Add files using upload-large-folder tool

scripts/cleanup.py

@@ -0,0 +1,33 @@
+import os
+import shutil
+
+def cleanup_generated_files():
+    """Cleans up generated scene files and datasets."""
+    # Define directories to clean up
+    scenes_dir = os.path.join("data", "scenes")
+    datasets_dir = os.path.join("data", "datasets")
+    logs_dir = "logs"
+
+    # Remove scenes directory if it exists
+    if os.path.exists(scenes_dir):
+        shutil.rmtree(scenes_dir)
+        print(f"Removed directory: {scenes_dir}")
+
+    # Remove datasets directory if it exists
+    if os.path.exists(datasets_dir):
+        shutil.rmtree(datasets_dir)
+        print(f"Removed directory: {datasets_dir}")
+
+    # Remove logs directory if it exists
+    if os.path.exists(logs_dir):
+        shutil.rmtree(logs_dir)
+        print(f"Removed directory: {logs_dir}")
+
+    # Optionally, create the directories again for fresh use
+    os.makedirs(scenes_dir, exist_ok=True)
+    os.makedirs(datasets_dir, exist_ok=True)
+    os.makedirs(logs_dir, exist_ok=True)
+    print("Cleanup complete. Directories have been recreated.")
+
+if __name__ == "__main__":
+    cleanup_generated_files()

scripts/generate_scenes.py

@@ -0,0 +1,315 @@
+import sys
+import os
+import argparse
+import shutil
+
+# Add project root to Python path
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, project_root)
+
+from src.coordinate_generator import generate_random_coordinates
+from src.scene_manager import SceneManager
+from src.config_manager import ConfigManager
+from src.utils.logging_utils import log_info, set_log_file
+from src.utils.file_utils import ensure_directory_exists
+
+def parse_arguments():
+    """Parse command-line arguments (supports config overrides)"""
+    parser = argparse.ArgumentParser(description='Batch generate ray-tracing scenes')
+    
+    # Config file arguments
+    parser.add_argument('--config', type=str, 
+                        help='Path to config file (default: configs/regions_config.yaml)')
+    parser.add_argument('--region', type=str,
+                        help='Use a predefined region (e.g., hefei, beijing, shanghai)')
+    
+    # Basic parameters (override config file)
+    parser.add_argument('--num-scenes', type=int,
+                        help='Number of scenes to generate')
+    parser.add_argument('--center-lat', type=float,
+                        help='Center latitude')
+    parser.add_argument('--center-lon', type=float,
+                        help='Center longitude')
+    parser.add_argument('--radius-km', type=float,
+                        help='Generation radius (km)')
+    parser.add_argument('--data-dir', type=str,
+                        help='Data storage directory')
+    parser.add_argument('--log-file', type=str,
+                        help='Log file path')
+    parser.add_argument('--size-x', type=int,
+                        help='Scene size X (meters)')
+    parser.add_argument('--size-y', type=int,
+                        help='Scene size Y (meters)')
+    
+    # Generation mode parameters
+    parser.add_argument('--generation-mode', type=str,
+                        choices=['fallback', 'osm_retry'],
+                        help='Scene generation mode')
+    parser.add_argument('--max-osm-attempts', type=int,
+                        help='Max attempts in OSM retry mode')
+    parser.add_argument('--search-radius-km', type=float,
+                        help='Search radius in OSM retry mode (km)')
+    
+    # Other parameters
+    parser.add_argument('--list-regions', action='store_true',
+                        help='List all available regions and exit')
+    parser.add_argument('--show-config', action='store_true',
+                        help='Show current configuration and exit')
+    
+    return parser.parse_args()
+
+def main():
+    """Main function"""
+    args = parse_arguments()
+    
+    # Initialize config manager
+    config_manager = ConfigManager(args.config)
+    
+    # Handle special commands
+    if args.list_regions:
+        regions = config_manager.list_available_regions()
+        print("Available regions:")
+        for region in regions:
+            region_config = config_manager.get_region_config(region)
+            print(f"  {region}: {region_config.get('name', 'Unnamed')} - "
+                  f"({region_config.get('center_lat')}, {region_config.get('center_lon')})")
+        return True
+    
+    if args.show_config:
+        print("Current configuration:")
+        print(f"  Config file: {config_manager.config_file_path}")
+        print(f"  Default region: {config_manager.get('default_region.name', 'Not set')}")
+        print(f"  Generation mode: {config_manager.get('scene_generation.generation_mode', 'Not set')}")
+        print(f"  Data directory: {config_manager.get('data_storage.base_data_dir', 'Not set')}")
+        return True
+    
+    # Merge config file and CLI args
+    config = config_manager.merge_with_args(args)
+    
+    # If a region is specified, use its config
+    if args.region:
+        region_config = config_manager.get_region_config(args.region)
+        if region_config:
+            config.update(region_config)
+            log_info(f"Using region config: {args.region} - {region_config.get('name', 'Unnamed')}")
+    
+    # Set up logging
+    ensure_directory_exists('logs')
+    set_log_file(config['log_file'])
+    
+    # Ensure data directory exists
+    data_dir_abs = os.path.abspath(config['data_dir'])
+    if not ensure_directory_exists(data_dir_abs):
+        log_info(f"Failed to create data directory: {data_dir_abs}")
+        return False
+    
+    # Show configuration info
+    log_info(f"Start generating {config['num_scenes']} scenes")
+    log_info(f"Center coordinates: ({config['center_lat']}, {config['center_lon']})")
+    log_info(f"Generation radius: {config['radius_km']} km")
+    log_info(f"Scene size: {config['size_x']}x{config['size_y']} meters")
+    log_info(f"Data directory: {data_dir_abs}")
+    log_info(f"Generation mode: {config['generation_mode']}")
+    
+    if config['generation_mode'] == 'fallback':
+        log_info("Strategy: Prefer OSM data; if it fails, automatically generate random building scenes")
+    elif config['generation_mode'] == 'osm_retry':
+        log_info("Strategy: Prefer OSM data; if it fails, re-sample within search radius and retry OSM")
+        log_info(f"OSM retry params - Max attempts: {config['max_osm_attempts']}, "
+                f"Search radius: {config['search_radius_km']}km")
+    
+    # Generate random coordinates
+    coordinates = generate_random_coordinates(
+        center_lat=config['center_lat'],
+        center_lon=config['center_lon'],
+        radius_km=config['radius_km'],
+        num_points=config['num_scenes']
+    )
+    
+    log_info(f"Generated {len(coordinates)} coordinate points")
+    
+    # Initialize scene manager
+    scene_manager = SceneManager(config_manager)
+    
+    # Batch generate scenes
+    successful_scenes = scene_manager.batch_generate_scenes(
+        coordinates,
+        generation_mode=config['generation_mode'],
+        max_osm_attempts=config['max_osm_attempts'],
+        search_radius_km=config['search_radius_km']
+    )
+    
+    log_info(f"Scene generation completed! Success: {len(successful_scenes)}/{len(coordinates)}")
+    
+    # Show details of generated scenes
+    if successful_scenes:
+        log_info("Details of successfully generated scenes:")
+        osm_scenes = []
+        random_scenes = []
+        
+        for i, scene_result in enumerate(successful_scenes, 1):
+            scene_file = scene_result['scene_file']
+            generation_type = scene_result['generation_type']
+            attempts = scene_result['attempts']
+            original_coords = scene_result['original_coordinates']
+            actual_coords = scene_result['coordinates']
+            
+            log_info(f"  {i}. {os.path.basename(os.path.dirname(scene_file))} - "
+                    f"Type: {generation_type} - Attempts: {attempts} times")
+            log_info(f"     Original coordinates: ({original_coords[0]:.6f}, {original_coords[1]:.6f})")
+            
+            if generation_type == 'OSM':
+                osm_scenes.append(scene_result)
+                if 'distance_from_original' in scene_result:
+                    distance = scene_result['distance_from_original']
+                    log_info(f"     Actual coordinates: ({actual_coords[0]:.6f}, {actual_coords[1]:.6f}) "
+                            f"Offset: {distance:.2f}km")
+                else:
+                    log_info(f"     Actual coordinates: ({actual_coords[0]:.6f}, {actual_coords[1]:.6f}) "
+                            f"Offset: 0.00km")
+            else:
+                random_scenes.append(scene_result)
+                log_info(f"     Actual coordinates: ({actual_coords[0]:.6f}, {actual_coords[1]:.6f})")
+        
+        # Statistics
+        log_info(f"\nScene type statistics:")
+        log_info(f"  OSM scenes: {len(osm_scenes)}")
+        log_info(f"  Random scenes: {len(random_scenes)}")
+        
+        if config['generation_mode'] == 'osm_retry' and osm_scenes:
+            total_attempts = sum(s['attempts'] for s in osm_scenes)
+            avg_attempts = total_attempts / len(osm_scenes)
+            total_distance = sum(s.get('distance_from_original', 0) for s in osm_scenes)
+            avg_distance = total_distance / len(osm_scenes)
+            log_info(f"  Average attempts for OSM scenes: {avg_attempts:.1f}")
+            log_info(f"  Average offset distance for OSM scenes: {avg_distance:.2f}km")
+    
+    # Adjust scene directory names by removing _attempt/_random suffixes
+    successful_scenes = sanitize_scene_directories(successful_scenes)
+
+    # Save generation results
+    save_generation_results(successful_scenes, coordinates, config, data_dir_abs)
+    
+    return len(successful_scenes) > 0
+
+def sanitize_scene_directories(scenes):
+    """Remove _attempt/_random suffix from scene directory names"""
+    sanitized = []
+    for scene in scenes:
+        scene_file = scene.get('scene_file')
+        if not scene_file:
+            sanitized.append(scene)
+            continue
+        scene_dir = os.path.dirname(scene_file)
+        original_name = os.path.basename(scene_dir)
+        stripped_name = _strip_scene_suffix(original_name)
+        if stripped_name == original_name:
+            sanitized.append(scene)
+            continue
+        parent_dir = os.path.dirname(scene_dir)
+        new_dir = os.path.join(parent_dir, stripped_name)
+        if os.path.exists(new_dir):
+            shutil.rmtree(new_dir)
+        os.rename(scene_dir, new_dir)
+        updated_scene = dict(scene)
+        updated_scene['scene_file'] = os.path.join(new_dir, os.path.basename(scene_file))
+        if 'scene_directory' in updated_scene:
+            updated_scene['scene_directory'] = new_dir
+        sanitized.append(updated_scene)
+    return sanitized
+
+def _strip_scene_suffix(name: str) -> str:
+    """Remove suffixes like _attempt/_random from scene directory names"""
+    if '_attempt_' in name:
+        return name.split('_attempt_')[0]
+    if name.endswith('_random'):
+        return name[:-7]
+    return name
+
+def save_generation_results(successful_scenes, coordinates, config, data_dir_abs):
+    """Save generation results to files"""
+    # Save list of successful scenes
+    scenes_list_file = os.path.join(data_dir_abs, 'generated_scenes.txt')
+    try:
+        with open(scenes_list_file, 'w', encoding='utf-8') as f:
+            f.write(f"# Generated scene list\n")
+            f.write(f"# Total: {len(successful_scenes)}/{len(coordinates)}\n")
+            f.write(f"# Generation time: {os.popen('date').read().strip()}\n")
+            f.write(f"# Center coordinates: ({config['center_lat']}, {config['center_lon']})\n")
+            f.write(f"# Generation radius: {config['radius_km']} km\n")
+            f.write(f"# Scene size: {config['size_x']}x{config['size_y']} meters\n")
+            f.write(f"# Generation mode: {config['generation_mode']}\n")
+            if config['generation_mode'] == 'osm_retry':
+                f.write(f"# OSM retry params: max attempts {config['max_osm_attempts']}, search radius {config['search_radius_km']}km\n")
+            f.write(f"\n")
+            f.write(f"# Format: scene_file_path\toriginal_lat\toriginal_lon\tactual_lat\tactual_lon\tgeneration_type\tattempts\toffset_distance(km)\n")
+            
+            for scene_result in successful_scenes:
+                scene_file = scene_result['scene_file']
+                original_coords = scene_result['original_coordinates']
+                actual_coords = scene_result['coordinates']
+                generation_type = scene_result['generation_type']
+                attempts = scene_result['attempts']
+                distance = scene_result.get('distance_from_original', 0.0)
+                
+                f.write(f"{scene_file}\t{original_coords[0]:.6f}\t{original_coords[1]:.6f}\t"
+                       f"{actual_coords[0]:.6f}\t{actual_coords[1]:.6f}\t{generation_type}\t"
+                       f"{attempts}\t{distance:.2f}\n")
+                    
+        log_info(f"Scene list saved to: {scenes_list_file}")
+    except Exception as e:
+        log_info(f"Failed to save scene list: {e}")
+    
+    # Generate scene statistics report
+    try:
+        stats_file = os.path.join(data_dir_abs, 'generation_stats.txt')
+        osm_scenes = [s for s in successful_scenes if s['generation_type'] == 'OSM']
+        random_scenes = [s for s in successful_scenes if s['generation_type'] == 'Random']
+        
+        with open(stats_file, 'w', encoding='utf-8') as f:
+            f.write("Scene generation statistics report\n")
+            f.write("=" * 50 + "\n")
+            f.write(f"Requested scene count: {len(coordinates)}\n")
+            f.write(f"Successfully generated scenes: {len(successful_scenes)}\n")
+            f.write(f"Failed scene count: {len(coordinates) - len(successful_scenes)}\n")
+            f.write(f"Success rate: {len(successful_scenes)/len(coordinates)*100:.1f}%\n")
+            f.write(f"Center coordinates: ({config['center_lat']}, {config['center_lon']})\n")
+            f.write(f"Generation radius: {config['radius_km']} km\n")
+            f.write(f"Scene size: {config['size_x']}x{config['size_y']} meters\n")
+            f.write(f"Generation mode: {config['generation_mode']}\n")
+            
+            f.write(f"\nScene type statistics:\n")
+            f.write(f"OSM scenes: {len(osm_scenes)} ({len(osm_scenes)/len(successful_scenes)*100:.1f}%)\n")
+            f.write(f"Random scenes: {len(random_scenes)} ({len(random_scenes)/len(successful_scenes)*100:.1f}%)\n")
+            
+            if config['generation_mode'] == 'osm_retry' and osm_scenes:
+                total_attempts = sum(s['attempts'] for s in osm_scenes)
+                avg_attempts = total_attempts / len(osm_scenes)
+                total_distance = sum(s.get('distance_from_original', 0) for s in osm_scenes)
+                avg_distance = total_distance / len(osm_scenes)
+                
+                f.write(f"\nOSM retry statistics:\n")
+                f.write(f"Configured max attempts: {config['max_osm_attempts']}\n")
+                f.write(f"Configured search radius: {config['search_radius_km']} km\n")
+                f.write(f"Average attempts: {avg_attempts:.1f}\n")
+                f.write(f"Average offset distance: {avg_distance:.2f} km\n")
+                f.write(f"Total attempts: {total_attempts}\n")
+                
+                # Attempt count distribution
+                attempt_counts = {}
+                for s in osm_scenes:
+                    attempts = s['attempts']
+                    attempt_counts[attempts] = attempt_counts.get(attempts, 0) + 1
+                
+                f.write(f"\nAttempts distribution:\n")
+                for attempts in sorted(attempt_counts.keys()):
+                    count = attempt_counts[attempts]
+                    f.write(f"  {attempts} times: {count} scenes\n")
+            
+        log_info(f"Statistics report saved to: {stats_file}")
+    except Exception as e:
+        log_info(f"Failed to save statistics report: {e}")
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)

scripts/run_raytracing.py

@@ -0,0 +1,169 @@
+import sys
+import os
+import argparse
+
+# Add project root to Python path
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, project_root)
+
+from src.raytracer.raytracing_manager import RaytracingManager
+from src.config_manager import ConfigManager
+from src.utils.logging_utils import log_info, set_log_file
+from src.utils.file_utils import ensure_directory_exists
+
+def parse_arguments():
+    """Parse command-line arguments"""
+    parser = argparse.ArgumentParser(description='Batch execute ray tracing')
+    
+    # Config file arguments
+    parser.add_argument('--config', type=str, 
+                        help='Config file path (default: configs/regions_config.yaml)')
+    
+    # Ray tracing parameters
+    parser.add_argument('--scenes-dir', type=str,
+                        help='Scenes directory path')
+    parser.add_argument('--results-dir', type=str,
+                        help='Results output directory')
+    parser.add_argument('--max-workers', type=int, default=None,
+                        help='Maximum parallel workers (default uses config file)')
+    parser.add_argument('--gpu-mode', type=str,
+                        choices=['auto', 'all', 'cpu_only'],
+                        help='GPU usage mode')
+    
+    # Scene selection parameters
+    parser.add_argument('--scene-pattern', type=str,
+                        help='Scene name matching pattern')
+    parser.add_argument('--max-scenes', type=int,
+                        help='Maximum number of scenes to process')
+    
+    # Other parameters
+    parser.add_argument('--log-file', type=str,
+                        help='Log file path')
+    parser.add_argument('--show-config', action='store_true',
+                        help='Show current configuration and exit')
+    parser.add_argument('--list-scenes', action='store_true',
+                        help='List available scenes and exit')
+    
+    return parser.parse_args()
+
+def safe_get_frequency(raytracing_config, default=3.66e9):
+    """Safely get frequency value, handling string and numeric types"""
+    try:
+        frequency = raytracing_config.get('simulation', {}).get('frequency', default)
+        # If it is a string, try to convert to float
+        if isinstance(frequency, str):
+            frequency = float(frequency)
+        return frequency
+    except (ValueError, TypeError):
+        log_info(f"Warning: Failed to parse frequency value, using default {default/1e9:.2f} GHz")
+        return default
+
+def main():
+    """Main function"""
+    args = parse_arguments()
+    
+    # Initialize config manager
+    config_manager = ConfigManager(args.config)
+    
+    # Handle special commands
+    if args.show_config:
+        print("Current ray tracing configuration:")
+        raytracing_config = config_manager.get('raytracing', {})
+        print(f"  Engine: {raytracing_config.get('engine', 'Not set')}")
+        print(f"  GPU mode: {raytracing_config.get('gpu_config', {}).get('gpu_mode', 'Not set')}")
+        print(f"  Max parallel jobs: {raytracing_config.get('max_parallel_jobs', 'Not set')}")
+        
+        # Safely get frequency
+        frequency = safe_get_frequency(raytracing_config)
+        print(f"  Frequency: {frequency/1e9:.2f} GHz")
+        
+        # Show visualization configuration
+        viz_config = config_manager.get('visualization', {})
+        print(f"  Heatmap generation: {'Enabled' if viz_config.get('enabled', False) else 'Disabled'}")
+        return True
+    
+    # Merge config file and CLI args
+    effective_workers = args.max_workers if args.max_workers is not None else config_manager.get(
+        'raytracing.max_parallel_jobs', 1
+    ) or 1
+    if args.gpu_mode:
+        config_manager.config.setdefault('raytracing', {}).setdefault('gpu_config', {})['gpu_mode'] = args.gpu_mode
+    config_manager.config.setdefault('raytracing', {}).setdefault('gpu_config', {})
+    config_manager.config['raytracing']['max_parallel_jobs'] = effective_workers
+    
+    # Ensure visualization config exists
+    if 'visualization' not in config_manager.config:
+        config_manager.config['visualization'] = {
+            'enabled': True,
+            'point_size': 50,
+            'dpi': 300
+        }
+    
+    # Fill in minimum samples ratio default
+    sim_cfg = config_manager.config.setdefault('raytracing', {}).setdefault('simulation', {})
+    sim_cfg.setdefault('min_samples_ratio', 0.5)
+
+    # Set up logging
+    log_file = args.log_file or 'logs/raytracing.log'
+    ensure_directory_exists('logs')
+    set_log_file(log_file)
+    
+    # Initialize ray tracing manager
+    raytracing_manager = RaytracingManager(config_manager)
+    
+    # Discover scenes
+    scenes = raytracing_manager.discover_scenes()
+    
+    if args.list_scenes:
+        print(f"Found {len(scenes)} available scenes:")
+        for scene in scenes:
+            print(f"  {scene['scene_name']} - ({scene['latitude']:.6f}, {scene['longitude']:.6f})")
+        return True
+    
+    if not scenes:
+        log_info("No available scene files found")
+        return False
+    
+    # Filter scenes
+    if args.scene_pattern:
+        scenes = [s for s in scenes if args.scene_pattern in s['scene_name']]
+        log_info(f"After filtering by pattern '{args.scene_pattern}', {len(scenes)} scenes remain")
+    
+    if args.max_scenes and len(scenes) > args.max_scenes:
+        scenes = scenes[:args.max_scenes]
+        log_info(f"Limiting number of scenes to process to {args.max_scenes}")
+    
+    # Display configuration info
+    raytracing_config = config_manager.get('raytracing', {})
+    log_info(f"Starting ray tracing, scene count: {len(scenes)}")
+    log_info(f"Engine: {raytracing_config.get('engine', 'sionna')}")
+    log_info(f"GPU mode: {raytracing_config.get('gpu_config', {}).get('gpu_mode', 'auto')}")
+    
+    # Safely get and display frequency
+    frequency = safe_get_frequency(raytracing_config)
+    log_info(f"Frequency: {frequency/1e9:.2f} GHz")
+    log_info(f"Max parallel jobs: {raytracing_config.get('max_parallel_jobs', 1)}")
+    
+    # Execute ray tracing
+    results = raytracing_manager.run_batch_raytracing(scenes, max_workers=effective_workers)
+    
+    # Display results
+    successful_results = [r for r in results if r['success']]
+    log_info(f"Ray tracing completed! Success: {len(successful_results)}/{len(scenes)}")
+    
+    if successful_results:
+        log_info("Successfully processed scenes:")
+        for result in successful_results:
+            scene_name = result['scene_info']['scene_name']
+            execution_time = result['execution_time']
+            num_paths = result.get('num_paths', 0)
+            num_receivers = result.get('num_receivers', 0)
+            
+            log_info(f"  {scene_name}: {execution_time:.1f}s, "
+                    f"{num_receivers} receivers, {num_paths} paths")
+    
+    return len(successful_results) > 0
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)