Code/benchmark/environment_evaluation/run_benchmark.py

#!/usr/bin/env python3
"""
SAGE-3D Benchmark Runner.

Main script for running VLN (Vision-and-Language Navigation) benchmark evaluation
on SAGE-3D dataset using Isaac Sim environment.

Usage:
    python run_benchmark.py --batch-dir /path/to/test/data --scene-folder /path/to/scenes \\
        --out-root /path/to/output --vlm-host localhost --vlm-port 54321

For distributed testing:
    python run_benchmark.py --batch-dir /path/to/data --scene-folder /path/to/scenes \\
        --out-root /path/to/output --vlm-host localhost --vlm-port 54321 \\
        --instance-id 0 --total-instances 4
"""

import os
import sys

_vlm_server_disconnected = False

def _init_global_silent_mode():
    """Initialize global silent mode before any module imports.
    
    Filters empty lines and debug output from print statements.
    """
    print(f"[INIT] Enabling smart print filter - filtering empty lines and debug info")
    
    # Enable basic empty line filtering regardless of --silent-logging
    original_print = print
    def smart_filtered_print(*args, **kwargs):
        # Skip if no args or all args are empty
        if not args or all(str(arg).strip() == '' for arg in args):
            return
        
        # Check for pure empty line
        if len(args) == 1 and str(args[0]).strip() == '':
            return
            
        # If silent-logging enabled, apply stricter filtering
        if '--silent-logging' in sys.argv:
            if args:
                msg = str(args[0])
                # Filter debug tags
                debug_tags = ['[COLLISION_2D]', '[PHYSICS]', '[CAMERA_UPDATE]',
                            '[RGB_CAPTURE]', '[COLLISION_VIS]', '[YAW_UPDATE]',
                            '[COORD_TRANSFORM]', '[POSITION]', '[VELOCITY]',
                            '[DEBUG_ENV]', '[EPISODE_RESET]', '[SUCCESS]',
                            '[ORACLE_SUCCESS]', '[CSR]', '[OBJECT_SUCCESS]']
                if any(tag in msg for tag in debug_tags):
                    return
        
        # Print other content normally
        original_print(*args, **kwargs)
    
    # Replace global print function
    import builtins
    builtins.print = smart_filtered_print
    
    if '--silent-logging' in sys.argv:
        print(f"[INIT] Detected --silent-logging argument, enabling strict filter mode")
        os.environ['SILENT_LOGGING_MODE'] = 'True'
    else:
        print(f"[INIT] Basic filter mode: only filtering empty lines")


# Execute immediately
_init_global_silent_mode()

import io
import json
import math
import argparse
import logging
import glob
import time
import datetime
from pathlib import Path
from typing import List, Dict, Any

import numpy as np
from PIL import Image

# For trajectory visualization
try:
    pass
    import matplotlib
    matplotlib.use('Agg')  # Use non-interactive backend
    import matplotlib.pyplot as plt
    MATPLOTLIB_AVAILABLE = True
except ImportError:
    pass
    MATPLOTLIB_AVAILABLE = False
    print("[WARN] matplotlib not available, trajectory visualization will be disabled")


class ProgressTracker:
    """Progress tracker - real-time display of test progress info"""
    
    def __init__(self, total_episodes: int, model_name: str = "Unknown", enable_live_display: bool = True):
        self.total_episodes = total_episodes
        self.model_name = model_name
        self.completed_episodes = 0
        self.failed_episodes = 0
        self.skipped_episodes = 0
        self.start_time = time.time()
        self.last_update_time = time.time()
        self.episode_times = []
        self.enable_live_display = enable_live_display
        self.last_displayed_episode = 0
        self.global_episode_counter = 0
        
        # Save original terminal settings
        import sys
        self.stdout = sys.stdout
        
        # Display initial progress
        if self.enable_live_display:
            pass
            self._display_progress_header()
        
    def start_episode(self, episode_id: str, scene_name: str, episode_idx: int):
        """Start processing episode"""
        self.global_episode_counter += 1
        self.current_episode_start = time.time()
        self.current_episode_id = episode_id
        self.current_scene_name = scene_name
        self.current_episode_idx = episode_idx
        
        # Real-time progress update (more frequent updates to ensure visibility)
        if self.enable_live_display and (self.global_episode_counter % 5 == 0 or self.global_episode_counter <= 3 or self.global_episode_counter == self.total_episodes):
            self._update_live_progress(self.global_episode_counter)
    
    def complete_episode(self, success: bool = True, skipped: bool = False):
        """Complete episode processing"""
        episode_time = time.time() - self.current_episode_start
        self.episode_times.append(episode_time)
        
        if skipped:
            pass
            self.skipped_episodes += 1
            status_char = "⏭️"
        elif success:
            pass
            self.completed_episodes += 1
            status_char = "✅"
        else:
            pass
            self.failed_episodes += 1
            status_char = "❌"
        
        # Compact episode completion info (doesn't interfere with main progress display)
        compact_status = f"[{self.global_episode_counter:4d}/{self.total_episodes}] {status_char} {self.current_scene_name}/{self.current_episode_id} ({self._format_duration(episode_time)})"
        print(compact_status, flush=True)
        
        # Ensure progress info is displayed promptly (force write to stdout)
        import sys
        sys.stdout.flush()
        
        # Keep last 20 episode times for ETA calculation
        if len(self.episode_times) > 20:
            pass
            self.episode_times = self.episode_times[-20:]
            
        # Show detailed progress every 10 episodes (more frequent)
        if self.enable_live_display and self.global_episode_counter % 10 == 0:
            self._update_live_progress(self.global_episode_counter, force_display=True)
    
    def _display_progress_header(self):
        """Display progress bar header"""
        print(f"\n{'='*100}")
        print(f"🚀 SAGE-Bench Test Progress - Model: {self.model_name}")
        print(f"📊 Total Episodes: {self.total_episodes}")
        print(f"⏰ Start Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"{'='*100}")
        print("[Progress] [Status] Episode Info")
        print("-" * 100)
    
    def _update_live_progress(self, episode_idx: int, force_display: bool = False):
        """Update live progress display"""
        # Avoid too frequent updates (reduced interval for responsiveness)
        current_time = time.time()
        if not force_display and current_time - self.last_update_time < 3:  # 3 second interval
            return
            
        self.last_update_time = current_time
        
        # Calculate progress
        progress_pct = (episode_idx / self.total_episodes) * 100
        
        # Calculate time info
        elapsed_time = current_time - self.start_time
        if self.episode_times:
            pass
            avg_time = sum(self.episode_times) / len(self.episode_times)
            remaining_episodes = self.total_episodes - episode_idx
            eta_seconds = avg_time * remaining_episodes
            eta_str = self._format_duration(eta_seconds)
        else:
            pass
            eta_str = "Calculating..."
        
        # Progress bar
        bar_length = 50
        filled_length = int(bar_length * episode_idx // self.total_episodes)
        bar = '█' * filled_length + '░' * (bar_length - filled_length)
        
        # Print colored progress info
        print(f"\n{'='*100}")
        print(f"📊 Progress: [{bar}] {progress_pct:.1f}% ({episode_idx}/{self.total_episodes})")
        print(f"⏱️  Elapsed: {self._format_duration(elapsed_time)} | ETA: {eta_str}")
        print(f"📈 Success: {self.completed_episodes} | Failed: {self.failed_episodes} | Skipped: {self.skipped_episodes}")
        if self.episode_times:
            pass
            success_rate = (self.completed_episodes / max(1, self.completed_episodes + self.failed_episodes)) * 100
            avg_time_str = self._format_duration(sum(self.episode_times) / len(self.episode_times))
            print(f"⚡ Success Rate: {success_rate:.1f}% | Avg Time: {avg_time_str}/episode")
        print(f"{'='*100}\n", flush=True)
    
    def final_summary(self):
        """Display final summary"""
        total_time = time.time() - self.start_time
        total_str = self._format_duration(total_time)
        
        print(f"\n{'🎉 SAGE-Bench Test Complete!':<50}")
        print(f"{'='*100}")
        print(f"🤖 Model: {self.model_name}")
        print(f"📊 Total Episodes: {self.total_episodes}")
        print(f"✅ Completed: {self.completed_episodes}")
        print(f"❌ Failed: {self.failed_episodes}")
        print(f"⏭️  Skipped: {self.skipped_episodes}")
        
        # Calculate success rate (excluding skipped)
        tested_episodes = self.completed_episodes + self.failed_episodes
        if tested_episodes > 0:
            pass
            success_rate = (self.completed_episodes / tested_episodes) * 100
            print(f"📈 Success Rate: {success_rate:.1f}% (based on {tested_episodes} actual tests)")
        
        print(f"⏱️  Total Time: {total_str}")
        if self.episode_times:
            pass
            avg_time = sum(self.episode_times) / len(self.episode_times)
            print(f"⚡ Avg Time: {self._format_duration(avg_time)}/episode")
            
            # Performance analysis
            total_test_time = tested_episodes * avg_time
            efficiency = (total_test_time / total_time) * 100 if total_time > 0 else 0
            print(f"🔧 Test Efficiency: {efficiency:.1f}% (actual test time ratio)")
            
        print(f"🏁 End Time: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        print(f"{'='*100}")
    
    def _format_duration(self, seconds: float) -> str:
        """Format time display"""
        if seconds < 60:
            pass
            return f"{seconds:.1f}s"
        elif seconds < 3600:
            pass
            minutes = seconds / 60
            return f"{minutes:.1f}min"
        else:
            pass
            hours = seconds / 3600
            return f"{hours:.1f}h"
    
    def update_model_name(self, model_name: str):
        """Update model name"""
        self.model_name = model_name
    
    def force_progress_update(self):
        """Force progress update"""
        if hasattr(self, 'current_episode_idx'):
            pass
            self._update_live_progress(self.current_episode_idx, force_display=True)


# Add current script directory to Python path to ensure related modules can be found
import sys
current_dir = os.path.dirname(os.path.abspath(__file__))
if current_dir not in sys.path:
    sys.path.insert(0, current_dir)

try:
    # Try relative import (when running as a package)
    from .episodes_adapter import adapt_gvln_to_episodes
    from .measures import default_measures, nogoal_measures
    from .vlm_client_modular import query_vlm, set_log_function
    from .simple_env import SimpleVLNEnv
    from .task_types import TaskTypeManager, adapt_episode_for_task
except ImportError:
    # Fallback to absolute import (when running directly)
    try:
        from episodes_adapter import adapt_gvln_to_episodes
        from measures import default_measures, nogoal_measures
        from vlm_client_modular import query_vlm, set_log_function
        from simple_env import SimpleVLNEnv
        from task_types import TaskTypeManager, adapt_episode_for_task
    except ImportError as e:
        print(f"[ERROR] Failed to import required modules: {e}")
        print(f"[ERROR] Script directory: {current_dir}")
        print("[ERROR] Please ensure all required modules are in the same directory")
        sys.exit(1)


def find_test_json_files(batch_dir: str, pattern: str = "test_*.json") -> List[str]:
    """
    Scan directory and subdirectories to find all JSON files matching pattern
    
    Args:
        batch_dir: Batch test directory
        pattern: File pattern, default "test_*.json"
        
    Returns:
        List of matching JSON file paths
    """
    batch_path = Path(batch_dir)
    if not batch_path.exists():
        pass
        print(f"[ERROR] Batch test directory does not exist: {batch_dir}")
        return []
    
    # Recursively search for all matching JSON files
    json_files = []
    for root, dirs, files in os.walk(batch_path):
        for file in files:
            if file.startswith("test_") and file.endswith(".json"):
                pass
                file_path = os.path.join(root, file)
                json_files.append(file_path)
    
    json_files.sort()  # Sort by filename
    print(f"[INFO] Found {len(json_files)} test JSON files:")
    for i, file_path in enumerate(json_files, 1):
        rel_path = os.path.relpath(file_path, batch_dir)
        print(f"[INFO]   {i:3d}. {rel_path}")
    
    return json_files


def get_scene_name_from_json(json_file_path: str) -> str:
    """
    Extract scene_name from JSON file
    
    Args:
        json_file_path: JSON trajectory file path
        
    Returns:
        scene_name string, empty string if not found
    """
    try:
        pass
        with open(json_file_path, 'r') as f:
            data = json.load(f)
        
        # Extract scene_name from JSON data
        if "scenes" in data and len(data["scenes"]) > 0:
            scene_name = data["scenes"][0].get("scene_name", "")
            return scene_name
        else:
            print(f"[WARN] Cannot get scene_name from JSON file: {json_file_path}")
            return ""
    except Exception as e:
        print(f"[ERROR] Failed to read JSON file: {json_file_path}, error: {e}")
        return ""


def check_episode_completed(out_root: Path, scene_name: str, episode_id: str) -> bool:
    """
    Check if specified episode has completed testing (by checking measurements file existence)
    
    Args:
        out_root: Output root directory
        scene_name: Scene name
        episode_id: Trajectory-instruction pair ID
        
    Returns:
        True if completed, False if not
    """
    measurements_file = out_root / scene_name / episode_id / "measurements" / f"{episode_id}.json"
    exists = measurements_file.exists()
    
    if exists:
        pass
        # Additional validation: check if file is valid JSON with required fields
        try:
            pass
            with open(measurements_file, 'r') as f:
                data = json.load(f)
            # Check required fields
            required_fields = ["success", "spl", "path_length"]
            has_required_fields = all(field in data for field in required_fields)
            if has_required_fields:
                print(f"[CHECKPOINT] ✅ Episode {scene_name}/{episode_id} completed, skipping")
                return True
            else:
                print(f"[CHECKPOINT] ⚠️ Episode {scene_name}/{episode_id} measurements incomplete, re-testing")
                return False
        except (json.JSONDecodeError, Exception) as e:
            print(f"[CHECKPOINT] ⚠️ Episode {scene_name}/{episode_id} measurements corrupted, re-testing: {e}")
            return False
    else:
        print(f"[CHECKPOINT] ⏭️  Episode {scene_name}/{episode_id} not completed, starting test")
        return False


def find_matching_scene_file(json_file_path: str, scene_folder: str, scene_name: str = None) -> str:
    """
    Auto-match corresponding scene USDA file based on JSON file
    
    Args:
        json_file_path: JSON trajectory file path
        scene_folder: Scene folder path
        scene_name: Optional scene_name, will read from JSON file if not provided
        
    Returns:
        Matching scene file path, empty string if not found
    """
    if not scene_folder or not os.path.exists(scene_folder):
        pass
        print(f"[WARN] Scene folder does not exist or not specified: {scene_folder}")
        return ""
    
    # Read scene_name from JSON file if not provided
    if not scene_name:
        pass
        scene_name = get_scene_name_from_json(json_file_path)
    
    if not scene_name:
        pass
        print(f"[WARN] scene_name not found: {json_file_path}")
        return ""
    
    print(f"[SCENE_MATCH] Finding scene file for '{scene_name}'...")
    
    # Search for matching scene file
    # Scene file format: scene_name.usda or scene_name.usd
    scene_patterns = [
        f"{scene_name}.usda",
        f"{scene_name}.usd"
    ]
    
    for pattern in scene_patterns:
        scene_file = os.path.join(scene_folder, pattern)
        if os.path.exists(scene_file):
            pass
            print(f"[SCENE_MATCH] ✓ Found matching scene: {os.path.basename(scene_file)}")
            return scene_file
    
    # Try fuzzy matching if exact match not found
    print(f"[SCENE_MATCH] Trying fuzzy match...")
    for file in os.listdir(scene_folder):
        if (file.endswith(".usda") or file.endswith(".usd")) and scene_name in file:
            pass
            scene_file = os.path.join(scene_folder, file)
            print(f"[SCENE_MATCH] ✓ Fuzzy match found scene: {file}")
            return scene_file
    
    print(f"[SCENE_MATCH] ✗ No matching scene file found for '{scene_name}'")
    return ""


def find_matching_map_file(json_file_path: str, map_folder: str, scene_name: str = None) -> str:
    """
    Auto-match corresponding 2D semantic map file based on JSON file
    
    Args:
        json_file_path: JSON trajectory file path
        map_folder: Map folder path
        scene_name: Optional scene_name, will read from JSON file if not provided
        
    Returns:
        Matching map file path, empty string if not found
    """
    if not map_folder or not os.path.exists(map_folder):
        pass
        print(f"[WARN] Map folder does not exist or not specified: {map_folder}")
        return ""
    
    # Read scene_name from JSON file if not provided
    if not scene_name:
        pass
        scene_name = get_scene_name_from_json(json_file_path)
    
    if not scene_name:
        pass
        print(f"[WARN] scene_name not found: {json_file_path}")
        return ""
    
    print(f"[MAP_MATCH] Finding map file for '{scene_name}'...")
    
    # Search for matching map file
    # Map file format: 2D_Semantic_Map_xxxx_scene_name_Complete.json
    map_patterns = [
        f"2D_Semantic_Map_*_{scene_name}_Complete.json",
        f"2D_Semantic_Map_{scene_name}_Complete.json",
        f"*_{scene_name}_Complete.json",
        f"*{scene_name}*.json"
    ]
    
    for pattern in map_patterns:
        search_pattern = os.path.join(map_folder, pattern)
        matching_files = glob.glob(search_pattern)
        
        if matching_files:
            pass
            # Select first match if multiple files found
            map_file = matching_files[0]
            print(f"[MAP_MATCH] ✓ Found matching map: {os.path.basename(map_file)}")
            return map_file
    
    # Try fuzzy matching if exact match not found
    print(f"[MAP_MATCH] Trying fuzzy match...")
    for file in os.listdir(map_folder):
        if file.endswith(".json") and scene_name in file:
            pass
            map_file = os.path.join(map_folder, file)
            print(f"[MAP_MATCH] ✓ Fuzzy match found map: {file}")
            return map_file
    
    print(f"[MAP_MATCH] ✗ No matching map file found for '{scene_name}'")
    return ""


def save_batch_summary(batch_results: List[Dict[str, Any]], output_root: Path, model_info: str) -> None:
    """
    Save batch test summary results
    
    Args:
        batch_results: List of batch test results
        output_root: Output root directory
        model_info: Model info string
    """
    summary_file = output_root / "batch_test_summary.json"
    
    # Calculate summary statistics
    total_files = len(batch_results)
    total_episodes = sum(r["total_episodes"] for r in batch_results)
    total_successful = sum(r["successful_episodes"] for r in batch_results)
    total_failed = sum(r["failed_episodes"] for r in batch_results)
    
    overall_success_rate = total_successful / total_episodes if total_episodes > 0 else 0.0
    
    summary = {
        "model_info": model_info,
        "batch_summary": {
            "total_json_files": total_files,
            "total_episodes": total_episodes,
            "successful_episodes": total_successful,
            "failed_episodes": total_failed,
            "overall_success_rate": overall_success_rate
        },
        "file_results": batch_results
    }
    
    # Save summary results
    with open(summary_file, 'w') as f:
        json.dump(summary, f, indent=2)
    
    print(f"\n[BATCH_SUMMARY] ===== Batch Test Summary =====")
    print(f"[BATCH_SUMMARY] Model Info: {model_info}")
    print(f"[BATCH_SUMMARY] Test Files: {total_files}")
    print(f"[BATCH_SUMMARY] Total Episodes: {total_episodes}")
    print(f"[BATCH_SUMMARY] Successful: {total_successful}")
    print(f"[BATCH_SUMMARY] Failed: {total_failed}")
    print(f"[BATCH_SUMMARY] Overall Success Rate: {overall_success_rate:.2%}")
    print(f"[BATCH_SUMMARY] Summary saved to: {summary_file}")
    print(f"[BATCH_SUMMARY] =============================\n")


def run_single_json_test(episodes: List[Dict[str, Any]], args, out_root: Path, json_file: str, model_info: str, map_path: str = "", scene_usd_path: str = "", close_env_on_finish: bool = True, shared_env=None, progress_tracker=None) -> tuple:
    """
    Run test for a single JSON file
    
    Args:
        episodes: Episode list
        args: Command line arguments
        out_root: Output root directory
        json_file: JSON file path
        model_info: Model info string
        map_path: 2D semantic map file path
        scene_usd_path: Optional scene file path, overrides episode scene_usd if provided
        
    Returns:
        (successful_episodes, failed_episodes) tuple
    """
    # Initialize shared environment for all episodes
    if len(episodes) == 0:
        pass
        print("[ERROR] No episodes to process", flush=True)
        return 0, 0
    
    first_episode = episodes[0]
    
    # Determine scene file path to use
    if scene_usd_path:
        pass
        # Use provided scene_usd_path parameter
        actual_scene_path = scene_usd_path
        print(f"[INFO] Using provided scene path: {actual_scene_path}", flush=True)
    else:
        pass
        # Use default path from episode
        actual_scene_path = first_episode["scene_usd"]
        print(f"[INFO] Using scene path from episode: {actual_scene_path}", flush=True)
    
    # Use passed map_path instead of args.map_path
    actual_map_path = map_path if map_path else args.map_path
    print(f"[INFO] Using map file: {actual_map_path if actual_map_path else 'None'}", flush=True)
    
    # Use shared environment or create new one
    if shared_env is not None:
        pass
        env = shared_env
        print(f"[INFO] Using shared environment", flush=True)
        # Load new scene for shared environment
        if hasattr(env, 'load_scene'):
            pass
            print(f"[INFO] Switching to new scene: {actual_scene_path}", flush=True)
            env.load_scene(actual_scene_path)
        else:
            pass
            print(f"[WARN] Shared environment does not support scene switching, using current scene", flush=True)
        
        # Dynamically update map
        if hasattr(env, 'update_map') and actual_map_path:
            pass
            print(f"[INFO] Updating 2D semantic map: {actual_map_path}", flush=True)
            env.update_map(actual_map_path)
        else:
            pass
            if not actual_map_path:
                pass
                print(f"[WARN] No map path provided, skipping map update", flush=True)
            else:
                pass
                print(f"[WARN] Shared environment does not support map update", flush=True)
    else:
        pass
        env = SimpleVLNEnv(scene_usd_path=actual_scene_path, headless=True, hz=args.hz, map_json_path=actual_map_path)
        print(f"[INFO] New environment initialized successfully", flush=True)
    
    successful_episodes = 0
    failed_episodes = 0
    
    try:
        pass
        for i, ep in enumerate(episodes):
            # Progress tracking
            if progress_tracker:
                pass
                progress_tracker.start_episode(ep['episode_id'], ep['scene_name'], i + 1)
            else:
                pass
            print(f"[INFO] ===== Processing Episode {i+1}/{len(episodes)} =====", flush=True)
            print(f"Running scene {ep['scene_name']} episode {ep['episode_id']}...", flush=True)
            
            # Checkpoint check: see if episode already completed (if checkpoint enabled)
            if args.skip_completed and check_episode_completed(out_root, ep['scene_name'], ep['episode_id']):
                pass
                successful_episodes += 1  # Count completed episode as success
                if progress_tracker:
                    pass
                    progress_tracker.complete_episode(success=True, skipped=True)
                continue  # Skip completed episode
            
            try:
                pass
                # Prepare task config
                task_config = {
                    "goal_radius": args.goal_radius,
                    "max_episode_time": 80.0,  # 80-second time limit for no-goal tasks
                    "collision_penalty": True,
                    "min_exploration_coverage": 0.25
                }
                
                run_episode(ep, out_root, args.vlm_host, args.vlm_port, env, hz=args.hz, max_steps=args.max_steps, 
                           map_path=actual_map_path, disable_collision=args.disable_collision, 
                           disable_autopilot=args.disable_autopilot, model_type=args.model_type,
                           input_type=getattr(args, 'input_type', None), 
                           output_type=getattr(args, 'output_type', None),
                           protocol=getattr(args, 'protocol', None),
                           task_type=args.task_type, task_config=task_config, args=args)
                successful_episodes += 1
                if progress_tracker:
                    pass
                    progress_tracker.complete_episode(success=True, skipped=False)
                else:
                    pass
                print(f"[SUCCESS] Episode {ep['episode_id']} completed successfully!", flush=True)
            except (ConnectionRefusedError, ConnectionResetError, OSError) as e:
                print(f"[ERROR] VLM server disconnected: {e}", flush=True)
                failed_episodes += 1
                if progress_tracker:
                    progress_tracker.complete_episode(success=False, skipped=False)
                import run_benchmark as _rb
                _rb._vlm_server_disconnected = True
                break  # 跳出episode循环
            except Exception as e:
                failed_episodes += 1
                if progress_tracker:
                    pass
                    progress_tracker.complete_episode(success=False, skipped=False)
                else:
                    pass
                print(f"[ERROR] Episode {ep['episode_id']} failed with error: {e}", flush=True)
                print(f"[ERROR] Continuing with next episode...", flush=True)
                import traceback
                traceback.print_exc()
    
    finally:
        # Close shared environment after all episodes (only if not in batch mode)
        if close_env_on_finish and shared_env is None:
            pass
            print(f"[INFO] Closing shared environment...", flush=True)
            try:
                pass
                env.close()
                print(f"[INFO] Shared environment closed successfully", flush=True)
            except Exception as e:
                pass
                print(f"[ERROR] Failed to close environment: {e}", flush=True)
        else:
            pass
            print(f"[INFO] Keeping environment open for subsequent use", flush=True)
    
    print(f"[INFO] ===== File Summary =====", flush=True)
    print(f"[INFO] JSON file: {os.path.basename(json_file)}", flush=True)
    print(f"[INFO] Total episodes processed: {len(episodes)}", flush=True)
    print(f"[INFO] Successful episodes: {successful_episodes}", flush=True)
    print(f"[INFO] Failed episodes: {failed_episodes}", flush=True)
    success_rate = successful_episodes / len(episodes) if len(episodes) > 0 else 0.0
    print(f"[INFO] Success rate: {success_rate:.2%}", flush=True)
    
    return successful_episodes, failed_episodes


def _closest_waypoint(ep: Dict[str, Any], pos: np.ndarray) -> np.ndarray:
    gts = np.asarray(ep["gt_locations"], dtype=np.float32)
    if gts.shape[0] == 0:
        pass
        return pos
    d = np.linalg.norm(gts - pos[None, :], axis=1)
    idx = int(np.argmin(d))
    return gts[idx]


def reverse_position_mapping(px_3d, py_3d, map_data, flip_x=True, flip_y=True, negate_xy=True):
    """
    Reverse mapping: convert 3D trajectory coordinates back to 2D for visualization
    This is the inverse of the original mapping code
    
    Args:
        px_3d, py_3d: Coordinates in 3D trajectory
        map_data: Map data for getting bounds
        flip_x, flip_y, negate_xy: Mapping parameters, should match original mapping
    
    Returns:
        (px_2d, py_2d): Converted 2D coordinates
    """
    # Get map bounds (keeping original correct calculation)
    all_y = [float(y) for inst in map_data for y, x in inst.get('mask_coords_m', [])]
    all_x = [float(x) for inst in map_data for y, x in inst.get('mask_coords_m', [])]
    min_y, max_y = min(all_y), max(all_y)
    min_x, max_x = min(all_x), max(all_x)
    
    # Reverse mapping process (opposite order of original mapping)
    px, py = px_3d, py_3d
    
    # 1. If original negated overall, reverse it
    if negate_xy:
        pass
        px = -px
        py = -py
    
    # 2. If original mirrored, reverse it
    if flip_x:
        pass
        px = (min_x + max_x) - px
    if flip_y:
        pass
        py = (min_y + max_y) - py
        
    return px, py


def visualize_trajectory(episode: Dict[str, Any], trajectory_positions: List[np.ndarray], 
                         map_path: str, output_dir: Path) -> None:
    """
    Visualize the VLM agent's trajectory on 2D semantic map
    
    Args:
        episode: Episode data containing scene info
        trajectory_positions: List of agent positions during execution
        map_path: Path to 2D semantic map JSON
        output_dir: Directory to save visualization
    """
    if not MATPLOTLIB_AVAILABLE:
        pass
        print("[WARN] matplotlib not available, skipping trajectory visualization", flush=True)
        return
    
    if not map_path or not os.path.exists(map_path):
        pass
        print(f"[WARN] Map file not found: {map_path}, skipping trajectory visualization", flush=True)
        return
    
    try:
        pass
        print("[INFO] Loading 2D semantic map...", flush=True)
        # Load 2D semantic map
        with open(map_path, 'r') as f:
            map_data = json.load(f)
        
        print(f"[INFO] Loaded map data with {len(map_data)} instances", flush=True)
        
        # Get map bounds
        all_y = [float(y) for inst in map_data for y, x in inst.get('mask_coords_m', [])]
        all_x = [float(x) for inst in map_data for y, x in inst.get('mask_coords_m', [])]
        
        if not all_x or not all_y:
            pass
            print("[WARN] No valid coordinates in map data", flush=True)
            return
            
        min_y, max_y = min(all_y), max(all_y)
        min_x, max_x = min(all_x), max(all_x)
        print(f"[INFO] Map bounds: x=[{min_x:.2f}, {max_x:.2f}], y=[{min_y:.2f}, {max_y:.2f}]", flush=True)
        
        # Create color map image for background (similar to your approach)
        print("[INFO] Creating color map for background...", flush=True)
        map_width = int((max_x - min_x) * 10) + 20  # 10 pixels per meter + padding
        map_height = int((max_y - min_y) * 10) + 20
        color_map_img = np.ones((map_height, map_width, 3), dtype=np.float32) * 0.9  # Light gray background
        
        # Fill obstacles
        for inst in map_data:
            category = str(inst.get('category_label', '')).lower()
            if category in ['wall', 'unable area']:
                pass
                coords = inst.get('mask_coords_m', [])
                if coords:
                    pass
                    for y, x in coords:
                        try:
                            pass
                            # Convert world coordinates to image coordinates (ensure float conversion)
                            x_float = float(x)
                            y_float = float(y)
                            img_x = int((x_float - min_x) * 10) + 10
                            img_y = int((y_float - min_y) * 10) + 10
                            if 0 <= img_x < map_width and 0 <= img_y < map_height:
                                pass
                                if category == 'wall':
                                    pass
                                    color_map_img[img_y, img_x] = [0.6, 0.8, 1.0]  # Light blue for walls
                                else:  # unable area
                                    color_map_img[img_y, img_x] = [1.0, 0.4, 0.4]  # Light red for unable areas
                        except (ValueError, TypeError) as e:
                            pass
                            # Skip invalid coordinates
                            continue
        
        # Create visualization
        print("[INFO] Creating matplotlib figure...", flush=True)
        fig = plt.figure(figsize=(12, 12))
        ax = plt.gca()
        
        # Set background color and display map image
        bg_color = (0.9, 0.9, 0.9)
        ax.set_facecolor(bg_color)
        img_extent = [min_x - 1, max_x + 1, min_y - 1, max_y + 1]
        ax.imshow(color_map_img, extent=img_extent, origin='lower', interpolation='nearest', alpha=0.8)
        
        # Apply reverse mapping to convert 3D coordinates back to 2D for visualization
        print("[INFO] Applying reverse mapping from 3D to 2D coordinates...", flush=True)
        
        # Plot ground truth path (red like your code) - with reverse mapping
        if episode.get("gt_locations"):
            pass
            gt_positions_3d = np.array(episode["gt_locations"])
            print(f"[INFO] GT path original 3D positions: {len(gt_positions_3d)}", flush=True)
            
            # Apply reverse mapping to each GT position
            gt_positions_2d = []
            for pos_3d in gt_positions_3d:
                pos_2d_x, pos_2d_y = reverse_position_mapping(pos_3d[0], pos_3d[1], map_data)
                gt_positions_2d.append([pos_2d_x, pos_2d_y])
            gt_positions_2d = np.array(gt_positions_2d)
            
            print(f"[INFO] GT path first 3D point: {gt_positions_3d[0][:2]} -> 2D: {gt_positions_2d[0]}", flush=True)
            print(f"[INFO] GT path last 3D point: {gt_positions_3d[-1][:2]} -> 2D: {gt_positions_2d[-1]}", flush=True)
            
            if len(gt_positions_2d) >= 2:
                pass
                ax.plot(gt_positions_2d[:, 0], gt_positions_2d[:, 1], '-', color='red', linewidth=3, alpha=0.9)
                ax.scatter([gt_positions_2d[0, 0], gt_positions_2d[-1, 0]], 
                          [gt_positions_2d[0, 1], gt_positions_2d[-1, 1]], color='red', s=80)
        
        # Plot VLM agent trajectory (blue) - with reverse mapping
        if trajectory_positions:
            pass
            traj_array_3d = np.array(trajectory_positions)
            print(f"[INFO] Agent trajectory original 3D positions: {len(traj_array_3d)}", flush=True)
            
            # Apply reverse mapping to each agent position
            traj_array_2d = []
            for pos_3d in traj_array_3d:
                pos_2d_x, pos_2d_y = reverse_position_mapping(pos_3d[0], pos_3d[1], map_data)
                traj_array_2d.append([pos_2d_x, pos_2d_y])
            traj_array_2d = np.array(traj_array_2d)
            
            print(f"[INFO] Agent trajectory first 3D point: {traj_array_3d[0][:2]} -> 2D: {traj_array_2d[0]}", flush=True)
            print(f"[INFO] Agent trajectory last 3D point: {traj_array_3d[-1][:2]} -> 2D: {traj_array_2d[-1]}", flush=True)
            
            if len(traj_array_2d) >= 2:
                pass
                # Check if all points are the same (agent stuck)
                first_point = traj_array_2d[0]
                all_same = np.allclose(traj_array_2d, first_point, atol=0.01)  # 1cm tolerance
                
                if all_same:
                    pass
                    # All points same, display as large blue dot
                    ax.scatter(first_point[0], first_point[1], color='blue', s=200, alpha=0.9, 
                              marker='o', edgecolors='darkblue', linewidth=2, label='Agent Stuck')
                    print(f"[INFO] Agent stuck at position: {first_point} ({len(traj_array_2d)} steps)")
                else:
                    pass
                    # Normal trajectory, draw lines
                    ax.plot(traj_array_2d[:, 0], traj_array_2d[:, 1], '-', color='blue', linewidth=4, alpha=0.9)
                    ax.scatter([traj_array_2d[0, 0], traj_array_2d[-1, 0]], 
                              [traj_array_2d[0, 1], traj_array_2d[-1, 1]], color='blue', s=100)
            elif len(traj_array_2d) == 1:
                pass
                # Single point, display as large blue dot
                ax.scatter(traj_array_2d[0, 0], traj_array_2d[0, 1], color='blue', s=200, alpha=0.9, 
                          marker='o', edgecolors='darkblue', linewidth=2, label='Agent Position')
                print(f"[INFO] Agent stayed at single position: {traj_array_2d[0]}")
            else:
                pass
                print(f"[WARN] No valid agent trajectory points to plot")
        
        # Plot start and goal with stars (using GT path start/end points) - with reverse mapping
        # Use GT locations for accurate start/goal positions
        if episode.get("gt_locations") and len(episode["gt_locations"]) >= 2:
            pass
            gt_positions_3d = np.array(episode["gt_locations"])
            start_pos_3d = gt_positions_3d[0]  # First GT point
            goal_pos_3d = gt_positions_3d[-1]   # Last GT point
            
            # Apply reverse mapping to start and goal positions
            start_pos_2d = reverse_position_mapping(start_pos_3d[0], start_pos_3d[1], map_data)
            goal_pos_2d = reverse_position_mapping(goal_pos_3d[0], goal_pos_3d[1], map_data)
        else:
            pass
            # Fallback to episode data if GT not available (also apply reverse mapping)
            start_pos_3d = episode.get("start_position", [0, 0, 0])
            goal_pos_3d = episode.get("goals", [{}])[0].get("position", [0, 0, 0])
            start_pos_2d = reverse_position_mapping(start_pos_3d[0], start_pos_3d[1], map_data)
            goal_pos_2d = reverse_position_mapping(goal_pos_3d[0], goal_pos_3d[1], map_data)
        
        print(f"[INFO] Start 3D: {start_pos_3d[:2]} -> 2D: {start_pos_2d}", flush=True)
        print(f"[INFO] Goal 3D: {goal_pos_3d[:2]} -> 2D: {goal_pos_2d}", flush=True)
        
        ax.scatter(start_pos_2d[0], start_pos_2d[1], c='orange', s=200, marker='*', 
                  edgecolors='black', linewidth=2)
        ax.scatter(goal_pos_2d[0], goal_pos_2d[1], c='green', s=200, marker='*', 
                  edgecolors='black', linewidth=2)
        
        # Add text annotations (like your code)
        ax.text(start_pos_2d[0], start_pos_2d[1] + 0.5, "START", color='yellow', fontsize=12,
                ha='center', va='center', fontweight='bold')
        ax.text(goal_pos_2d[0], goal_pos_2d[1] + 0.5, "GOAL", color='yellow', fontsize=12,
                ha='center', va='center', fontweight='bold')
        
        # Customize plot (no legend, similar to your style)
        print("[INFO] Customizing plot appearance...", flush=True)
        ax.set_xlim(min_x - 1, max_x + 1)
        ax.set_ylim(min_y - 1, max_y + 1)
        ax.set_xlabel('X (meters)')
        ax.set_ylabel('Y (meters)')
        ax.set_title(f'2D Navigation Map - Scene {episode["scene_name"]} Episode {episode["episode_id"]}')
        # No legend, no grid for cleaner look like your code
        ax.set_aspect('equal')
        
        # Save visualization
        vis_path = output_dir / f"trajectory_visualization_{episode['scene_name']}_{episode['episode_id']}.png"
        print(f"[INFO] Saving visualization to: {vis_path}", flush=True)
        plt.savefig(str(vis_path), dpi=150, bbox_inches='tight')
        plt.close(fig)
        
        print(f"[INFO] Trajectory visualization saved successfully to: {vis_path}", flush=True)
        
    except Exception as e:
        pass
        print(f"[ERROR] Failed to create trajectory visualization: {e}", flush=True)
        import traceback
        traceback.print_exc()
        plt.close('all')  # Clean up any open figures


def run_episode(ep: Dict[str, Any], out_root: Path, vlm_host: str, vlm_port: int, env: SimpleVLNEnv,
                 hz: int = 30, max_steps: int = 200, fps: int = 10, map_path: str = "", 
                 disable_collision: bool = False, disable_autopilot: bool = False, 
                 model_type: str = "navdp", input_type: str = None, output_type: str = None, 
                 protocol: str = None, task_type: str = "vln", task_config: Dict[str, Any] = None, 
                 args: Any = None) -> None:
                     # Earliest debug info - confirm function called
    print(f"[DEBUG_ENTRY] run_episode function starting: {ep['episode_id']}", flush=True)
    # Write directly to stderr to ensure output not filtered
    import sys
    sys.stderr.write(f"[STDERR_DEBUG] run_episode function starting: {ep['episode_id']}\n")
    sys.stderr.flush()
    
    # Safe args parameter handling - use global variable for log_and_print access
    global perf_opts
    perf_opts = {
        'batch_logging': getattr(args, 'batch_logging', False) if args else False,
        'minimal_logging': getattr(args, 'minimal_logging', False) if args else False,
        'low_res': getattr(args, 'low_res', False) if args else False,
        'save_debug_files': getattr(args, 'save_debug_files', False) if args else False,
        'save_videos': getattr(args, 'save_videos', False) if args else False,
        'save_vlm_inputs': getattr(args, 'save_vlm_inputs', False) if args else False,
        'fast_mode': getattr(args, 'fast_mode', False) if args else False,
        'ultra_fast': getattr(args, 'ultra_fast', False) if args else False,
        'enable_vlm_cache': getattr(args, 'enable_vlm_cache', False) if args else False,
        'adaptive_timeout': getattr(args, 'adaptive_timeout', False) if args else False,
        'silent_logging': getattr(args, 'silent_logging', False) if args else False,
        'terminal_only': getattr(args, 'terminal_only', False) if args else False,
    }
    
    
    # Initialize task type system
    if task_config is None:
        pass
        task_config = {
            "goal_radius": 0.5,
            "max_episode_time": 80.0,  # 80 second time limit for no-goal tasks
            "collision_penalty": True,
            "min_exploration_coverage": 0.25
        }
    
    # Adapt episode data for specified task type
    adapted_episode = adapt_episode_for_task(ep, task_type)
    
    # Create task instance
    navigation_task = TaskTypeManager.create_task(task_type, task_config)
    
    result_dir = out_root / str(adapted_episode["scene_name"]) / str(adapted_episode["episode_id"])
    meas_dir = result_dir / "measurements"
    vid_dir = result_dir / "videos"
    log_path = result_dir / "episode.log"
    meas_dir.mkdir(parents=True, exist_ok=True)
    vid_dir.mkdir(parents=True, exist_ok=True)

    # Create task ID and display episode info
    task_id = f"{adapted_episode['scene_name']}_Trajectory_{adapted_episode['episode_id']}"
    
    # Get instruction using task system (supports different task types)
    instruction = navigation_task.get_instruction(adapted_episode, step=0)
    
    print(f"[INFO] ===== Starting Episode =====", flush=True)
    print(f"[INFO] Task ID: {task_id}", flush=True)
    print(f"[INFO] Task Type: {task_type.upper()}", flush=True)
    print(f"[INFO] Scene: {adapted_episode['scene_name']}", flush=True)
    print(f"[INFO] Episode: {adapted_episode['episode_id']}", flush=True)
    print(f"[INFO] Instruction: {instruction}", flush=True)
    
    # Display task-specific info
    goal_pos = navigation_task.get_goal_position(adapted_episode)
    goal_radius = navigation_task.get_goal_radius(adapted_episode)
    print(f"[INFO] Goal Position: ({goal_pos[0]:.2f}, {goal_pos[1]:.2f}, {goal_pos[2]:.2f})", flush=True)
    print(f"[INFO] Goal Radius: {goal_radius:.2f}m", flush=True)
    print(f"[INFO] Start pos: {adapted_episode.get('start_position', ep.get('start_position', 'N/A'))}", flush=True)
    print(f"[INFO] Original Goal pos: {ep.get('goals', [{}])[0].get('position', 'N/A')}", flush=True)
    print(f"[INFO] GT path length: {len(ep.get('gt_locations', []))} waypoints", flush=True)
    print(f"[INFO] ============================", flush=True)
    
    # Open log file for the entire function execution
    logf = open(log_path, "w")
    
    # Configure logging module to also write to episode.log
    # Clear existing handlers to avoid duplicate config
    for handler in logging.root.handlers[:]:
        logging.root.removeHandler(handler)
    
    # Create file handler to write all logging messages to episode.log
    file_handler = logging.FileHandler(str(log_path), mode='a')
    file_handler.setLevel(logging.INFO)
    file_handler.setFormatter(logging.Formatter('%(message)s'))
    
    # Create console handler to maintain console output
    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.INFO)
    console_handler.setFormatter(logging.Formatter('%(message)s'))
    
    # Configure root logger
    logging.root.setLevel(logging.INFO)
    logging.root.addHandler(file_handler)
    logging.root.addHandler(console_handler)
    
    print(f"[DEBUG] Logging configured to: {log_path}", flush=True)
    logging.info("[DEBUG] Logging configuration complete")
    
    # Write initial info to log file
    logf.write(f"episode_id={ep['episode_id']} scene={ep['scene_name']}\n")
    logf.write(f"task_id={task_id}\n")
    logf.write(f"instruction={instruction}\n")
    
    # Add additional info records
    if 'instruction_type' in ep and ep['instruction_type']:
        pass
        logf.write(f"instruction_type={ep['instruction_type']}\n")
    if 'instruction_index' in ep:
        pass
        logf.write(f"instruction_index={ep['instruction_index']}\n")
    if 'trajectory_id' in ep:
        pass
        logf.write(f"trajectory_id={ep['trajectory_id']}\n")
    if 'start_item' in ep and ep['start_item']:
        pass
        logf.write(f"start_item={ep['start_item']}\n")
    if 'end_item' in ep and ep['end_item']:
        pass
        logf.write(f"end_item={ep['end_item']}\n")
        
    logf.write(f"start_position={ep['start_position']}\n")
    logf.write(f"start_rotation={ep['start_rotation']}\n")
    logf.write(f"goal_radius={ep['goals'][0]['radius']}\n")
    logf.write(f"max_steps={max_steps}\n")
    logf.write(f"hz={hz}\n")
    logf.write("="*50 + "\n")  # Separator
    logf.flush()

    # Environment is now passed as parameter - reset it for this episode
    print(f"[DEBUG] Resetting environment for episode {ep['episode_id']}")
    # Note: Environment is already initialized and passed from main function
    
    # Set environment log function
    def env_log_func(msg):
        logf.write(msg + "\n")
        logf.flush()
    env.set_log_function(env_log_func)
    if disable_collision:
        pass
        env.set_collision_detection(False)
        print(f"[CONFIG] Collision detection disabled, agent can move freely")
    
    # Silent mode: redirect all print output
    if perf_opts['silent_logging']:
        pass
        # Set environment variable so other modules know silent mode is enabled
        import os
        os.environ['SILENT_LOGGING_MODE'] = 'True'
        import sys
        import io
        
        class SilentPrintFilter:
            def __init__(self, original_stdout):
                self.original_stdout = original_stdout
                # Consecutive empty line compression flag
                self._last_was_newline = False
                self.excluded_keywords = [
                    '[OBJECT_SUCCESS]', '[RGB_CAPTURE]', '[COLLISION_VIS]', '[CAMERA_UPDATE]',
                    '[COLLISION_2D]', '[PHYSICS]', '[DEPTH_CAPTURE]', '[PERF]',
                    '[YAW_UPDATE]', '[COORD_TRANSFORM]', '[POSITION]', '[VELOCITY]'
                ]
                self.important_keywords = [
                    '[ERROR]', '[WARN]', '✅', '❌', '⏭️',
                    '===== Processing Episode', 'Episode completed', 'Episode failed',
                    '===== Starting Episode', '[CHECKPOINT]', '[BATCH]',
                    'Model:', 'Progress:', 'Elapsed:', 'Success Rate:', 'Test Complete', 'SAGE-Bench', '======',
                    '🚀', '📊', '⏱️', '📈', '⚡', '🎉',  # Progress bar emoji
                    'SAGE-Bench Test Progress', 'Total Episodes:', 'Start Time:', 'Est. Remaining:', 'Avg. Time:',
                    '[Progress]', '[Status]', 'Episode Info'  # Progress bar related text
                ]
            
            def write(self, text):
                # Non-empty text
                if text.strip():
                    # Priority check if contains important info
                    if any(keyword in text for keyword in self.important_keywords):
                        self.original_stdout.write(text)
                        self.original_stdout.flush()
                        self._last_was_newline = False
                    # Check if it's debug info that needs to be excluded
                    elif any(keyword in text for keyword in self.excluded_keywords):
                        # Don't display in terminal
                        pass
                    # Use regex to match debug tags with square brackets (general filtering)
                    elif self._is_debug_log(text):
                        # Don't display in terminal
                        pass
                    else:
                        # Other content displayed normally
                        self.original_stdout.write(text)
                        self.original_stdout.flush()
                        self._last_was_newline = False
                else:
                    # Blank output: compress consecutive empty lines, keep only one newline
                    if not self._last_was_newline:
                        self.original_stdout.write("\n")
                        self._last_was_newline = True
                return len(text)

            
            def _is_debug_log(self, text):
                """Check if it's a debug log (format: [Tag] content)"""
                import re
                # Match debug logs starting with [Tag]
                debug_pattern = r'^\[([A-Z_]+)\]'
                return re.match(debug_pattern, text.strip())
            
            def flush(self):
                self.original_stdout.flush()
        
        # Replace stdout but keep original reference for important info
        original_stdout = sys.stdout
        sys.stdout = SilentPrintFilter(original_stdout)
    
    log_and_print(f"[DEBUG_MAIN] Preparing to set starting pose...")
    env.set_start_pose(ep["start_position"], ep["start_rotation"])
    
    # Reset episode time (especially important for no-goal tasks)
    if hasattr(env, 'reset_episode_time'):
        env.reset_episode_time()
        log_and_print(f"[DEBUG_MAIN] Episode time has been reset")
    
    log_and_print(f"[DEBUG_MAIN] Starting pose set successfully")
    
    # Initialize measure manager - select different metrics based on task type
    if task_type.lower() == "nogoalnav":
        measure_manager = nogoal_measures(adapted_episode)
        log_and_print(f"[DEBUG_MAIN] Using no-goal task specific metrics")
    else:
        measure_manager = default_measures(adapted_episode)
        log_and_print(f"[DEBUG_MAIN] Using default VLN task metrics")
    log_and_print(f"[DEBUG_MAIN] Preparing to reset measure_manager...")
    try:
        pass
        measure_manager.reset(env)
        log_and_print(f"[DEBUG_MAIN] measure_manager reset successful")
    except Exception as e:
        pass
        log_and_print(f"[ERROR] measure_manager reset failed: {e}")
        import traceback
        log_and_print(f"[ERROR] Stack trace: {traceback.format_exc()}")
        return  # Early exit

    frames: List[np.ndarray] = []
    images_for_vlm: List[Image.Image] = []
    trajectory_positions: List[np.ndarray] = []  # Track agent positions
    instr = ep["instruction"]["instruction_text"]
    
    # 🚀 Simple VLM response cache (for performance optimization)
    vlm_response_cache = {}
    last_vlm_response = None

    # 🚀 Optimized Warm-up: avoid apply_cmd_for infinite loop
    log_and_print("[INFO] Optimized Warm-up capture - avoiding apply_cmd_for")
    sys.stderr.write(f"[STDERR_DEBUG] Starting optimized warm-up\n")
    warm_tries = 0
    first_rgb = None
    max_warm_tries = 10  # Reduced number of attempts
    
    while warm_tries < max_warm_tries and first_rgb is None:
        sys.stderr.write(f"[STDERR_DEBUG] warm-up attempt {warm_tries}/{max_warm_tries}: Getting RGB directly...\n")
        first_rgb = env.get_rgb()
        if first_rgb is None:
            pass
            sys.stderr.write(f"[STDERR_DEBUG] RGB capture failed, waiting briefly before retry...\n")
            sys.stderr.flush()
            # Use simple time wait instead of apply_cmd_for, avoid camera update loop
            import time
            time.sleep(0.1)  # 100ms wait
            warm_tries += 1
        else:
            pass
            sys.stderr.write(f"[STDERR_DEBUG] RGB capture successful! shape={first_rgb.shape}\n")
            sys.stderr.flush()
            break
    
    # If still failed, create a dummy RGB image to continue execution
    if first_rgb is None:
        pass
        sys.stderr.write(f"[STDERR_DEBUG] warm-up failed, creating dummy RGB image\n")
        sys.stderr.flush()
        # Create dummy RGB image (480x640x3)
        first_rgb = np.zeros((480, 640, 3), dtype=np.uint8)
        log_and_print("[WARN] Warm-up failed, using dummy RGB image to continue")
    if first_rgb is not None:
        pass
        images_for_vlm.append(Image.fromarray(first_rgb))
        frames.append(first_rgb)
        log_and_print("[INFO] First RGB captured")
    else:
        pass
        log_and_print("[WARN] No RGB during warm-up; proceeding")
    
    # Record initial position
    log_and_print(f"[DEBUG_MAIN] Preparing to get initial position...")
    try:
        pass
        initial_pos = env.get_agent_pos()
        trajectory_positions.append(initial_pos)
        log_and_print(f"[INFO] Initial position: {initial_pos}")
    except Exception as e:
        pass
        log_and_print(f"[ERROR] Failed to get initial position: {e}")
        import traceback
        log_and_print(f"[ERROR] Stack trace: {traceback.format_exc()}")
        return  # Early exit

    steps_run = 0
    turn_only_count = 0
    stop_override_count = 0  # Count STOP command overrides (only for no-goal tasks)
    
    # Only non-no-goal tasks need to get initial distance
    prev_dist = None
    if task_type != "nogoalnav":
        log_and_print(f"[DEBUG_MAIN] Preparing to get initial distance...")
        try:
            prev_dist = measure_manager.measures["distance_to_goal"].get()
            log_and_print(f"[DEBUG_MAIN] Initial distance: {prev_dist}")
        except Exception as e:
            log_and_print(f"[ERROR] Failed to get initial distance: {e}")
            import traceback
            log_and_print(f"[ERROR] Stack trace: {traceback.format_exc()}")
            return  # Early exit
    else:
        log_and_print(f"[DEBUG_MAIN] No-goal task, skipping distance initialization")
    
    # 🔍 Debug: Check if entering main loop
    log_and_print(f"[DEBUG_MAIN] About to start main loop, max_steps={max_steps}")
    
    for step in range(max_steps):
        # 🕒 Update environment time state (for no-goal tasks)
        env.update_time_and_reset_collision()
        
        # 🚫 No-goal task special handling: check time limit and collision termination
        if task_type.lower() == "nogoalnav":
            current_time = env._current_time
            episode_time = current_time - env._episode_start_time
            
            # Check if timeout (80 second limit)
            max_episode_time = task_config.get("max_episode_time", 80.0)
            if episode_time >= max_episode_time:
                log_and_print(f"[NOGOAL] Episode timeout termination ({episode_time:.1f}s >= {max_episode_time}s)")
                env.is_stop_called = True
                break
            
            # Check if collision occurred
            if env._collision_detected:
                log_and_print(f"[NOGOAL] Collision detected, Episode terminated immediately (time: {episode_time:.1f}s)")
                env.is_stop_called = True
                break
            
            log_and_print(f"[NOGOAL] Exploration in progress... Time: {episode_time:.1f}s/{max_episode_time}s")
        
        log_and_print(f"[DEBUG_MAIN] Step {step}: About to query VLM")
        log_and_print(f"[INFO] Step {step}")
        
        # 🔧 Smart image capture based on input type (performance optimized)
        rgb = None
        depth = None
        
        # Decide what data to get based on modular config
        need_depth = False
        if input_type == "rgbd":
            need_depth = True
            if not perf_opts['minimal_logging']:
                pass  # Can add logging or debug code here
            log_and_print(f"[IMAGE_INPUT] RGB-D mode: Need to get RGB and depth")
        elif input_type == "rgb":
            need_depth = False
            if not perf_opts['minimal_logging']:
                pass
            log_and_print(f"[IMAGE_INPUT] RGB mode: Only need to get RGB image")
        elif model_type and model_type in ["navdp"]:
            need_depth = True
            if not perf_opts['minimal_logging']:
                pass
            log_and_print(f"[IMAGE_INPUT] Predefined model {model_type}: Need RGB-D")
        elif model_type and model_type in ["navila", "navid"]:
            need_depth = False
            if not perf_opts['minimal_logging']:
                pass
            log_and_print(f"[IMAGE_INPUT] Predefined model {model_type}: Only need RGB")
        else:
            need_depth = True  # Default fallback
            if not perf_opts['minimal_logging']:
                pass
            log_and_print(f"[IMAGE_INPUT] Default mode: Getting RGB-D")
        
        # 🚀 Performance optimization: frame skip detection
        # If no significant movement for several steps, reuse image to reduce rendering overhead
        skip_rendering = False
        if step > 0 and len(trajectory_positions) >= 2:
            last_pos = trajectory_positions[-1]
            second_last_pos = trajectory_positions[-2] if len(trajectory_positions) >= 2 else last_pos
            movement_distance = np.linalg.norm(last_pos - second_last_pos)
            if movement_distance < 0.05 and not perf_opts['fast_mode']:  # 5cm movement threshold
                skip_rendering = False  # Temporarily disable frame skip for stability
                if not perf_opts['minimal_logging']:
                    log_and_print(f"[PERF] Minimal movement ({movement_distance:.3f}m), considering image reuse")
        
        # Get RGB image (always needed)
        if hasattr(env, 'get_rgb'):
            pass
            rgb = env.get_rgb()
            if rgb is not None:
                pass
                # 🚀 Performance optimization: low resolution processing
                if perf_opts['low_res'] and rgb.shape[:2] != (240, 320):
                    pass
                    try:
                        pass
                        import cv2
                        rgb = cv2.resize(rgb, (320, 240))
                    except ImportError:
                        pass
                        # fallback to PIL if cv2 not available
                        rgb_pil = Image.fromarray(rgb).resize((320, 240))
                        rgb = np.array(rgb_pil)
                
                images_for_vlm.append(Image.fromarray(rgb))
                frames.append(rgb)
                if not perf_opts['minimal_logging']:
                    pass
                log_and_print(f"[DEBUG] ✓ Got RGB image: shape={rgb.shape}")
            else:
                pass
                if not perf_opts['minimal_logging']:
                    pass
                log_and_print("[WARN] ✗ Failed to get RGB")
        
        # Only get depth map when needed
        if need_depth:
            pass
            if hasattr(env, 'get_depth'):
                pass
                depth = env.get_depth()
                if depth is not None:
                    pass
                    # 🚀 Performance optimization: low resolution processing
                    if perf_opts['low_res'] and depth.shape[:2] != (240, 320):
                        pass
                        try:
                            pass
                            import cv2
                            depth = cv2.resize(depth, (320, 240))
                        except ImportError:
                            pass
                            # fallback to PIL for depth
                            depth_pil = Image.fromarray(depth).resize((320, 240))
                            depth = np.array(depth_pil)
                    
                    if not perf_opts['minimal_logging']:
                        pass
                    log_and_print(f"[DEBUG] ✓ 获取到深度图: shape={depth.shape}, range=[{depth.min():.3f}, {depth.max():.3f}]m")
                else:
                    pass
                    if not perf_opts['minimal_logging']:
                        pass
                    log_and_print("[WARN] ✗ Failed to get depth")
            else:
                pass
                if not perf_opts['minimal_logging']:
                    pass
                log_and_print("[WARN] Environment does not support depth capture")
        else:
            pass
            if not perf_opts['minimal_logging']:
                pass
            log_and_print(f"[DEBUG] RGB mode: Skipping depth capture")

        # Measure current step
        measure_manager.update(env)
        if task_type != "nogoalnav" and "distance_to_goal" in measure_manager.measures:
            d = measure_manager.measures["distance_to_goal"].get()
            log_and_print(f"[INFO] DistanceToGoal(before): {d:.3f}")
        else:
            d = None

        # Query VLM
        try:
            pass
            
            # Get task instruction for current step
            current_instruction = navigation_task.get_instruction(adapted_episode, step=steps_run)
            
            # 🚀 Performance optimization: VLM response cache check
            # Create simple cache key for similar scenes and instructions
            cache_hit = False
            cache_key = None
            if perf_opts.get('enable_vlm_cache', False) and len(trajectory_positions) >= 2:
                current_pos = trajectory_positions[-1]
                cache_key = f"{current_instruction}_{current_pos[0]:.1f}_{current_pos[1]:.1f}"
                if cache_key in vlm_response_cache:
                    resp = vlm_response_cache[cache_key]
                    cache_hit = True
                    log_and_print(f"[CACHE] 🎯 Cache hit, reusing VLM response")
            
            if not cache_hit:
                # No cache hit, need to query VLM
                pass
            else:
                # Cache hit, skip VLM query and image saving
                log_and_print(f"[INFO] VLM resp (cached): {resp}")
                
            # 🎥 Conditional VLM input image saving - based on debug file settings (forced off in fast-mode)
            if not cache_hit:
                should_save_vlm_inputs = (
                    perf_opts.get('save_debug_files', False) or perf_opts.get('save_vlm_inputs', False)
                ) and not perf_opts.get('fast_mode', False)
                
                if should_save_vlm_inputs:
                    debug_img_path = vid_dir / "vlm_inputs" / f"step_{step:03d}_input.png"
                    debug_depth_path = vid_dir / "vlm_inputs" / f"step_{step:03d}_depth.png"
                    debug_img_path.parent.mkdir(parents=True, exist_ok=True)
                    
                    if rgb is not None:
                        Image.fromarray(rgb).save(debug_img_path)
                        if not perf_opts['minimal_logging']:
                            log_and_print(f"[DEBUG] Saved VLM input RGB: {debug_img_path}")
                else:
                    if step == 0 and not perf_opts['minimal_logging']:  # Only prompt once on first step
                        log_and_print(f"[PERF] Skipping VLM input image saving for performance (debug file disabled)")
                
                log_and_print(f"[VLM_INPUT] Task: {task_type.upper()} | Sending to VLM: \"{current_instruction}\"")
                log_and_print(f"[VLM_DEBUG] VLM server: {vlm_host}:{vlm_port}")
                log_and_print(f"[VLM_DEBUG] Image count: {len(images_for_vlm)}")
                
                # Use VLM model, supports multiple configuration methods
                current_yaw = env.get_yaw()
                depth_images = [depth] if depth is not None else None
                log_and_print(f"[VLM_DEBUG] Preparing VLM query, yaw: {current_yaw:.3f}")
                
                # 🚀 Performance optimization: Dynamic VLM timeout
                # Adjust timeout based on network conditions and historical response time
                import time as time_module
                vlm_start_time = time_module.time()
                
                # Prefer modular config if complete parameters provided
                log_and_print(f"[DEBUG] 检查模块化配置参数: input_type={input_type}, output_type={output_type}, protocol={protocol}, vlm_host={vlm_host}, vlm_port={vlm_port}")
                if input_type and output_type and protocol:
                    pass
                    log_and_print(f"[VLM_CONFIG] Using modular config: {input_type} + {output_type} + {protocol}")
                    log_and_print(f"[VLM_DEBUG] Starting VLM query...")
                    resp = query_vlm(images_for_vlm, current_instruction, vlm_host, vlm_port, 
                                    current_yaw=current_yaw, depth_images=depth_images,
                                    input_type=input_type, output_type=output_type, protocol=protocol)
                    log_and_print(f"[VLM_DEBUG] VLM query completed")
                # Fallback to predefined model type
                elif model_type:
                    pass
                    log_and_print(f"[VLM_CONFIG] Using predefined model type: {model_type}")
                    log_and_print(f"[VLM_DEBUG] Starting VLM query...")
                    resp = query_vlm(images_for_vlm, current_instruction, vlm_host, vlm_port, 
                                    current_yaw=current_yaw, depth_images=depth_images, model_type=model_type)
                    log_and_print(f"[VLM_DEBUG] VLM查询完成")
                else:
                    pass
                    log_and_print(f"[ERROR] Must provide model_type or (input_type, output_type, protocol)")
                    resp = {"vx": 0.0, "vy": 0.0, "yaw_rate": 0.0, "duration_s": 0.0, "stop": True}
                
                log_and_print(f"[INFO] VLM resp: {resp}")
                
                # 🚀 Performance stats: record VLM response time
                vlm_end_time = time_module.time()
                vlm_duration = vlm_end_time - vlm_start_time
                if not perf_opts.get('minimal_logging', False):
                    log_and_print(f"[PERF] VLM response time: {vlm_duration:.2f}s")
                
                # Save response to cache
                if perf_opts.get('enable_vlm_cache', False) and cache_key is not None:
                    vlm_response_cache[cache_key] = resp
                last_vlm_response = resp

        except ConnectionError as e:
            log_and_print(f"[ERROR] VLM server disconnected, stopping current episode")
            import run_benchmark as _rb
            _rb._vlm_server_disconnected = True
            env.is_stop_called = True
            break

        except Exception as e:
            pass
            log_and_print(f"[ERROR] Failed to query VLM: {e}")
            # 🚀 Smart fallback: if previous response exists, use modified version
            if last_vlm_response and not perf_opts.get('fast_mode', False):
                # Use modified version of last response as fallback
                resp = {
                    "vx": last_vlm_response.get("vx", 0.1) * 0.5,  # Reduce speed
                    "vy": last_vlm_response.get("vy", 0.0) * 0.5,
                    "yaw_rate": last_vlm_response.get("yaw_rate", 0.0) * 0.5,
                    "duration_s": 1.0,
                    "stop": False
                }
                log_and_print(f"[FALLBACK] Using modified previous VLM response")
            else:
                # Don't stop immediately, continue with a default action
                resp = {"vx": 0.1, "vy": 0.0, "yaw_rate": 0.0, "duration_s": 1.0, "stop": False}

        # 🚫 No-goal task special handling: STOP not allowed, convert to exploration command
        if resp.get("stop", False):
            if task_type.lower() == "nogoalnav":
                # In no-goal task, convert STOP to exploration command
                stop_override_count += 1
                log_and_print(f"[NOGOAL_OVERRIDE] STOP command detected, converting to exploration command (#{stop_override_count})")
                resp["stop"] = False
                
                # Use step count to create some variation, avoid repetitive behavior
                import random
                random.seed(steps_run)  # Use step count as seed for reproducibility
                
                # Randomly select exploration behavior: forward, turn left, turn right
                action_type = random.choice(['forward', 'turn_left', 'turn_right'])
                
                if action_type == 'forward':
                    resp["vx"] = 0.2
                    resp["vy"] = 0.0
                    resp["yaw_rate"] = 0.0
                elif action_type == 'turn_left':
                    resp["vx"] = 0.1
                    resp["vy"] = 0.0
                    resp["yaw_rate"] = 0.5  # Turn left
                else:  # turn_right
                    resp["vx"] = 0.1
                    resp["vy"] = 0.0
                    resp["yaw_rate"] = -0.5  # Turn right
                
                resp["duration_s"] = 1.0
                log_and_print(f"[NOGOAL_OVERRIDE] 新命令({action_type}): vx={resp['vx']}, vy={resp['vy']}, yaw_rate={resp['yaw_rate']}, duration={resp['duration_s']}")
            else:
                # Other tasks handle STOP normally
                env.is_stop_called = True
        
        # execute
        try:
            pass
            # Log command details for debugging
            cmd_vx = resp.get("vx", 0.0)
            cmd_vy = resp.get("vy", 0.0)
            cmd_yaw_rate = resp.get("yaw_rate", 0.0)
            cmd_duration = resp.get("duration_s", 0.0)
            
            log_and_print(f"[DEBUG] Executing command: vx={cmd_vx:.3f}, vy={cmd_vy:.3f}, yaw_rate={cmd_yaw_rate:.3f}, duration={cmd_duration:.3f}")
            
            # Execute movement command
            log_and_print(f"[DEBUG] About to call env.apply_cmd_for...")
            env.apply_cmd_for(cmd_vx, cmd_vy, cmd_yaw_rate, cmd_duration)
            log_and_print(f"[DEBUG] Finished env.apply_cmd_for")
            
            log_and_print(f"[DEBUG] About to update measures...")
            measure_manager.update(env)
            log_and_print(f"[DEBUG] Finished updating measures")
            
        except Exception as e:
            pass
            log_and_print(f"[ERROR] Failed to execute command or update measures: {e}")
            import traceback
            tb = traceback.format_exc()
            log_and_print(f"[ERROR] Full traceback: {tb}")
            env.is_stop_called = True
            break

        steps_run += 1
        if task_type != "nogoalnav" and "distance_to_goal" in measure_manager.measures:
            new_dist = measure_manager.measures["distance_to_goal"].get()
            log_and_print(f"[INFO] DistanceToGoal(after): {new_dist:.3f}")
            prev_dist = new_dist
        else:
            new_dist = None
        
        # Record current position for trajectory visualization
        current_pos = env.get_agent_pos()
        trajectory_positions.append(current_pos)
        
        # 🎯 Task-specific success check
        if task_type.lower() == "nogoalnav":
            # No-goal task: use task instance's success judgment
            current_pos = env.get_agent_pos()
            episode_time = env._current_time - env._episode_start_time
            exploration_coverage = 0.0
            if "exploration_coverage" in measure_manager.measures:
                exploration_coverage = measure_manager.measures["exploration_coverage"].get()
            
            task_success = navigation_task.is_success(
                current_pos, adapted_episode, 
                collision_detected=env._collision_detected,
                episode_time=episode_time,
                exploration_coverage=exploration_coverage
            )
            
            if task_success:
                log_and_print(f"[NOGOAL] Exploration task complete! Time: {episode_time:.1f}s, Coverage: {exploration_coverage:.2%}")
                env.is_stop_called = True
        else:
            # Traditional VLN task: distance check
            goal_radius = 0.5  # default radius
            if ep.get("goals") and len(ep["goals"]) > 0 and "radius" in ep["goals"][0]:
                goal_radius = ep["goals"][0]["radius"]
            if new_dist < goal_radius:
                log_and_print(f"[INFO] Within goal radius ({goal_radius}); stopping")
                env.is_stop_called = True
        
        if env.is_stop_called:
            log_and_print("[INFO] Stop called; breaking")
            break
    
    # Save results even if we break early
    log_and_print(f"[INFO] Episode ended after {steps_run} steps")

    try:
        pass
        log_and_print("[INFO] Saving measurements...")
        meas_path = meas_dir / f"{ep['episode_id']}.json"
        
        # Get original measurements
        measurements = measure_manager.dump()
        
        # Add episode details
        measurements["episode_info"] = {
            "episode_id": ep['episode_id'],
            "scene_name": ep['scene_name'],
            "task_id": task_id,
            "instruction": instruction,
            "start_position": ep['start_position'],
            "start_rotation": ep['start_rotation'],
            "goal_radius": ep['goals'][0]['radius'],
            "max_steps": max_steps,
            "hz": hz
        }
        
        # Add special stats for no-goal tasks
        if task_type.lower() == "nogoalnav":
            measurements["episode_info"]["stop_override_count"] = stop_override_count
            log_and_print(f"[INFO] No-goal task stats: STOP command overridden {stop_override_count} times")
        
        # Add new details
        if 'instruction_type' in ep and ep['instruction_type']:
            pass
            measurements["episode_info"]["instruction_type"] = ep['instruction_type']
        if 'instruction_index' in ep:
            pass
            measurements["episode_info"]["instruction_index"] = ep['instruction_index']
        if 'trajectory_id' in ep:
            pass
            measurements["episode_info"]["trajectory_id"] = ep['trajectory_id']
        if 'start_item' in ep and ep['start_item']:
            pass
            measurements["episode_info"]["start_item"] = ep['start_item']
        if 'end_item' in ep and ep['end_item']:
            pass
            measurements["episode_info"]["end_item"] = ep['end_item']
        
        with open(meas_path, "w") as f:
            json.dump(measurements, f, indent=2)
        log_and_print(f"[INFO] ✅ Measurements saved (key output): {meas_path}")
    except Exception as e:
        pass
        log_and_print(f"[ERROR] Failed to save measurements: {e}")

     # 🎥 Conditional video saving - based on debug file settings (forced off in fast-mode)
    should_save_video = (
        perf_opts.get('save_debug_files', False) or perf_opts.get('save_videos', False)
    ) and not perf_opts.get('fast_mode', False)
     
    if should_save_video:
        try:
            log_and_print("[INFO] Saving episode video...")
            # save video (use placeholder if empty)
            video_path = (vid_dir / f"{ep['episode_id']}.mp4").resolve()
            if len(frames) == 0:
                log_and_print("[WARN] No frames captured; writing a placeholder")
                frames = [np.zeros((240, 320, 3) if perf_opts['low_res'] else (480, 640, 3), dtype=np.uint8)]
            SimpleVLNEnv.write_video(frames, str(video_path), fps=fps)
            log_and_print(f"[INFO] Saved video to: {video_path}")
        except Exception as e:
            log_and_print(f"[ERROR] Failed to save video: {e}")
    else:
        # Processing when not saving video
        log_and_print("[PERF] Skipping video saving for performance (debug file disabled)")
    
    if task_type != "nogoalnav" and "distance_to_goal" in measure_manager.measures:
        final_dist = measure_manager.measures['distance_to_goal'].get()
        log_and_print(f"[INFO] Steps run: {steps_run}, Final distance_to_goal: {final_dist:.3f}")
    else:
        log_and_print(f"[INFO] Steps run: {steps_run} (No-goal task)")
    
    # 📊 2D trajectory visualization - key output, always keep
    try:
        pass
        if map_path:
            pass
            log_and_print("[INFO] Creating trajectory visualization...")
            visualize_trajectory(ep, trajectory_positions, map_path, result_dir)
            log_and_print("[INFO] ✅ 2D trajectory visualization saved (key output)")
        else:
            pass
            log_and_print("[INFO] No map path provided, skipping trajectory visualization")
    except Exception as e:
        pass
        log_and_print(f"[ERROR] Failed to create visualization: {e}")
        import traceback
        traceback.print_exc()
    
    # 🚀 Ensure all log buffers are flushed
    try:
        pass
        flush_log_buffer()
    except Exception as e:
        pass
        print(f"[WARN] Failed to flush log buffer: {e}")
    
    # 🔇 Restore original stdout, print function and env vars (if silent mode was used)
    if perf_opts['silent_logging']:
        pass
        if 'original_stdout' in locals():
            pass
            sys.stdout = original_stdout
        # Clean up environment variables
        import os
        if 'SILENT_LOGGING_MODE' in os.environ:
            pass
            del os.environ['SILENT_LOGGING_MODE']
    
        # Environment will be closed by main function after all episodes
        log_and_print("[INFO] Episode completed, environment remains open for next episode")
        
        # Clean up logging handlers
        try:
            pass
            for handler in logging.root.handlers[:]:
                handler.close()
                logging.root.removeHandler(handler)
            log_and_print("[DEBUG] Logging handlers cleared")
        except Exception as e:
            pass
            log_and_print(f"[WARN] Failed to clear logging handlers: {e}")
        
        # Close log file
        try:
            pass
            logf.close()
            log_and_print("[INFO] Log file closed")
        except Exception as e:
            pass
            log_and_print(f"[WARN] Failed to close log file: {e}")


# 🚀 Performance optimization: batch log buffering (moved to run_episode internally)

# Helper function to log to both console and file (performance optimized)
def log_and_print(msg: str):
    """Print to console and write to log file (supports silent log mode)"""
    global perf_opts
    
    # Inline debug log detection function
    def _is_debug_log_msg_inline(msg: str) -> bool:
        """Check if it's a debug log (format: [Tag] content)"""
        import re
        debug_pattern = r'^\[([A-Z_]+)\]'
        return bool(re.match(debug_pattern, msg.strip()))
    
    # 🔇 Silent log mode: only write to log, print to terminal only for key info
    # Safety check: perf_opts may not exist (when called outside function)
    try:
        pass
        silent_logging = perf_opts['silent_logging']
    except (NameError, KeyError):
        pass
        silent_logging = False
    
    if silent_logging:
        # Only print truly important info to terminal, filter out detailed debug info
        important_keywords = [
            '[ERROR]', '[WARN]',
            '✅', '❌', '⏭️',  # episode状态
            '===== Processing Episode',  # episode开始
            '===== Starting Episode', '[CHECKPOINT]', '[BATCH]',  # episode状态
            'Episode completed', 'Episode failed',  # episode结果
            '模型:', '进度:', '已用时间:', '成功率:',  # 进度信息
            '测试完成', 'SAGE-Bench',  # 测试状态
            '======',  # 进度条分隔符
            '🚀', '📊', '⏱️', '📈', '⚡', '🎉',  # 进度条emoji
            'SAGE-Bench 测试进度', '总Episodes:', '开始时间:', '预计剩余:', '平均耗时:',
            '[进度]', '[状态]', 'Episode信息'  # 进度条相关文本
        ]

        # 排除详细调试信息
        excluded_keywords = [
            '[OBJECT_SUCCESS]', '[RGB_CAPTURE]', '[COLLISION_VIS]', '[CAMERA_UPDATE]',
            '[QUERY_VLM]', '[MODULAR_CLIENT]', '[SOCKET_CLIENT]', '[DEBUG]',
            '[COLLISION_2D]', '[EPISODE_RESET]', '[PHYSICS]', '[VLM]',
            '[DIRECT_MOVE]', '[DEPTH_CAPTURE]', '[IMAGE_INPUT]', '[PERF]',
            '[YAW_UPDATE]', '[SOCKET_PROTOCOL]', '[TEXT_PARSER]', '[MOVEMENT]',
            '[SAFE_MOVE]', '[MOVEMENT_RESULT]', '[COORD_TRANSFORM]', '[ACTION]',
            '[STEP]', '[ROTATION]', '[POSITION]', '[VELOCITY]', '[CONTROL]',
            '[SUCCESS]', '[ORACLE_SUCCESS]', '[CSR]', '[COL', '[INFO]'
        ]

        # 优先检查是否包含重要信息
        if any(keyword in msg for keyword in important_keywords):
            print(msg, flush=True)
        # 检查是否是需要排除的调试信息
        elif any(keyword in msg for keyword in excluded_keywords):
            pass  # 不打印，只写入日志
        # 使用正则表达式匹配所有带方括号的调试标签（通用过滤）
        elif _is_debug_log_msg_inline(msg):
            pass  # 不打印，只写入日志
        else:
            # 其他内容正常打印
            print(msg, flush=True)

        # 但所有日志都写入文件
        try:
            terminal_only = perf_opts.get('terminal_only', False)
        except (NameError, KeyError):
            terminal_only = False

        if terminal_only:
            # 仅终端模式：只打印不写日志
            print(msg, flush=True)
            return  # 直接返回，不写入日志文件
        else:
            # 默认模式：既打印又写日志
            print(msg, flush=True)

        if not terminal_only:
            try:
                batch_logging = perf_opts.get('batch_logging', False)

                # 安全检测运行期是否定义了批量日志缓冲
                has_log_buffer = 'log_buffer' in globals()
                has_buffer_size = 'log_buffer_size' in globals()
                has_flush = 'flush_log_buffer' in globals()
                has_log_file = 'logf' in globals()

                if batch_logging and has_log_buffer and has_buffer_size and has_flush:
                    try:
                        log_buffer.append(msg)
                        if len(log_buffer) >= log_buffer_size:
                            flush_log_buffer()
                    except Exception:
                        # 回退到直接写文件
                        if has_log_file:
                            try:
                                logf.write(msg + "\n")
                                logf.flush()
                                import os
                                os.fsync(logf.fileno())
                            except Exception:
                                pass
                else:
                    # 非批量/无缓冲定义：直接写日志文件（若可用）
                    if has_log_file:
                        try:
                            logf.write(msg + "\n")
                            logf.flush()
                            import os
                            os.fsync(logf.fileno())
                        except Exception:
                            pass
            except Exception:
                # 静默忽略日志写入失败，避免刷屏
                pass


# 设置VLM客户端的日志函数
set_log_function(log_and_print)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--scene_usd_path", "--scene-path", type=str, required=True, help="Path to scene USD/USDA file (single file) or folder (batch mode)")
    parser.add_argument("--traj_json_path", "--episodes-path", type=str, help="Path to episodes JSON file (single file mode)")
    parser.add_argument("--batch_test_dir", "--batch-test-dir", type=str, help="Directory containing multiple JSON files for batch testing")
    parser.add_argument("--json_pattern", "--json-pattern", type=str, default="test_*.json", help="Pattern to match JSON files (default: test_*.json)")
    parser.add_argument("--output_root", "--output-dir", type=str, default="output", help="Output directory")
    parser.add_argument("--goal-radius", "--goal_radius", type=float, default=0.5, help="Success radius in meters")
    parser.add_argument("--map_path", "--map-path", type=str, default="", help="Path to 2D semantic map JSON (single file) or folder (batch mode)")
    parser.add_argument("--vlm-host", "--vlm_host", type=str, default="localhost", help="VLM server host")
    parser.add_argument("--vlm-port", "--vlm_port", type=int, default=8888, help="VLM server port (NavDP default: 8888, NaVILA default: 54321)")
    parser.add_argument("--vlm-timeout", type=float, default=60.0, help="VLM server timeout in seconds")
    parser.add_argument("--model-type", "--model_type", type=str, default=None, 
                       help="Predefined VLM model type (e.g., navdp, navila) or use modular config params")
    
    # Modular configuration parameters
    parser.add_argument("--input-type", "--input_type", type=str, choices=["rgb", "rgbd"], 
                       help="Input type: rgb (RGB image sequence) or rgbd (RGB-D image)")
    parser.add_argument("--output-type", "--output_type", type=str, choices=["trajectory", "text"], 
                       help="Output type: trajectory (waypoints) or text (text action)")
    parser.add_argument("--protocol", type=str, choices=["http", "socket"], 
                       help="Communication protocol: http or socket")
    
    # Task type parameters
    parser.add_argument("--task-type", "--task_type", type=str, default="vln", 
                       choices=["vln", "objectnav", "pointnav", "imgnav", "nogoalnav"],
                       help="Navigation task type: vln, objectnav, pointnav, imgnav, nogoalnav")
    parser.add_argument("--headless", action="store_true", help="Run in headless mode")
    parser.add_argument("--disable-collision", action="store_true", help="Disable collision detection for debugging")
    parser.add_argument("--disable-autopilot", action="store_true", help="Disable auto-alignment, execute VLM commands directly")
    parser.add_argument("--max-episodes", "--max_episodes", type=int, default=-1, help="Maximum number of episodes to run")
    parser.add_argument("--start-idx", "--start_idx", type=int, default=0, help="Start index in episodes list")
    parser.add_argument("--num-episodes", "--num_episodes", type=int, default=-1, help="Number of episodes to run")
    parser.add_argument("--hz", type=int, default=30, help="Simulation frequency")
    parser.add_argument("--max-steps", "--max_steps", type=int, default=200, help="Maximum steps per episode")
    parser.add_argument("--skip-completed", "--skip_completed", action="store_true", default=True, help="Skip episodes that already have measurements files (enable checkpoint/resume functionality)")
    parser.add_argument("--no-skip-completed", "--no_skip_completed", dest="skip_completed", action="store_false", help="Disable checkpoint functionality, re-run all episodes")
    
    # Performance optimization parameters
    parser.add_argument("--fast-mode", action="store_true", help="Enable fast mode: disable debug output, reduce I/O, improve speed")
    parser.add_argument("--low-res", action="store_true", help="Use low resolution images (320x240) for faster processing")
    parser.add_argument("--minimal-logging", action="store_true", help="Minimize log output, keep only key info")
    parser.add_argument("--batch-logging", action="store_true", default=True, help="Enable batch log writing")
    parser.add_argument("--ultra-fast", action="store_true", help="Ultra-fast mode: enable all optimizations (may affect accuracy)")
    parser.add_argument("--enable-vlm-cache", action="store_true", help="Enable VLM response caching (experimental)")
    parser.add_argument("--adaptive-timeout", action="store_true", help="Enable adaptive VLM timeout")
    
    # Debug output control parameters
    parser.add_argument("--save-debug-files", action="store_true", default=False, help="Save debug files (videos, vlm_inputs) - disabled by default for performance")
    parser.add_argument("--no-debug-files", dest="save_debug_files", action="store_false", help="Disable debug file saving (default behavior)")
    parser.add_argument("--save-videos", action="store_true", help="Save episode video files")
    parser.add_argument("--save-vlm-inputs", action="store_true", help="Save VLM input images")
    
    # Progress display control parameters
    parser.add_argument("--quiet-progress", action="store_true", help="Quiet mode: simplify progress display, reduce terminal output")
    parser.add_argument("--no-progress", action="store_true", help="Disable progress display, keep only basic logs")
    parser.add_argument("--silent-logging", action="store_true", help="Silent logging mode: write to log file only, no terminal detail logs (keep progress bar)")
    parser.add_argument("--terminal-only", action="store_true", help="Terminal only mode: display only in terminal, no log file")
    
    # Backward compatible old parameters (deprecated but kept)
    parser.add_argument("--no-debug-images", action="store_true", help="[Deprecated] Use --no-debug-files instead")
    parser.add_argument("--no-videos", action="store_true", help="[Deprecated] Use --no-debug-files instead")
    
    args = parser.parse_args()

    # ===== 新增：启动前检测VLM server =====
    def check_vlm_server(host: str, port: int, timeout: int = 5) -> bool:
        import socket as _socket
        try:
            s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
            s.settimeout(timeout)
            s.connect((host, port))
            s.close()
            print(f"[VLM_CHECK] ✅ VLM server reachable at {host}:{port}")
            return True
        except Exception as e:
            print(f"[VLM_CHECK] ❌ VLM server NOT reachable at {host}:{port}")
            print(f"[VLM_CHECK] Error: {e}")
            return False

    if not check_vlm_server(args.vlm_host, args.vlm_port):
        sys.exit(1)
    # ===== 检测结束 =====

    # 验证参数：必须提供单文件路径或批量测试目录之一
    if not args.traj_json_path and not args.batch_test_dir:
        pass
        print("[ERROR] 必须提供 --traj_json_path 或 --batch_test_dir 参数之一")
        parser.print_help()
        return
    
    if args.traj_json_path and args.batch_test_dir:
        pass
        print("[ERROR] --traj_json_path 和 --batch_test_dir 不能同时提供，请选择其中一个")
        parser.print_help()
        return
    
    out_root = Path(args.output_root).resolve()
    out_root.mkdir(parents=True, exist_ok=True)
    print(f"[INFO] Output directory: {out_root}")
    # 显示断点继续功能状态
    if args.skip_completed:
        pass
        print("[INFO] 🔄 断点继续功能已启用：将跳过已完成的episode（有measurements文件）")
    else:
        pass
        print("[INFO] ⚠️  断点继续功能已禁用：将重新运行所有episode")
    
    # 🚀 超高速模式处理
    if args.ultra_fast:
        print("[INFO] ⚡ 超高速模式已启用：")
        # 启用所有性能优化
        args.fast_mode = True
        args.minimal_logging = True
        args.save_debug_files = False
        args.low_res = True
        args.silent_logging = True
        args.enable_vlm_cache = True
        args.adaptive_timeout = True
        print("     - 启用所有性能优化选项")
        print("     - 实验性VLM缓存")
        print("     - 自适应超时时间")
        print("     - ⚠️  可能影响测试准确性")
    
    # 🚀 快速模式处理
    if args.fast_mode:
        pass
        print("[INFO] 🚀 快速模式已启用：")
        # 自动启用相关的性能优化选项
        args.minimal_logging = True
        args.save_debug_files = False  # 快速模式下禁用调试文件
        args.low_res = True
        args.silent_logging = True  # 快速模式下启用静默日志
        print("     - 最小化日志输出")
        print("     - 禁用调试文件保存 (videos + vlm_inputs)")
        print("     - 使用低分辨率图像(320x240)")
        print("     - 启用静默日志模式 (减少终端输出，保留进度条)")
        print("     - 保留关键输出 (measurements + episode.log + 2D轨迹可视化)")
    
    # 🎥 调试输出状态显示
    if args.save_debug_files or args.save_videos or args.save_vlm_inputs:
        print("[INFO] 🎥 调试输出已启用：")
        if args.save_debug_files:
            print("     - 保存所有调试文件 (videos + vlm_inputs)")
        else:
            if args.save_videos:
                print("     - 保存episode视频")
            if args.save_vlm_inputs:
                print("     - 保存VLM输入图像")
    else:
        print("[INFO] 🚫 调试文件已禁用 (默认) - 仅保存关键输出")
    
    # 显示其他性能优化状态
    if args.low_res:
        pass
        print("[INFO] 📷 低分辨率模式：图像分辨率 320x240")
    if args.minimal_logging:
        pass
        print("[INFO] 📝 最小化日志模式：减少详细输出")
    
    # 🔇 日志模式状态显示
    if args.silent_logging:
        pass
        print("[INFO] 🔇 静默日志模式：终端仅显示进度条和关键信息，详细日志仍保存到文件")
    elif args.terminal_only:
        pass
        print("[INFO] 🖥️ 仅终端模式：只在终端显示，不写入日志文件")
    elif not args.silent_logging:
        pass
        print("[INFO] 📄 标准日志模式：终端显示+文件记录")
    
    # 向后兼容处理
    if args.no_debug_images or args.no_videos:
        pass
        print("[INFO] ⚠️  检测到已废弃参数，建议使用新的调试控制参数")
        if args.no_debug_images:
            pass
            args.save_vlm_inputs = False
        if args.no_videos:
            pass
            args.save_videos = False
    
    # 确定模型信息字符串用于汇总
    if args.model_type:
        pass
        model_info = f"predefined:{args.model_type}"
    elif args.input_type and args.output_type and args.protocol:
        pass
        model_info = f"modular:{args.input_type}+{args.output_type}+{args.protocol}"
    else:
        pass
        model_info = "default:navdp"
    
    # 批量测试模式
    if args.batch_test_dir:
        pass
        print(f"[INFO] ===== 批量测试模式 =====")
        print(f"[INFO] 批量测试目录: {args.batch_test_dir}")
        print(f"[INFO] JSON文件模式: {args.json_pattern}")
        print(f"[INFO] 输出根目录: {out_root}")
        print(f"[INFO] 模型配置: {model_info}")
        print(f"[INFO] ========================\n")
        
        # 扫描所有测试JSON文件
        json_files = find_test_json_files(args.batch_test_dir, args.json_pattern)
        if not json_files:
            pass
            print("[ERROR] 未找到匹配的JSON文件")
            return
        
        batch_results = []
        shared_env = None  # 共享环境
        
        # 🚀 初始化总体进度跟踪器
        total_episodes_count = 0
        for json_file in json_files:
            try:
                pass
                temp_episodes = adapt_gvln_to_episodes(json_file, "", goal_radius=args.goal_radius)
                if args.max_episodes > 0:
                    pass
                    temp_episodes = temp_episodes[:args.max_episodes]
                if args.start_idx > 0:
                    pass
                    temp_episodes = temp_episodes[args.start_idx:]
                if args.num_episodes > 0:
                    pass
                    temp_episodes = temp_episodes[:args.num_episodes]
                total_episodes_count += len(temp_episodes)
            except:
                pass
                pass  # 忽略无法解析的文件
        
        # 根据用户参数决定进度显示模式
        enable_progress = not args.no_progress
        enable_live_display = enable_progress and not args.quiet_progress
        progress_tracker = ProgressTracker(total_episodes_count, model_info, enable_live_display=enable_live_display) if enable_progress else None
        
        try:
            pass
            # 为批量测试创建第一个环境
            print(f"[BATCH] 初始化共享Isaac Sim环境...")
            first_json = json_files[0]
            first_scene_path = find_matching_scene_file(first_json, args.scene_usd_path) if os.path.isdir(args.scene_usd_path) else args.scene_usd_path
            # 初始化时不设置地图，稍后在每个文件处理时动态设置
            shared_env = SimpleVLNEnv(scene_usd_path=first_scene_path, headless=True, hz=args.hz, map_json_path="")
            print(f"[BATCH] 共享环境初始化成功")
        except Exception as e:
            pass
            print(f"[BATCH_ERROR] 共享环境初始化失败: {e}")
            return
        
        for i, json_file in enumerate(json_files, 1):
            print(f"\n[BATCH] ===== 处理文件 {i}/{len(json_files)} =====")
            print(f"[BATCH] 文件: {os.path.basename(json_file)}")
            print(f"[BATCH] 路径: {json_file}")
            print(f"[BATCH] 进度: {i}/{len(json_files)} ({i/len(json_files)*100:.1f}%)")
            
            try:
                pass
                # 自动匹配场景文件
                current_scene_path = ""
                print(f"[BATCH] 开始场景匹配...")
                if os.path.isdir(args.scene_usd_path):
                    pass
                    # 批量模式：自动匹配场景文件
                    current_scene_path = find_matching_scene_file(json_file, args.scene_usd_path)
                    print(f"[BATCH] 场景匹配结果: {current_scene_path if current_scene_path else '未找到'}")
                    if not current_scene_path:
                        pass
                        print(f"[BATCH_ERROR] 未找到匹配的场景文件，跳过: {json_file}")
                        batch_results.append({
                            "json_file": json_file,
                            "scene_file": "",
                            "map_file": "",
                            "status": "failed",
                            "reason": "scene_file_not_found",
                            "total_episodes": 0,
                            "successful_episodes": 0,
                            "failed_episodes": 0
                        })
                        continue
                else:
                    pass
                    # 单文件模式：直接使用指定的场景文件
                    current_scene_path = args.scene_usd_path
                
                print(f"[BATCH] 使用场景文件: {current_scene_path}")
                
                # 为每个JSON文件适配episodes
                episodes = adapt_gvln_to_episodes(json_file, current_scene_path, goal_radius=args.goal_radius)
                
                # slice episodes (应用到每个文件)
                original_episode_count = len(episodes)
                if args.max_episodes > 0:
                    pass
                    episodes = episodes[:args.max_episodes]
                if args.start_idx > 0:
                    pass
                    episodes = episodes[args.start_idx:]
                if args.num_episodes > 0:
                    pass
                    episodes = episodes[:args.num_episodes]
                
                print(f"[BATCH] Episodes: {len(episodes)} (原始: {original_episode_count})")
                
                if len(episodes) == 0:
                    pass
                    print(f"[BATCH] 跳过空文件: {json_file}")
                    batch_results.append({
                        "json_file": json_file,
                        "scene_file": current_scene_path,
                        "map_file": "",
                        "status": "skipped",
                        "reason": "no_episodes",
                        "total_episodes": 0,
                        "successful_episodes": 0,
                        "failed_episodes": 0
                    })
                    continue
                
                # 自动匹配地图文件
                current_map_path = ""
                if args.map_path:
                    pass
                    if os.path.isdir(args.map_path):
                        pass
                        # 批量模式：自动匹配地图文件
                        current_map_path = find_matching_map_file(json_file, args.map_path)
                        if not current_map_path:
                            pass
                            print(f"[BATCH_WARN] 未找到匹配的地图文件，将使用空地图路径")
                    else:
                        pass
                        # 单文件模式：直接使用指定的地图文件
                        current_map_path = args.map_path
                
                print(f"[BATCH] 使用地图文件: {current_map_path if current_map_path else '无'}")
                
                # 运行这个文件的测试
                print(f"[BATCH] 开始处理 {len(episodes)} 个episodes...")
                successful, failed = run_single_json_test(episodes, args, out_root, json_file, model_info, current_map_path, current_scene_path, close_env_on_finish=False, shared_env=shared_env, progress_tracker=progress_tracker)
                print(f"[BATCH] 文件处理完成: 成功={successful}, 失败={failed}")
                
                batch_results.append({
                    "json_file": json_file,
                    "scene_file": current_scene_path,
                    "map_file": current_map_path,
                    "status": "completed",
                    "total_episodes": len(episodes),
                    "successful_episodes": successful,
                    "failed_episodes": failed,
                    "success_rate": successful / len(episodes) if len(episodes) > 0 else 0.0
                })
                
            except Exception as e:
                pass
                print(f"[BATCH_ERROR] 处理文件失败: {json_file}")
                print(f"[BATCH_ERROR] 错误类型: {type(e).__name__}")
                print(f"[BATCH_ERROR] 错误信息: {e}")
                import traceback
                print(f"[BATCH_ERROR] 详细错误堆栈:")
                traceback.print_exc()
                
                batch_results.append({
                    "json_file": json_file,
                    "scene_file": current_scene_path if 'current_scene_path' in locals() else "",
                    "map_file": "",
                    "status": "failed",
                    "reason": f"{type(e).__name__}: {str(e)}",
                    "total_episodes": 0,
                    "successful_episodes": 0,
                    "failed_episodes": 0
                })
                
                print(f"[BATCH] 继续处理下一个文件...")
            
            print(f"[BATCH] 文件 {i}/{len(json_files)} 处理完毕")
            
            # ===== 新增：检测VLM server是否断连 =====
            if _vlm_server_disconnected:
                print(f"[BATCH] ⚠️ VLM server disconnected, stopping benchmark gracefully...")
                break
            # ===== 检测结束 =====

            # 强制垃圾回收，释放内存
            try:
                pass
                import gc
                gc.collect()
                print(f"[BATCH] 内存清理完成")
            except Exception:
                pass
                pass
        
        # 关闭共享环境
        if shared_env is not None:
            pass
            print(f"[BATCH] 关闭共享Isaac Sim环境...")
            try:
                pass
                shared_env.close()
                print(f"[BATCH] 共享环境已关闭")
            except Exception as e:
                pass
                print(f"[BATCH_ERROR] 关闭共享环境失败: {e}")
        
        # 🎉 显示最终进度总结
        if 'progress_tracker' in locals():
            pass
            progress_tracker.final_summary()
        
        # 保存批量测试汇总
        save_batch_summary(batch_results, out_root, model_info)
        return
    
    # 单文件测试模式（原有逻辑）
    else:
        pass
        print(f"[INFO] ===== 单文件测试模式 =====")
        print(f"[INFO] JSON文件: {args.traj_json_path}")
        print(f"[INFO] 输出目录: {out_root}")
        print(f"[INFO] 模型配置: {model_info}")
        print(f"[INFO] ========================\n")
        
        episodes = adapt_gvln_to_episodes(args.traj_json_path, args.scene_usd_path, goal_radius=args.goal_radius)
        # slice episodes
        if args.max_episodes > 0:
            pass
            episodes = episodes[:args.max_episodes]
        if args.start_idx > 0:
            pass
            episodes = episodes[args.start_idx:]
        if args.num_episodes > 0:
            pass
            episodes = episodes[:args.num_episodes]

        print(f"[INFO] Total episodes to run: {len(episodes)}", flush=True)
        
        # 🚀 为单个文件测试创建进度跟踪器
        enable_progress = not args.no_progress
        enable_live_display = enable_progress and not args.quiet_progress
        progress_tracker = ProgressTracker(len(episodes), model_info, enable_live_display=enable_live_display) if enable_progress else None
        
        successful, failed = run_single_json_test(episodes, args, out_root, args.traj_json_path, model_info, args.map_path, progress_tracker=progress_tracker)
        
        # 🎉 显示最终总结
        if progress_tracker:
            pass
            progress_tracker.final_summary()



if __name__ == "__main__":
    pass
    main()