preprocessing/export_sampled_frames.py

"""
1. 导出的核心数据类型
对于每一个被采样到的视频帧，脚本会提取并保存以下 5 种数据：

Color (RGB 图像): 从原始流中解压 JPEG 颜色数据，支持根据 --image_size 参数重新调整分辨率（Resize），最终保存为 .jpg 格式。

Depth (深度图): 解压深度数据，并将其转化为 16-bit 灰度图的 .png 格式保存。

Pose (相机外参/位姿): 获取该帧对应的相机到世界坐标系的 4x4 变换矩阵（Camera-to-World）。特别地，脚本会读取 ScanNet 场景的元数据（scene_id.txt），获取 axisAlignment 矩阵，将原始的相机位姿对齐到统一的全局重力坐标系下，最后保存为 .txt 文件。

Instance Mask (实例分割掩码): 如果同级目录下存在 2d-instance-filt.zip 文件，脚本会自动去解压并匹配对应帧的 2D 实例/语义标签掩码，保存为 .png。

Intrinsics (相机内参): 解析元数据中的焦距和主点坐标（fx, fy, mx, my），构建 4x4 的深度图相机内参矩阵并保存。
"""

import argparse
import os
import sys
import cv2  # Requires opencv-python
import numpy as np
from tqdm import tqdm  # Requires tqdm
import glob
import concurrent.futures
import math
import png # Requires pypng
import zipfile # Added for zip file handling
import shutil # Added for file copying
sensor_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(sensor_dir) 
# Assuming SensorData is in the same directory or PYTHONPATH is set

from SensorData import SensorData

# Helper function to parse scene_id.txt
def parse_scene_meta_file(filename):
    """Parses the scene_id.txt file to extract axis alignment and depth intrinsics."""
    metadata = {}
    try:
        with open(filename, 'r') as f:
            for line in f:
                parts = line.strip().split(' = ')
                if len(parts) == 2:
                    key, value = parts
                    metadata[key.strip()] = value.strip()

        # Extract and reshape axis alignment matrix
        axis_align_str = metadata.get('axisAlignment')
        if axis_align_str:
            axis_align_vals = list(map(float, axis_align_str.split()))
            if len(axis_align_vals) == 16:
                axis_align_matrix = np.array(axis_align_vals).reshape(4, 4)
            else:
                print(f"Warning: Invalid number of values for axisAlignment in {filename}. Expected 16, got {len(axis_align_vals)}.")
                axis_align_matrix = None
        else:
            print(f"Warning: axisAlignment key not found in {filename}.")
            axis_align_matrix = None

        # Construct depth intrinsics matrix
        try:
            fx = float(metadata['fx_depth'])
            fy = float(metadata['fy_depth'])
            mx = float(metadata['mx_depth'])
            my = float(metadata['my_depth'])
            depth_intrinsics = np.array([
                [fx, 0, mx, 0],
                [0, fy, my, 0],
                [0, 0, 1, 0],
                [0, 0, 0, 1]
            ])
        except KeyError as e:
            print(f"Warning: Missing depth intrinsic key {e} in {filename}.")
            depth_intrinsics = None
        except ValueError as e:
            print(f"Warning: Invalid value for depth intrinsic key in {filename}: {e}.")
            depth_intrinsics = None

        return axis_align_matrix, depth_intrinsics

    except FileNotFoundError:
        print(f"Warning: Scene metadata file not found: {filename}")
        return None, None
    except Exception as e:
        print(f"Warning: Error parsing scene metadata file {filename}: {e}")
        return None, None

def save_matrix_to_file(matrix, filename):
    """Saves a numpy matrix to a text file."""
    with open(filename, 'w') as f:
        for row in matrix:
            f.write(' '.join(map(str, row)) + '\n')

def export_scene_sampled_frames(sens_file_path, output_base_dir, num_frames_to_sample, split, image_size=None, min_valid_components_per_frame_initial=0, min_valid_frames_per_scene=1):
    """Exports uniformly sampled pose, depth, color, instance mask, and intrinsics for a single scene, applying axis alignment to poses."""
    scene_id = os.path.basename(os.path.dirname(sens_file_path))
    scene_dir_path = os.path.dirname(sens_file_path)
    print(f"Processing scene: {scene_id} (split: {split})")
    print(f'Loading {sens_file_path}...')
    try:
        sd = SensorData(sens_file_path)
    except NameError:
        print("Error: SensorData class failed to be imported.")
        return None 
    except Exception as e:
        print(f"Error loading SensorData from {sens_file_path}: {e}")
        return None 
    print(f'Loaded {len(sd.frames)} frames.')

    if not hasattr(sd, 'frames') or not sd.frames:
        print("Error: SensorData object does not contain frames or is empty.")
        return None
    
    total_raw_frames = len(sd.frames)
    if total_raw_frames == 0:
        print(f"Scene {scene_id} has 0 frames. Skipping.")
        return scene_id 

    # --- Locate additional input files ---
    scene_meta_path = os.path.join(scene_dir_path, f"{scene_id}.txt")
    instance_zip_path = os.path.join(scene_dir_path, f"{scene_id}_2d-instance-filt.zip")
    if not os.path.exists(instance_zip_path):
         instance_zip_path = os.path.join(scene_dir_path, f"{scene_id}_2d-instance.zip")

    instance_zip = None
    if os.path.exists(instance_zip_path):
        try:
            instance_zip = zipfile.ZipFile(instance_zip_path, 'r')
            print(f"Opened instance mask zip: {instance_zip_path}")
        except zipfile.BadZipFile:
            print(f"Warning: Bad zip file: {instance_zip_path}. Instance masks will be unavailable.")
            instance_zip = None
        except Exception as e:
            print(f"Warning: Error opening zip file {instance_zip_path}: {e}. Instance masks will be unavailable.")
            instance_zip = None
    else:
        print(f"Warning: Instance mask zip file not found at {instance_zip_path} or fallback. Instance masks will be unavailable.")

    # --- Phase 1: Validate all available frames to create a list of candidates ---
    print(f"Validating all {total_raw_frames} available frames for scene {scene_id}...")
    valid_frame_candidates_info = [] 
    
    for original_idx in tqdm(range(total_raw_frames), desc=f"Validating raw frames for {scene_id}", leave=False):
        try:
            frame = sd.frames[original_idx]
            num_available_components = 0

            if hasattr(frame, 'camera_to_world') and frame.camera_to_world is not None:
                num_available_components += 1
            
            if hasattr(frame, 'decompress_depth') and hasattr(sd, 'depth_compression_type') and sd.depth_compression_type.lower() != 'unknown':
                num_available_components += 1

            if hasattr(frame, 'decompress_color') and hasattr(sd, 'color_compression_type') and sd.color_compression_type.lower() == 'jpeg':
                num_available_components += 1
            
            instance_mask_potentially_available = False
            if instance_zip:
                mask_filename_in_zip = f'instance-filt/{original_idx}.png' 
                try:
                    instance_zip.getinfo(mask_filename_in_zip) 
                    instance_mask_potentially_available = True
                except KeyError:
                    instance_mask_potentially_available = False 
                except Exception: 
                    instance_mask_potentially_available = False
            
            if instance_mask_potentially_available:
                num_available_components +=1

            if num_available_components >= min_valid_components_per_frame_initial:
                 valid_frame_candidates_info.append({"original_idx": original_idx})

        except IndexError:
            print(f"Warning: Raw frame index {original_idx} out of bounds during validation for scene {scene_id}.")
            continue 
        except Exception as e_val:
            print(f"Warning: Error validating raw frame {original_idx} for scene {scene_id}: {e_val}. Skipping candidate.")
            continue
            
    if not valid_frame_candidates_info:
        print(f"No valid frame candidates found for scene {scene_id} after initial validation. Skipping scene processing.")
        if instance_zip: instance_zip.close()
        return None 

    num_candidates = len(valid_frame_candidates_info)
    print(f"Found {num_candidates} valid frame candidates for scene {scene_id}.")

    # --- Sampling Logic based on validated candidates ---
    if num_candidates <= num_frames_to_sample:
        selected_candidate_indices = np.arange(num_candidates)
    else:
        selected_candidate_indices = np.linspace(0, num_candidates - 1, num_frames_to_sample, dtype=int)
        selected_candidate_indices = np.unique(selected_candidate_indices)

    actual_indices_to_process = [valid_frame_candidates_info[i]["original_idx"] for i in selected_candidate_indices]
    if not actual_indices_to_process: # Should not happen if valid_frame_candidates_info is not empty
        print(f"No frames selected for processing for scene {scene_id} after sampling (num_candidates: {num_candidates}, num_frames_to_sample: {num_frames_to_sample}). Skipping.")
        if instance_zip: instance_zip.close()
        return None
    print(f"Selected {len(actual_indices_to_process)} frames for export. First few original indices: {actual_indices_to_process[:10]}...")


    # --- Create output directories ---
    pose_output_dir = os.path.join(output_base_dir, 'pose', split, scene_id)
    depth_output_dir = os.path.join(output_base_dir, 'depth', split, scene_id)
    color_output_dir = os.path.join(output_base_dir, 'color', split, scene_id)
    instance_output_dir = os.path.join(output_base_dir, 'instance', split, scene_id)
    intrinsic_base_output_dir = os.path.join(output_base_dir, 'intrinsic', split)
    
    os.makedirs(pose_output_dir, exist_ok=True)
    os.makedirs(depth_output_dir, exist_ok=True)
    os.makedirs(color_output_dir, exist_ok=True)
    os.makedirs(instance_output_dir, exist_ok=True)
    os.makedirs(intrinsic_base_output_dir, exist_ok=True)

    # --- Process scene-level data ---
    axis_align_matrix, intrinsics_matrix = parse_scene_meta_file(scene_meta_path)
    if intrinsics_matrix is not None:
        intrinsic_out_filename = os.path.join(intrinsic_base_output_dir, f'intrinsic_depth_{scene_id}.txt')
        save_matrix_to_file(intrinsics_matrix, intrinsic_out_filename)
        print(f"Saved intrinsics to {intrinsic_out_filename}")
    else:
        print(f"Warning: Could not read/parse or save intrinsics for scene {scene_id} from {scene_meta_path}.")

    if axis_align_matrix is None:
        print(f"Warning: Could not read/parse axis alignment matrix for scene {scene_id} from {scene_meta_path}. Poses will NOT be aligned.")

    # --- Phase 2: Process and Save Selected Frames ---
    processed_attempt_count = 0 
    final_valid_frames_count = 0 
    total_skipped_components_in_export = 0 
    min_successful_components_per_frame_export = min_valid_components_per_frame_initial
    
    try:
        for original_idx in tqdm(actual_indices_to_process, desc=f"Exporting selected frames for {scene_id}", leave=False):
            try:
                frame = sd.frames[original_idx] 
                components_skipped_this_frame_export = 0
                
                pose_saved_path = None
                depth_saved_path = None
                color_saved_path = None
                instance_saved_path = None
                color_export_failed_critically = False

                # Export Pose
                if hasattr(frame, 'camera_to_world') and frame.camera_to_world is not None:
                    pose_matrix_original = frame.camera_to_world
                    pose_filename = os.path.join(pose_output_dir, f'{original_idx:06d}.txt')
                    if axis_align_matrix is not None:
                        try:
                            aligned_pose = np.dot(axis_align_matrix, pose_matrix_original)
                            save_matrix_to_file(aligned_pose, pose_filename)
                            pose_saved_path = pose_filename
                        except ValueError as e:
                            print(f"Warning: Error applying axis alignment for frame {original_idx}: {e}. Saving original.")
                            save_matrix_to_file(pose_matrix_original, pose_filename)
                            pose_saved_path = pose_filename 
                        except Exception as e:
                            print(f"Warning: Unexpected error during pose alignment/saving for frame {original_idx}: {e}. Skip pose comp.")
                            components_skipped_this_frame_export += 1
                    else:
                        save_matrix_to_file(pose_matrix_original, pose_filename)
                        pose_saved_path = pose_filename
                else:
                    print(f"Warning: Pose data not found for pre-validated frame {original_idx} during export. Skip pose comp.")
                    components_skipped_this_frame_export += 1

                # Export Depth
                if hasattr(frame, 'decompress_depth') and hasattr(sd, 'depth_compression_type') and sd.depth_compression_type.lower() != 'unknown':
                    depth_data = frame.decompress_depth(sd.depth_compression_type)
                    if depth_data is not None:
                        try:
                            depth_image = np.frombuffer(depth_data, dtype=np.uint16).reshape(sd.depth_height, sd.depth_width)
                            depth_filename = os.path.join(depth_output_dir, f'{original_idx:06d}.png')
                            depth_image_reshaped = depth_image.reshape(-1, depth_image.shape[1]).tolist()
                            with open(depth_filename, 'wb') as f_png:
                                writer = png.Writer(width=depth_image.shape[1], height=depth_image.shape[0], bitdepth=16, greyscale=True)
                                writer.write(f_png, depth_image_reshaped)
                            depth_saved_path = depth_filename
                        except (ValueError, AttributeError, Exception) as e: # Catch specific and general errors
                            print(f"Warning: Error processing/writing depth for frame {original_idx}: {e}. Skip depth comp.")
                            components_skipped_this_frame_export += 1
                    else:
                        print(f"Warning: Decompressed null depth data for frame {original_idx}. Skip depth comp.")
                        components_skipped_this_frame_export += 1
                else:
                    print(f"Warning: Depth data/decompression not available for pre-validated frame {original_idx}. Skip depth comp.")
                    components_skipped_this_frame_export += 1

                # Export Color
                if hasattr(frame, 'decompress_color') and hasattr(sd, 'color_compression_type') and sd.color_compression_type.lower() == 'jpeg':
                    color_image = frame.decompress_color(sd.color_compression_type)
                    if color_image is not None:
                        try:
                            color_filename = os.path.join(color_output_dir, f'{original_idx:06d}.jpg')
                            if image_size:
                                color_image_resized = cv2.resize(color_image, (image_size[1], image_size[0]))
                            else:
                                color_image_resized = color_image
                            color_image_bgr = cv2.cvtColor(color_image_resized, cv2.COLOR_RGB2BGR)
                            if not cv2.imwrite(color_filename, color_image_bgr):
                                raise ValueError(f"cv2.imwrite failed for color {color_filename}")
                            color_saved_path = color_filename
                        except Exception as e:
                            print(f"Warning: Error saving color image for frame {original_idx}: {e}. CRITICAL: Skip color & FRAME.")
                            components_skipped_this_frame_export += 1
                            color_export_failed_critically = True
                    else:
                        print(f"Warning: Decompressed null color data for frame {original_idx}. CRITICAL: Skip color & FRAME.")
                        components_skipped_this_frame_export += 1
                        color_export_failed_critically = True
                else:
                    print(f"Warning: Color data/decompression not JPEG for pre-validated frame {original_idx}. CRITICAL: Skip color & FRAME.")
                    components_skipped_this_frame_export += 1
                    color_export_failed_critically = True

                if color_export_failed_critically:
                    if pose_saved_path and os.path.exists(pose_saved_path): os.remove(pose_saved_path)
                    if depth_saved_path and os.path.exists(depth_saved_path): os.remove(depth_saved_path)
                    total_skipped_components_in_export += (4 - components_skipped_this_frame_export) # Add remaining potential skips
                    processed_attempt_count += 1
                    continue 

                # Export Instance Mask
                if instance_zip:
                    mask_filename_in_zip = f'instance-filt/{original_idx}.png'
                    instance_output_filename = os.path.join(instance_output_dir, f'{original_idx:06d}.png')
                    try:
                        with instance_zip.open(mask_filename_in_zip, 'r') as mask_file:
                            mask_data = mask_file.read()
                        instance_mask = cv2.imdecode(np.frombuffer(mask_data, np.uint8), cv2.IMREAD_UNCHANGED)
                        if instance_mask is None: raise ValueError(f"cv2.imdecode failed for {mask_filename_in_zip}")
                        if image_size:
                            target_h, target_w = image_size
                            instance_mask = cv2.resize(instance_mask, (target_w, target_h), interpolation=cv2.INTER_NEAREST)
                        if not cv2.imwrite(instance_output_filename, instance_mask):
                            raise ValueError(f"cv2.imwrite failed for instance {instance_output_filename}")
                        instance_saved_path = instance_output_filename
                    except KeyError:
                        print(f"Warning: Instance mask {mask_filename_in_zip} not in zip for frame {original_idx}. Skip instance comp.")
                        components_skipped_this_frame_export += 1
                    except Exception as e:
                        print(f"Warning: Error processing instance mask {mask_filename_in_zip} for frame {original_idx}: {e}. Skip instance comp.")
                        components_skipped_this_frame_export += 1
                elif not instance_zip: # Instance masks were not available for the scene
                    pass # Not a skip for this frame if unavailable for scene, handled by num_successfully_exported

                processed_attempt_count += 1
                total_skipped_components_in_export += components_skipped_this_frame_export

                num_successfully_exported_components = 0
                if pose_saved_path: num_successfully_exported_components +=1
                if depth_saved_path: num_successfully_exported_components +=1
                if color_saved_path: num_successfully_exported_components +=1
                if instance_saved_path: num_successfully_exported_components +=1
                
                if num_successfully_exported_components >= min_successful_components_per_frame_export:
                    final_valid_frames_count += 1
                else:
                    print(f"Info: Frame {original_idx} did not meet min successful components ({num_successfully_exported_components}/{min_successful_components_per_frame_export}). Cleaning up.")
                    if pose_saved_path and os.path.exists(pose_saved_path): os.remove(pose_saved_path)
                    if depth_saved_path and os.path.exists(depth_saved_path): os.remove(depth_saved_path)
                    if color_saved_path and os.path.exists(color_saved_path): os.remove(color_saved_path)
                    if instance_saved_path and os.path.exists(instance_saved_path): os.remove(instance_saved_path)

            except IndexError: 
                print(f"Warning: Frame index {original_idx} out of bounds for scene {scene_id} during export. Critical error.")
                break 
            except Exception as e:
                print(f"Warning: Unhandled error processing selected frame {original_idx} for scene {scene_id}: {e}. Skipping frame.")
                total_skipped_components_in_export += 4 
                processed_attempt_count += 1
                continue
    finally:
        if instance_zip:
            instance_zip.close()
            print(f"Closed instance mask zip for {scene_id}")

    scene_export_successful = False
    if total_raw_frames == 0:
        scene_export_successful = True 
    elif processed_attempt_count > 0 and final_valid_frames_count >= min_valid_frames_per_scene:
        scene_export_successful = True
    elif not actual_indices_to_process and total_raw_frames > 0 : 
        scene_export_successful = False 
    else: 
        scene_export_successful = False
        
    if scene_export_successful:
        print(f'Finished exporting for scene {scene_id} (split: {split}).')
        print(f'Initial valid candidates: {num_candidates}. Selected for processing: {len(actual_indices_to_process)}.')
        print(f'Attempted export for {processed_attempt_count} selected frames.')
        print(f'Number of finally valid frames (>= {min_successful_components_per_frame_export} components exported): {final_valid_frames_count} (required >= {min_valid_frames_per_scene}).')
        if total_skipped_components_in_export > 0:
            print(f'Skipped {total_skipped_components_in_export} components during export phase.')
        return scene_id
    else:
        print(f"Failed to export scene {scene_id} (split: {split}).")
        print(f"  Initial valid candidates: {num_candidates}. Selected for processing: {len(actual_indices_to_process)}.")
        print(f"  Attempted export for {processed_attempt_count} selected frames.")
        print(f"  Number of finally valid frames (>= {min_successful_components_per_frame_export} components exported): {final_valid_frames_count} (required >= {min_valid_frames_per_scene}).")
        if not valid_frame_candidates_info and total_raw_frames > 0:
            print("  Reason: No frame candidates passed initial validation.")
        elif not actual_indices_to_process and valid_frame_candidates_info:
             print("  Reason: No frames were selected from candidates for processing.")
        elif final_valid_frames_count < min_valid_frames_per_scene and processed_attempt_count > 0 :
             print(f"  Reason: Number of finally valid frames ({final_valid_frames_count}) is less than the required minimum ({min_valid_frames_per_scene}).")
        return None

def main():
    parser = argparse.ArgumentParser(description="Export uniformly sampled pose (axis-aligned), depth, color, and instance masks from ScanNet .sens files, along with intrinsics, organised by train/val splits.")
    parser.add_argument('--scans_dir', required=True, help='Path to the directory containing scene subdirectories (e.g., data/scannet/scans)')
    parser.add_argument('--output_dir', required=True, help='Path to the base directory where output train/val folders (containing pose/depth/color/instance_mask/intrinsic) will be saved')
    parser.add_argument('--train_val_splits_path', type=str, default=None, help='Path to the directory containing scannetv2_train.txt and scannetv2_val.txt (optional). If provided, scenes will be sorted into train/val subfolders.')
    parser.add_argument('--num_frames', type=int, default=32, help='Number of frames to uniformly sample (default: 32)')
    parser.add_argument('--max_workers', type=int, default=None, help='Maximum number of processes to use for parallel processing (default: number of cores)')
    parser.add_argument('--image_size', type=int, nargs=2, metavar=('HEIGHT', 'WIDTH'), default=None, help='Target image size (height width) to resize color and instance images to (default: None)')
    parser.add_argument('--skip_existing', action='store_true', help='Skip processing scenes if their ID is found in the corresponding successful_scenes_<split>.txt in the output directory, or if output data directories exist.')
    parser.add_argument('--scene_list_file', type=str, default=None, help='Path to a text file containing a list of scene IDs to process, one per line. If provided, --scans_dir is still used to locate these scenes.')
    parser.add_argument('--min_valid_components_per_frame', type=int, default=0, help='Minimum number of components (pose, depth, color, instance) that must be available for a frame to be a candidate for sampling, AND successfully exported for a frame to be considered valid post-export. Default 0.')
    parser.add_argument('--min_valid_frames_per_scene', type=int, default=1, help='Minimum number of valid frames required for a scene to be considered successfully processed. Default 1.')


    opt = parser.parse_args()
    print("Script Options:")
    print(vars(opt)) 

    if opt.image_size and len(opt.image_size) != 2:
        print("Error: --image_size requires two arguments: HEIGHT WIDTH")
        sys.exit(1)
    if opt.image_size:
        print(f"Color images will be resized to Height={opt.image_size[0]}, Width={opt.image_size[1]}")

    train_scenes = set()
    val_scenes = set()
    if opt.train_val_splits_path:
        train_file_path = os.path.join(opt.train_val_splits_path, 'scannetv2_train.txt')
        val_file_path = os.path.join(opt.train_val_splits_path, 'scannetv2_val.txt')
        try:
            with open(train_file_path, 'r') as f:
                train_scenes = set(line.strip() for line in f if line.strip())
            print(f"Loaded {len(train_scenes)} train scene IDs from {train_file_path}")
        except FileNotFoundError:
            print(f"Warning: Train split file not found: {train_file_path}.")
        except Exception as e:
            print(f"Warning: Error reading train split file {train_file_path}: {e}")

        try:
            with open(val_file_path, 'r') as f:
                val_scenes = set(line.strip() for line in f if line.strip())
            print(f"Loaded {len(val_scenes)} val scene IDs from {val_file_path}")
        except FileNotFoundError:
            print(f"Warning: Validation split file not found: {val_file_path}.")
        except Exception as e:
            print(f"Warning: Error reading validation split file {val_file_path}: {e}")

        if not train_scenes and not val_scenes:
             print("Warning: Train/Val split path provided, but failed to load any scenes from the split files.")
    else:
        print("Train/Val split path not provided. Scenes will not be assigned to train/val splits and processing might be skipped depending on skip logic.")

    if not os.path.exists(opt.output_dir):
        print(f"Creating output directory: {opt.output_dir}")
        os.makedirs(opt.output_dir, exist_ok=True)

    successful_scenes_list_files = {
        'train': os.path.join(opt.output_dir, 'successful_scenes_train.txt'),
        'val': os.path.join(opt.output_dir, 'successful_scenes_val.txt')
    }
    existing_successful_scenes = {'train': set(), 'val': set()}

    if opt.skip_existing:
        for split_key, list_file in successful_scenes_list_files.items(): # Use split_key consistently
             if os.path.exists(list_file):
                try:
                    with open(list_file, 'r') as f:
                        existing_successful_scenes[split_key] = set(line.strip() for line in f if line.strip())
                    print(f"Loaded {len(existing_successful_scenes[split_key])} previously successful {split_key} scene IDs from {list_file}")
                except Exception as e:
                    print(f"Warning: Could not read {list_file}: {e}. Proceeding without skipping based on this list for {split_key} split.")

    scenes_to_consider = []
    if opt.scene_list_file:
        if not os.path.exists(opt.scene_list_file):
            print(f"Error: Scene list file not found: {opt.scene_list_file}")
            sys.exit(1)
        if not opt.scans_dir: # scans_dir is needed to locate the data
            print(f"Error: --scans_dir must be provided when using --scene_list_file.")
            sys.exit(1)
        try:
            with open(opt.scene_list_file, 'r') as f:
                target_scene_ids = [line.strip() for line in f if line.strip()]
            print(f"Loaded {len(target_scene_ids)} scene IDs from {opt.scene_list_file}")
            for scene_id_val in target_scene_ids: # Use scene_id_val to avoid conflict
                scene_dir_path = os.path.join(opt.scans_dir, scene_id_val)
                if os.path.isdir(scene_dir_path):
                    scenes_to_consider.append(scene_dir_path)
                else:
                    print(f"Warning: Scene directory for ID '{scene_id_val}' not found at {scene_dir_path}. Skipping.")
        except Exception as e:
            print(f"Error reading scene list file {opt.scene_list_file}: {e}")
            sys.exit(1)
    else:
        if not opt.scans_dir:
            print(f"Error: --scans_dir must be provided if --scene_list_file is not used.")
            sys.exit(1)
        try:
            scenes_to_consider = [d.path for d in os.scandir(opt.scans_dir) if d.is_dir()]
        except FileNotFoundError:
            print(f"Error: Scans directory not found: {opt.scans_dir}")
            sys.exit(1)
        except Exception as e:
            print(f"Error scanning directory {opt.scans_dir}: {e}")
            sys.exit(1)

    if not scenes_to_consider:
        print(f"No scene directories found or specified to process. Exiting.")
        sys.exit(0)

    print(f"Found {len(scenes_to_consider)} potential scene directories to evaluate.")

    total_scenes_found = len(scenes_to_consider) 
    successful_scenes_this_run = {'train': [], 'val': []} 
    scenes_to_process_args_list = [] 

    skipped_due_to_sens_or_skip_flag = 0
    skipped_due_to_no_split = 0
    for scene_dir_path in scenes_to_consider:
        current_scene_id = os.path.basename(scene_dir_path) # Renamed to avoid conflict
        sens_file_path = os.path.join(scene_dir_path, f"{current_scene_id}.sens")
        
        if not os.path.exists(sens_file_path):
            print(f"Warning: .sens file not found for scene {current_scene_id}. Skipping.")
            skipped_due_to_sens_or_skip_flag += 1
            continue

        current_split = None # Renamed to avoid conflict
        if opt.train_val_splits_path:
            if current_scene_id in train_scenes:
                current_split = 'train'
            elif current_scene_id in val_scenes:
                current_split = 'val'
            else:
                skipped_due_to_no_split += 1
                continue 
        else:
             print(f"Warning: --train_val_splits_path not provided. Skipping scene {current_scene_id} as split assignment is required.")
             skipped_due_to_no_split += 1
             continue

        if opt.skip_existing:
            if current_scene_id in existing_successful_scenes[current_split]:
                print(f"Scene {current_scene_id} (split: {current_split}) found in successful list. Skipping.")
                skipped_due_to_sens_or_skip_flag += 1
                continue

            # Simplified output path check - check for one key output directory for the scene in its split
            scene_output_check_path = os.path.join(opt.output_dir, current_split, 'pose', current_scene_id) # Check e.g. pose dir
            if os.path.exists(scene_output_check_path):
                 print(f"Output data likely exists for scene {current_scene_id} (split: {current_split}). Skipping.")
                 skipped_due_to_sens_or_skip_flag += 1
                 continue
        
        scenes_to_process_args_list.append((sens_file_path, opt.output_dir, opt.num_frames, current_split, opt.image_size, opt.min_valid_components_per_frame, opt.min_valid_frames_per_scene))

    num_scenes_to_actually_process = len(scenes_to_process_args_list)
    print(f"Skipped {skipped_due_to_sens_or_skip_flag} scenes based on missing .sens or --skip_existing flag.")
    if skipped_due_to_no_split > 0:
        print(f"Skipped {skipped_due_to_no_split} scenes because they were not found in train/val lists or --train_val_splits_path was not provided/required.")
    print(f"Attempting to process {num_scenes_to_actually_process} scenes.")

    if num_scenes_to_actually_process == 0:
        print("No scenes left to process. Exiting.")
        sys.exit(0)

    print(f"Starting parallel export using up to {opt.max_workers or os.cpu_count()} workers...")
    with concurrent.futures.ProcessPoolExecutor(max_workers=opt.max_workers) as executor:
        futures_map = {}
        # Unpack arguments correctly for submit
        for sens_path_arg, output_base_arg, num_frames_arg, split_arg, image_size_arg, min_comp_arg, min_frames_arg in scenes_to_process_args_list:
            # Need scene_id for futures_map key association, extract from sens_path_arg
            proc_scene_id = os.path.basename(os.path.dirname(sens_path_arg))
            future = executor.submit(export_scene_sampled_frames, sens_path_arg, output_base_arg, num_frames_arg, split_arg, image_size_arg, min_comp_arg, min_frames_arg)
            futures_map[future] = (proc_scene_id, split_arg) # Use proc_scene_id and split_arg

        processed_counts_this_run = {'train': 0, 'val': 0} # Renamed for clarity
        failed_counts_this_run = {'train': 0, 'val': 0}    # Renamed for clarity
        for future in tqdm(concurrent.futures.as_completed(futures_map), total=len(futures_map), desc="Processing Scenes"):
            result_scene_id, result_split = futures_map[future] # Get associated scene_id and split
            try:
                returned_scene_id = future.result() 
                if returned_scene_id is not None: # export_scene_sampled_frames returns scene_id on success
                    successful_scenes_this_run[result_split].append(returned_scene_id)
                    processed_counts_this_run[result_split] += 1
                else:
                    failed_counts_this_run[result_split] += 1 
            except Exception as exc:
                print(f'\nScene {result_scene_id} (split: {result_split}) generated an exception during execution: {exc}')
                failed_counts_this_run[result_split] += 1

    all_successful_scenes_combined = {'train': set(), 'val': set()} # Renamed for clarity
    for split_key in ['train', 'val']: # Use split_key consistently
        if successful_scenes_this_run[split_key]:
            current_split_successful_combined = existing_successful_scenes[split_key].union(set(successful_scenes_this_run[split_key]))
            all_successful_scenes_combined[split_key] = current_split_successful_combined
            list_file = successful_scenes_list_files[split_key]
            try:
                with open(list_file, 'w') as f: 
                    for scene_id_val in sorted(list(current_split_successful_combined)): 
                        f.write(scene_id_val + '\n')
                print(f"Updated successful {split_key} scenes list at: {list_file}")
            except Exception as e:
                print(f"Error writing successful {split_key} scenes list to {list_file}: {e}")
        else:
             all_successful_scenes_combined[split_key] = existing_successful_scenes[split_key]


    total_processed_in_this_run = sum(processed_counts_this_run.values())
    total_failed_in_this_run = sum(failed_counts_this_run.values())
    total_successful_over_all_runs = sum(len(s) for s in all_successful_scenes_combined.values())


    print("\n" + "=" * 30)
    print("Processing Summary:")
    print(f"Total potential scenes found: {total_scenes_found}")
    print(f"Scenes skipped (missing .sens / --skip_existing): {skipped_due_to_sens_or_skip_flag}")
    print(f"Scenes skipped (no split assignment): {skipped_due_to_no_split}")
    print(f"Scenes submitted for processing in this run: {num_scenes_to_actually_process}")
    print(f"  - Train: {processed_counts_this_run['train']} successful, {failed_counts_this_run['train']} failed")
    print(f"  - Val:   {processed_counts_this_run['val']} successful, {failed_counts_this_run['val']} failed")
    print(f"Total successfully processed scenes (this run): {total_processed_in_this_run}")
    print(f"Total failed/incomplete scenes (this run): {total_failed_in_this_run}")
    print("-" * 30)
    print(f"Total successful scenes across all runs:")
    print(f"  - Train: {len(all_successful_scenes_combined['train'])} (list: {successful_scenes_list_files['train']})")
    print(f"  - Val:   {len(all_successful_scenes_combined['val'])} (list: {successful_scenes_list_files['val']})")
    print(f"  - Overall: {total_successful_over_all_runs}")
    print("Note: Success indicates the scene processing completed. Check logs for skipped components or frames.")
    print("=" * 30)

if __name__ == '__main__':
    main()