From 5de89d64e28d26c89e87fcd9fcecb224b3fe3752 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Thu, 18 Dec 2025 14:45:21 +0800 Subject: [PATCH 01/21] =?UTF-8?q?=E6=96=B0=E5=A2=9ELiDAR=E6=95=B0=E6=8D=AE?= =?UTF-8?q?=E5=A4=84=E7=90=86=EF=BC=8C=E5=A2=9E=E5=BC=BA=E4=BC=A0=E6=84=9F?= =?UTF-8?q?=E5=99=A8=E7=B3=BB=E7=BB=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../annotation_generator.py | 168 +++ .../config_manager.py | 108 ++ .../data_analyzer.py | 337 ++++++ .../data_validator.py | 309 ++++++ .../lidar_processor.py | 274 +++++ src/enhance_pedestrian_safety/main.py | 989 +++++++++++------- .../scene_manager.py | 245 +++++ 7 files changed, 2036 insertions(+), 394 deletions(-) create mode 100644 src/enhance_pedestrian_safety/annotation_generator.py create mode 100644 src/enhance_pedestrian_safety/config_manager.py create mode 100644 src/enhance_pedestrian_safety/data_analyzer.py create mode 100644 src/enhance_pedestrian_safety/data_validator.py create mode 100644 src/enhance_pedestrian_safety/lidar_processor.py create mode 100644 src/enhance_pedestrian_safety/scene_manager.py diff --git a/src/enhance_pedestrian_safety/annotation_generator.py b/src/enhance_pedestrian_safety/annotation_generator.py new file mode 100644 index 0000000000..d443854d96 --- /dev/null +++ b/src/enhance_pedestrian_safety/annotation_generator.py @@ -0,0 +1,168 @@ +import json +import os +import numpy as np +from datetime import datetime + + +class AnnotationGenerator: + """标注生成器""" + + def __init__(self, output_dir): + self.output_dir = output_dir + self.annotations_dir = os.path.join(output_dir, "annotations") + os.makedirs(self.annotations_dir, exist_ok=True) + + self.frame_annotations = {} + self.object_counter = 0 + + def detect_objects(self, world, frame_num, timestamp): + """检测场景中的物体""" + annotations = { + 'frame_id': frame_num, + 'timestamp': timestamp, + 'objects': [], + 'camera_info': {} + } + + try: + actors = world.get_actors() + + for actor in actors: + obj_type = actor.type_id + + if 'vehicle' in obj_type or 'walker' in obj_type: + obj_info = self._extract_object_info(actor) + if obj_info: + annotations['objects'].append(obj_info) + self.object_counter += 1 + + self._save_annotations(frame_num, annotations) + return annotations + + except Exception as e: + print(f"物体检测失败: {e}") + return annotations + + def _extract_object_info(self, actor): + """提取物体信息""" + try: + bbox = actor.bounding_box + location = actor.get_location() + velocity = actor.get_velocity() + + obj_info = { + 'id': actor.id, + 'type': actor.type_id, + 'class': self._get_object_class(actor.type_id), + 'location': { + 'x': float(location.x), + 'y': float(location.y), + 'z': float(location.z) + }, + 'velocity': { + 'x': float(velocity.x), + 'y': float(velocity.y), + 'z': float(velocity.z) + }, + 'bounding_box': { + 'extent': { + 'x': float(bbox.extent.x), + 'y': float(bbox.extent.y), + 'z': float(bbox.extent.z) + } + }, + 'attributes': { + 'is_alive': actor.is_alive + } + } + + return obj_info + + except Exception as e: + return None + + def _get_object_class(self, type_id): + """获取物体类别""" + type_lower = type_id.lower() + + if 'vehicle' in type_lower: + if 'tesla' in type_lower: + return 'car' + elif 'audi' in type_lower: + return 'car' + elif 'mini' in type_lower: + return 'car' + elif 'mercedes' in type_lower: + return 'car' + elif 'nissan' in type_lower: + return 'car' + elif 'bmw' in type_lower: + return 'car' + else: + return 'vehicle' + + elif 'walker' in type_lower: + return 'pedestrian' + + elif 'traffic' in type_lower: + return 'traffic_light' + + else: + return 'unknown' + + def _save_annotations(self, frame_num, annotations): + """保存标注到文件""" + filename = f"frame_{frame_num:06d}.json" + filepath = os.path.join(self.annotations_dir, filename) + + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(annotations, f, indent=2, ensure_ascii=False) + + # 同时更新总标注文件 + self.frame_annotations[frame_num] = annotations + self._update_master_annotation() + + def _update_master_annotation(self): + """更新主标注文件""" + master_file = os.path.join(self.annotations_dir, "annotations.json") + + master_data = { + 'total_frames': len(self.frame_annotations), + 'total_objects': self.object_counter, + 'frames': list(self.frame_annotations.keys()), + 'created': datetime.now().isoformat() + } + + with open(master_file, 'w', encoding='utf-8') as f: + json.dump(master_data, f, indent=2, ensure_ascii=False) + + def generate_summary(self): + """生成标注摘要""" + vehicle_count = 0 + pedestrian_count = 0 + other_count = 0 + + for frame_data in self.frame_annotations.values(): + for obj in frame_data.get('objects', []): + if obj['class'] in ['car', 'vehicle']: + vehicle_count += 1 + elif obj['class'] == 'pedestrian': + pedestrian_count += 1 + else: + other_count += 1 + + summary = { + 'total_frames': len(self.frame_annotations), + 'total_objects': self.object_counter, + 'vehicles': vehicle_count, + 'pedestrians': pedestrian_count, + 'other_objects': other_count, + 'average_objects_per_frame': self.object_counter / len( + self.frame_annotations) if self.frame_annotations else 0 + } + + summary_file = os.path.join(self.annotations_dir, "summary.json") + with open(summary_file, 'w', encoding='utf-8') as f: + json.dump(summary, f, indent=2, ensure_ascii=False) + + return summary \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py new file mode 100644 index 0000000000..38622ee18a --- /dev/null +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -0,0 +1,108 @@ +import json +import os +import argparse + + +class ConfigManager: + + @staticmethod + def load_config(config_file=None): + config = { + 'scenario': { + 'name': 'multi_sensor_scene', + 'town': 'Town10HD', + 'weather': 'clear', + 'time_of_day': 'noon', + 'duration': 60, + 'seed': 42 + }, + 'traffic': { + 'ego_vehicles': 1, + 'background_vehicles': 8, + 'pedestrians': 6, + 'traffic_lights': True + }, + 'sensors': { + 'vehicle_cameras': 4, + 'infrastructure_cameras': 4, + 'lidar_sensors': 1, + 'radar_sensors': 0, + 'image_size': [1280, 720], + 'capture_interval': 2.0, + 'lidar_config': { + 'channels': 32, + 'range': 100, + 'points_per_second': 56000, + 'rotation_frequency': 10 + } + }, + 'output': { + 'data_dir': 'cvips_dataset', + 'save_raw': True, + 'save_stitched': True, + 'save_annotations': False, + 'save_lidar': True, + 'save_fusion': True, + 'validate_data': True, + 'run_analysis': False + } + } + + if config_file and os.path.exists(config_file): + try: + with open(config_file, 'r') as f: + user_config = json.load(f) + ConfigManager._deep_update(config, user_config) + except: + pass + + return config + + @staticmethod + def _deep_update(original, update): + for key, value in update.items(): + if key in original and isinstance(original[key], dict) and isinstance(value, dict): + ConfigManager._deep_update(original[key], value) + else: + original[key] = value + + @staticmethod + def merge_args(config, args): + if args.scenario: + config['scenario']['name'] = args.scenario + if args.town: + config['scenario']['town'] = args.town + if args.weather: + config['scenario']['weather'] = args.weather + if args.time_of_day: + config['scenario']['time_of_day'] = args.time_of_day + if args.duration: + config['scenario']['duration'] = args.duration + if args.seed: + config['scenario']['seed'] = args.seed + + if args.num_vehicles: + config['traffic']['background_vehicles'] = args.num_vehicles + if args.num_pedestrians: + config['traffic']['pedestrians'] = args.num_pedestrians + + if args.capture_interval: + config['sensors']['capture_interval'] = args.capture_interval + + if args.enable_lidar: + config['sensors']['lidar_sensors'] = 1 + config['output']['save_lidar'] = True + + if args.enable_fusion: + config['output']['save_fusion'] = True + + if args.enable_annotations: + config['output']['save_annotations'] = True + + if args.skip_validation: + config['output']['validate_data'] = False + + if args.run_analysis: + config['output']['run_analysis'] = True + + return config \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/data_analyzer.py b/src/enhance_pedestrian_safety/data_analyzer.py new file mode 100644 index 0000000000..a5802c2dc4 --- /dev/null +++ b/src/enhance_pedestrian_safety/data_analyzer.py @@ -0,0 +1,337 @@ +import os +import json +import numpy as np +from collections import defaultdict + + +class DataAnalyzer: + """数据分析器 - 生成数据集统计信息""" + + @staticmethod + def analyze_dataset(data_dir): + """分析数据集并生成详细报告""" + print(f"分析数据集: {data_dir}") + + analysis = { + 'basic_stats': DataAnalyzer._get_basic_stats(data_dir), + 'file_distribution': DataAnalyzer._analyze_file_distribution(data_dir), + 'object_statistics': DataAnalyzer._analyze_objects(data_dir), + 'temporal_analysis': DataAnalyzer._analyze_temporal(data_dir), + 'quality_metrics': DataAnalyzer._calculate_quality_metrics(data_dir) + } + + # 生成评分 + analysis['overall_score'] = DataAnalyzer._calculate_overall_score(analysis) + + # 保存分析结果 + DataAnalyzer._save_analysis_report(data_dir, analysis) + + # 打印摘要 + DataAnalyzer._print_analysis_summary(analysis) + + return analysis + + @staticmethod + def _get_basic_stats(data_dir): + """获取基本统计信息""" + stats = { + 'total_size_mb': DataAnalyzer._get_directory_size(data_dir), + 'file_count': 0, + 'directory_count': 0, + 'data_types': defaultdict(int) + } + + for root, dirs, files in os.walk(data_dir): + stats['directory_count'] += len(dirs) + stats['file_count'] += len(files) + + for file in files: + ext = os.path.splitext(file)[1].lower() + if ext in ['.png', '.jpg', '.jpeg']: + stats['data_types']['images'] += 1 + elif ext == '.json': + stats['data_types']['json'] += 1 + elif ext == '.txt': + stats['data_types']['text'] += 1 + elif ext == '.bin': + stats['data_types']['binary'] += 1 + else: + stats['data_types']['other'] += 1 + + return stats + + @staticmethod + def _get_directory_size(path): + """计算目录大小""" + total = 0 + for dirpath, dirnames, filenames in os.walk(path): + for f in filenames: + fp = os.path.join(dirpath, f) + if os.path.exists(fp): + total += os.path.getsize(fp) + return round(total / (1024 * 1024), 2) + + @staticmethod + def _analyze_file_distribution(data_dir): + """分析文件分布""" + distribution = {} + + # 分析原始图像 + raw_dirs = ['vehicle', 'infrastructure'] + for raw_dir in raw_dirs: + path = os.path.join(data_dir, "raw", raw_dir) + if os.path.exists(path): + camera_stats = {} + for camera_dir in os.listdir(path): + camera_path = os.path.join(path, camera_dir) + if os.path.isdir(camera_path): + images = [f for f in os.listdir(camera_path) + if f.endswith(('.png', '.jpg', '.jpeg'))] + camera_stats[camera_dir] = len(images) + distribution[f'raw_{raw_dir}'] = camera_stats + + # 分析拼接图像 + stitched_dir = os.path.join(data_dir, "stitched") + if os.path.exists(stitched_dir): + stitched_images = [f for f in os.listdir(stitched_dir) + if f.endswith(('.jpg', '.jpeg', '.png'))] + distribution['stitched'] = len(stitched_images) + + # 分析标注文件 + annotations_dir = os.path.join(data_dir, "annotations") + if os.path.exists(annotations_dir): + json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] + distribution['annotations'] = len(json_files) + + return distribution + + @staticmethod + def _analyze_objects(data_dir): + """分析物体统计""" + annotations_dir = os.path.join(data_dir, "annotations") + + if not os.path.exists(annotations_dir): + return {'total_objects': 0, 'by_class': {}, 'by_frame': {}} + + object_stats = { + 'total_objects': 0, + 'by_class': defaultdict(int), + 'by_frame': defaultdict(int), + 'class_distribution': {} + } + + json_files = [f for f in os.listdir(annotations_dir) + if f.endswith('.json') and f.startswith('frame_')] + + for json_file in json_files: + try: + with open(os.path.join(annotations_dir, json_file), 'r') as f: + data = json.load(f) + + frame_id = data.get('frame_id', 0) + objects = data.get('objects', []) + + object_stats['by_frame'][frame_id] = len(objects) + object_stats['total_objects'] += len(objects) + + for obj in objects: + obj_class = obj.get('class', 'unknown') + object_stats['by_class'][obj_class] += 1 + + except Exception as e: + print(f"分析标注文件 {json_file} 失败: {e}") + + # 计算类分布百分比 + if object_stats['total_objects'] > 0: + for obj_class, count in object_stats['by_class'].items(): + object_stats['class_distribution'][obj_class] = round( + count / object_stats['total_objects'] * 100, 2) + + return object_stats + + @staticmethod + def _analyze_temporal(data_dir): + """分析时间分布""" + temporal_stats = { + 'frame_intervals': [], + 'total_duration': 0, + 'frame_rate': 0 + } + + metadata_file = os.path.join(data_dir, "metadata", "collection_info.json") + if os.path.exists(metadata_file): + try: + with open(metadata_file, 'r') as f: + metadata = json.load(f) + + collection_stats = metadata.get('collection_stats', {}) + temporal_stats['total_duration'] = collection_stats.get('duration_seconds', 0) + temporal_stats['frame_rate'] = collection_stats.get('average_fps', 0) + + except Exception as e: + print(f"分析元数据失败: {e}") + + return temporal_stats + + @staticmethod + def _calculate_quality_metrics(data_dir): + """计算质量指标""" + quality_metrics = { + 'completeness_score': 0, + 'consistency_score': 0, + 'diversity_score': 0, + 'issues_found': [] + } + + # 检查完整性 + required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata"] + missing_dirs = [] + + for dir_path in required_dirs: + if not os.path.exists(os.path.join(data_dir, dir_path)): + missing_dirs.append(dir_path) + + if missing_dirs: + quality_metrics['issues_found'].append(f"缺失目录: {missing_dirs}") + quality_metrics['completeness_score'] = 50 + else: + quality_metrics['completeness_score'] = 100 + + # 检查一致性(图像数量) + raw_vehicle = os.path.join(data_dir, "raw", "vehicle") + if os.path.exists(raw_vehicle): + camera_counts = [] + for camera_dir in os.listdir(raw_vehicle): + camera_path = os.path.join(raw_vehicle, camera_dir) + if os.path.isdir(camera_path): + images = [f for f in os.listdir(camera_path) + if f.endswith('.png')] + camera_counts.append(len(images)) + + if camera_counts: + max_diff = max(camera_counts) - min(camera_counts) + if max_diff > 5: + quality_metrics['issues_found'].append(f"摄像头图像数量不一致: 差异{max_diff}") + quality_metrics['consistency_score'] = 70 + else: + quality_metrics['consistency_score'] = 95 + + # 多样性评分(基于物体类别) + object_stats = DataAnalyzer._analyze_objects(data_dir) + num_classes = len(object_stats.get('by_class', {})) + + if num_classes >= 5: + quality_metrics['diversity_score'] = 90 + elif num_classes >= 3: + quality_metrics['diversity_score'] = 70 + else: + quality_metrics['diversity_score'] = 50 + quality_metrics['issues_found'].append(f"物体类别较少: {num_classes}类") + + return quality_metrics + + @staticmethod + def _calculate_overall_score(analysis): + """计算总体评分""" + weights = { + 'completeness': 0.3, + 'consistency': 0.25, + 'diversity': 0.25, + 'temporal': 0.2 + } + + quality = analysis['quality_metrics'] + + score = ( + quality['completeness_score'] * weights['completeness'] + + quality['consistency_score'] * weights['consistency'] + + quality['diversity_score'] * weights['diversity'] + ) + + # 时间因素 + temporal = analysis['temporal_analysis'] + if temporal['frame_rate'] >= 2.0: + score += 20 * weights['temporal'] + elif temporal['frame_rate'] >= 1.0: + score += 15 * weights['temporal'] + else: + score += 5 * weights['temporal'] + + return round(score, 1) + + @staticmethod + def _save_analysis_report(data_dir, analysis): + """保存分析报告""" + report_file = os.path.join(data_dir, "metadata", "dataset_analysis.json") + + with open(report_file, 'w', encoding='utf-8') as f: + json.dump(analysis, f, indent=2, ensure_ascii=False) + + print(f"数据集分析报告保存: {report_file}") + + @staticmethod + def _print_analysis_summary(analysis): + """打印分析摘要""" + print("\n" + "=" * 60) + print("数据集分析摘要") + print("=" * 60) + + basic = analysis['basic_stats'] + print(f"\n基本统计:") + print(f" 总大小: {basic['total_size_mb']} MB") + print(f" 文件数: {basic['file_count']}") + print(f" 目录数: {basic['directory_count']}") + + print(f" 数据类型:") + for data_type, count in basic['data_types'].items(): + print(f" {data_type}: {count}") + + distribution = analysis['file_distribution'] + print(f"\n文件分布:") + for key, value in distribution.items(): + if isinstance(value, dict): + print(f" {key}:") + for subkey, subvalue in value.items(): + print(f" {subkey}: {subvalue}") + else: + print(f" {key}: {value}") + + objects = analysis['object_statistics'] + print(f"\n物体统计:") + print(f" 总物体数: {objects['total_objects']}") + if objects['by_class']: + print(f" 类别分布:") + for obj_class, count in objects['by_class'].items(): + percentage = objects['class_distribution'].get(obj_class, 0) + print(f" {obj_class}: {count} ({percentage}%)") + + temporal = analysis['temporal_analysis'] + print(f"\n时间分析:") + print(f" 总时长: {temporal['total_duration']:.1f}秒") + print(f" 平均帧率: {temporal['frame_rate']:.2f} FPS") + + quality = analysis['quality_metrics'] + print(f"\n质量指标:") + print(f" 完整性: {quality['completeness_score']}/100") + print(f" 一致性: {quality['consistency_score']}/100") + print(f" 多样性: {quality['diversity_score']}/100") + + if quality['issues_found']: + print(f" 发现的问题 ({len(quality['issues_found'])}):") + for issue in quality['issues_found'][:3]: + print(f" - {issue}") + if len(quality['issues_found']) > 3: + print(f" ... 还有 {len(quality['issues_found']) - 3} 个问题") + + print(f"\n总体评分: {analysis['overall_score']}/100") + + if analysis['overall_score'] >= 90: + print("✓ 数据集质量优秀") + elif analysis['overall_score'] >= 75: + print("✓ 数据集质量良好") + elif analysis['overall_score'] >= 60: + print("⚠ 数据集质量一般") + else: + print("✗ 数据集质量需要改进") + + print("=" * 60) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/data_validator.py b/src/enhance_pedestrian_safety/data_validator.py new file mode 100644 index 0000000000..f015231a42 --- /dev/null +++ b/src/enhance_pedestrian_safety/data_validator.py @@ -0,0 +1,309 @@ +import os +import json + + +class DataValidator: + + @staticmethod + def validate_dataset(data_dir): + print(f"验证数据集: {data_dir}") + + validation_results = { + 'directory_structure': DataValidator._check_directory_structure(data_dir), + 'raw_images': DataValidator._validate_raw_images(data_dir), + 'stitched_images': DataValidator._validate_stitched_images(data_dir), + 'annotations': DataValidator._validate_annotations(data_dir), + 'metadata': DataValidator._validate_metadata(data_dir), + 'lidar_data': DataValidator._validate_lidar_data(data_dir) + } + + validation_results['overall_score'] = DataValidator._calculate_score(validation_results) + + DataValidator._save_validation_report(data_dir, validation_results) + DataValidator._print_validation_report(validation_results) + + return validation_results + + @staticmethod + def _check_directory_structure(data_dir): + required_dirs = [ + "raw/vehicle", + "raw/infrastructure", + "stitched", + "metadata" + ] + + missing_dirs = [] + for dir_path in required_dirs: + full_path = os.path.join(data_dir, dir_path) + if not os.path.exists(full_path): + missing_dirs.append(dir_path) + + status = 'PASS' if len(missing_dirs) == 0 else 'FAIL' + + result = { + 'status': status, + 'missing_directories': missing_dirs, + 'required_directories': required_dirs + } + + return result + + @staticmethod + def _validate_raw_images(data_dir): + raw_dirs = ["vehicle", "infrastructure"] + results = {} + + for raw_dir in raw_dirs: + path = os.path.join(data_dir, "raw", raw_dir) + if not os.path.exists(path): + results[raw_dir] = {'status': 'MISSING', 'count': 0, 'errors': []} + continue + + camera_dirs = [] + if os.path.exists(path): + camera_dirs = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))] + + total_images = 0 + errors = [] + + for camera_dir in camera_dirs: + camera_path = os.path.join(path, camera_dir) + images = [f for f in os.listdir(camera_path) if f.endswith(('.png', '.jpg', '.jpeg'))] + + for img_file in images: + img_path = os.path.join(camera_path, img_file) + try: + if os.path.getsize(img_path) == 0: + errors.append(f"空文件: {img_file}") + except: + errors.append(f"文件访问失败: {img_file}") + + total_images += len(images) + + if len(errors) == 0 and total_images > 0: + status = 'PASS' + elif len(errors) < 3 and total_images > 0: + status = 'WARNING' + else: + status = 'FAIL' + + results[raw_dir] = { + 'status': status, + 'count': total_images, + 'errors': errors + } + + return results + + @staticmethod + def _validate_stitched_images(data_dir): + stitched_dir = os.path.join(data_dir, "stitched") + + if not os.path.exists(stitched_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + images = [f for f in os.listdir(stitched_dir) if f.endswith(('.jpg', '.jpeg', '.png'))] + errors = [] + + for img_file in images: + img_path = os.path.join(stitched_dir, img_file) + try: + if os.path.getsize(img_path) == 0: + errors.append(f"空文件: {img_file}") + except: + errors.append(f"文件访问失败: {img_file}") + + if len(errors) == 0 and len(images) > 0: + status = 'PASS' + elif len(errors) < 3 and len(images) > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': len(images), + 'errors': errors + } + + @staticmethod + def _validate_annotations(data_dir): + annotations_dir = os.path.join(data_dir, "annotations") + + if not os.path.exists(annotations_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] + errors = [] + valid_files = 0 + + for json_file in json_files: + json_path = os.path.join(annotations_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + valid_files += 1 + except Exception as e: + errors.append(f"无效的JSON文件: {json_file} - {str(e)}") + + if len(errors) == 0 and valid_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': valid_files, + 'errors': errors + } + + @staticmethod + def _validate_metadata(data_dir): + metadata_dir = os.path.join(data_dir, "metadata") + + if not os.path.exists(metadata_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + json_files = [f for f in os.listdir(metadata_dir) if f.endswith('.json')] + errors = [] + valid_files = 0 + + for json_file in json_files: + json_path = os.path.join(metadata_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + valid_files += 1 + except Exception as e: + errors.append(f"无效的JSON文件: {json_file} - {str(e)}") + + if len(errors) == 0 and valid_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': valid_files, + 'errors': errors + } + + @staticmethod + def _validate_lidar_data(data_dir): + lidar_dir = os.path.join(data_dir, "lidar") + + if not os.path.exists(lidar_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] + errors = [] + valid_files = 0 + + for bin_file in bin_files: + bin_path = os.path.join(lidar_dir, bin_file) + try: + if os.path.getsize(bin_path) > 0: + valid_files += 1 + else: + errors.append(f"空文件: {bin_file}") + except: + errors.append(f"文件访问失败: {bin_file}") + + if len(errors) == 0 and valid_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': valid_files, + 'errors': errors + } + + @staticmethod + def _calculate_score(results): + weights = { + 'directory_structure': 0.15, + 'raw_images': 0.25, + 'stitched_images': 0.15, + 'annotations': 0.1, + 'metadata': 0.15, + 'lidar_data': 0.2 + } + + score = 0 + for key, weight in weights.items(): + if key not in results: + score += 30 * weight + continue + + result = results[key] + if 'status' not in result: + score += 30 * weight + continue + + if result['status'] == 'PASS': + score += 100 * weight + elif result['status'] == 'WARNING': + score += 70 * weight + elif result['status'] in ['FAIL', 'MISSING']: + score += 30 * weight + else: + score += 50 * weight + + return round(score, 1) + + @staticmethod + def _save_validation_report(data_dir, results): + report_path = os.path.join(data_dir, "metadata", "validation_report.json") + + with open(report_path, 'w', encoding='utf-8') as f: + json.dump(results, f, indent=2, ensure_ascii=False) + + @staticmethod + def _print_validation_report(results): + print("\n" + "=" * 60) + print("数据集验证报告") + print("=" * 60) + + for key, result in results.items(): + if key == 'overall_score': + continue + + print(f"\n{key.replace('_', ' ').title()}:") + + if 'status' in result: + print(f" 状态: {result['status']}") + else: + print(f" 状态: 未知") + + if 'count' in result: + print(f" 数量: {result['count']}") + + if 'errors' in result and result['errors']: + print(f" 错误 ({len(result['errors'])}):") + for error in result['errors'][:3]: + print(f" - {error}") + if len(result['errors']) > 3: + print(f" ... 还有 {len(result['errors']) - 3} 个错误") + + print(f"\n总体评分: {results.get('overall_score', 0)}/100") + + overall_score = results.get('overall_score', 0) + if overall_score >= 90: + print("✓ 数据集质量优秀") + elif overall_score >= 70: + print("✓ 数据集质量良好") + elif overall_score >= 50: + print("⚠ 数据集质量一般") + else: + print("✗ 数据集质量需要改进") + + print("=" * 60) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py new file mode 100644 index 0000000000..fdcc61637b --- /dev/null +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -0,0 +1,274 @@ +import numpy as np +import struct +import os +import json +import threading +from datetime import datetime + + +class LidarProcessor: + + def __init__(self, output_dir): + self.output_dir = output_dir + self.lidar_dir = os.path.join(output_dir, "lidar") + os.makedirs(self.lidar_dir, exist_ok=True) + + self.calibration_dir = os.path.join(output_dir, "calibration") + os.makedirs(self.calibration_dir, exist_ok=True) + + self.frame_counter = 0 + self.data_lock = threading.Lock() + + self._init_calibration_files() + + def _init_calibration_files(self): + lidar_intrinsic = { + "channels": 32, + "range": 100.0, + "points_per_second": 56000, + "rotation_frequency": 10.0, + "horizontal_fov": 360.0, + "vertical_fov": 30.0, + "upper_fov": 10.0, + "lower_fov": -20.0 + } + + lidar_extrinsic = { + "translation": [0.0, 0.0, 2.5], + "rotation": [0.0, 0.0, 0.0], + "matrix": [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0] + ] + } + + intrinsic_file = os.path.join(self.calibration_dir, "lidar_intrinsic.json") + extrinsic_file = os.path.join(self.calibration_dir, "lidar_extrinsic.json") + + with open(intrinsic_file, 'w') as f: + json.dump(lidar_intrinsic, f, indent=2) + + with open(extrinsic_file, 'w') as f: + json.dump(lidar_extrinsic, f, indent=2) + + def process_lidar_data(self, lidar_data, frame_num): + with self.data_lock: + self.frame_counter = frame_num + + points = self._carla_lidar_to_numpy(lidar_data) + + if points is None or points.shape[0] == 0: + return None + + bin_path = self._save_as_bin(points, frame_num) + npy_path = self._save_as_npy(points, frame_num) + csv_path = self._save_as_csv(points, frame_num) + + metadata = self._generate_metadata(points, bin_path, npy_path, csv_path) + + return metadata + + def _carla_lidar_to_numpy(self, lidar_data): + try: + points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) + points = np.reshape(points, (int(points.shape[0] / 4), 4)) + + points = points[:, :3] + + return points + + except Exception as e: + print(f"LiDAR数据转换失败: {e}") + + try: + points = [] + for point in lidar_data: + points.append([point.x, point.y, point.z]) + + return np.array(points, dtype=np.float32) + except: + return None + + def _save_as_bin(self, points, frame_num): + bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") + + points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) + points_with_intensity[:, :3] = points + points_with_intensity[:, 3] = 0.0 + + points_with_intensity.tofile(bin_path) + + return bin_path + + def _save_as_npy(self, points, frame_num): + npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") + np.save(npy_path, points) + return npy_path + + def _save_as_csv(self, points, frame_num): + csv_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.csv") + + sample_points = points[:min(1000, points.shape[0])] + + header = "x,y,z\n" + + with open(csv_path, 'w') as f: + f.write(header) + np.savetxt(f, sample_points, delimiter=',', fmt='%.6f') + + return csv_path + + def _generate_metadata(self, points, bin_path, npy_path, csv_path): + metadata = { + 'frame_id': self.frame_counter, + 'timestamp': datetime.now().isoformat(), + 'point_count': int(points.shape[0]), + 'file_paths': { + 'bin': os.path.basename(bin_path), + 'npy': os.path.basename(npy_path), + 'csv': os.path.basename(csv_path) + }, + 'statistics': { + 'x_range': [float(points[:, 0].min()), float(points[:, 0].max())], + 'y_range': [float(points[:, 1].min()), float(points[:, 1].max())], + 'z_range': [float(points[:, 2].min()), float(points[:, 2].max())], + 'mean': [float(points[:, 0].mean()), float(points[:, 1].mean()), float(points[:, 2].mean())], + 'std': [float(points[:, 0].std()), float(points[:, 1].std()), float(points[:, 2].std())] + }, + 'file_sizes': { + 'bin': os.path.getsize(bin_path) if os.path.exists(bin_path) else 0, + 'npy': os.path.getsize(npy_path) if os.path.exists(npy_path) else 0, + 'csv': os.path.getsize(csv_path) if os.path.exists(csv_path) else 0 + } + } + + meta_path = os.path.join(self.lidar_dir, f"lidar_meta_{self.frame_counter:06d}.json") + with open(meta_path, 'w') as f: + json.dump(metadata, f, indent=2) + + return metadata + + def generate_lidar_summary(self): + if not os.path.exists(self.lidar_dir): + return None + + bin_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.bin')] + npy_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.npy')] + meta_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.json')] + + total_points = 0 + for bin_file in bin_files: + bin_path = os.path.join(self.lidar_dir, bin_file) + if os.path.exists(bin_path): + file_size = os.path.getsize(bin_path) + points_in_file = file_size // (4 * 4) + total_points += points_in_file + + summary = { + 'total_frames': len(bin_files), + 'total_points': total_points, + 'average_points_per_frame': total_points // max(len(bin_files), 1), + 'file_types': { + 'bin': len(bin_files), + 'npy': len(npy_files), + 'meta': len(meta_files) + }, + 'total_size_mb': round(sum(os.path.getsize(os.path.join(self.lidar_dir, f)) + for f in bin_files + npy_files + meta_files) / (1024 * 1024), 2) + } + + summary_path = os.path.join(self.output_dir, "metadata", "lidar_summary.json") + with open(summary_path, 'w') as f: + json.dump(summary, f, indent=2) + + return summary + + +class MultiSensorFusion: + + def __init__(self, output_dir): + self.output_dir = output_dir + self.fusion_dir = os.path.join(output_dir, "fusion") + os.makedirs(self.fusion_dir, exist_ok=True) + + self.calibration_data = {} + self._load_calibration() + + def _load_calibration(self): + calibration_dir = os.path.join(self.output_dir, "calibration") + + if os.path.exists(calibration_dir): + for file in os.listdir(calibration_dir): + if file.endswith('.json'): + filepath = os.path.join(calibration_dir, file) + try: + with open(filepath, 'r') as f: + data = json.load(f) + sensor_name = file.replace('.json', '') + self.calibration_data[sensor_name] = data + except: + pass + + def create_synchronization_file(self, frame_num, sensor_data): + sync_data = { + 'frame_id': frame_num, + 'timestamp': datetime.now().isoformat(), + 'sensors': {} + } + + for sensor_type, data_path in sensor_data.items(): + if data_path and os.path.exists(data_path): + sync_data['sensors'][sensor_type] = { + 'file_path': os.path.basename(data_path), + 'file_size': os.path.getsize(data_path), + 'timestamp': datetime.fromtimestamp(os.path.getctime(data_path)).isoformat() + } + + sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") + with open(sync_file, 'w') as f: + json.dump(sync_data, f, indent=2) + + return sync_file + + def generate_fusion_report(self): + if not os.path.exists(self.fusion_dir): + return None + + sync_files = [f for f in os.listdir(self.fusion_dir) if f.endswith('.json')] + + report = { + 'total_sync_frames': len(sync_files), + 'calibration_data': list(self.calibration_data.keys()), + 'sensor_types': set(), + 'frame_range': [] + } + + if sync_files: + frame_ids = [] + for sync_file in sync_files: + try: + frame_id = int(sync_file.split('_')[1].split('.')[0]) + frame_ids.append(frame_id) + + filepath = os.path.join(self.fusion_dir, sync_file) + with open(filepath, 'r') as f: + data = json.load(f) + + for sensor_type in data.get('sensors', {}).keys(): + report['sensor_types'].add(sensor_type) + + except: + continue + + if frame_ids: + report['frame_range'] = [min(frame_ids), max(frame_ids)] + + report['sensor_types'] = list(report['sensor_types']) + + report_path = os.path.join(self.output_dir, "metadata", "fusion_report.json") + with open(report_path, 'w') as f: + json.dump(report, f, indent=2) + + return report \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 41616f043f..64f7caf9ea 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -6,561 +6,762 @@ import traceback import math import threading +import json from datetime import datetime -from PIL import Image, ImageDraw, ImageFont from carla_utils import setup_carla_path, import_carla_module +from config_manager import ConfigManager +from annotation_generator import AnnotationGenerator +from data_validator import DataValidator +from scene_manager import SceneManager +from data_analyzer import DataAnalyzer +from lidar_processor import LidarProcessor, MultiSensorFusion carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() -class ImageStitcher: +class Log: + @staticmethod + def info(msg): + print(f"[INFO] {msg}") + + @staticmethod + def warning(msg): + print(f"[WARNING] {msg}") + + @staticmethod + def error(msg): + print(f"[ERROR] {msg}") + + @staticmethod + def debug(msg): + print(f"[DEBUG] {msg}") + + +class WeatherSystem: + WEATHER_PRESETS = { + 'clear': {'cloudiness': 10, 'precipitation': 0, 'wind': 5}, + 'rainy': {'cloudiness': 90, 'precipitation': 80, 'wind': 15}, + 'cloudy': {'cloudiness': 70, 'precipitation': 10, 'wind': 10}, + 'foggy': {'cloudiness': 50, 'precipitation': 0, 'fog_density': 40} + } + + @staticmethod + def create_weather(weather_type, time_of_day): + weather = carla.WeatherParameters() + + if weather_type in WeatherSystem.WEATHER_PRESETS: + preset = WeatherSystem.WEATHER_PRESETS[weather_type] + weather.cloudiness = preset.get('cloudiness', 30) + weather.precipitation = preset.get('precipitation', 0) + weather.wind_intensity = preset.get('wind', 5) + if 'fog_density' in preset: + weather.fog_density = preset['fog_density'] + + if time_of_day == 'noon': + weather.sun_altitude_angle = 75 + elif time_of_day == 'sunset': + weather.sun_altitude_angle = 15 + elif time_of_day == 'night': + weather.sun_altitude_angle = -20 + + return weather + + +class ImageProcessor: def __init__(self, output_dir): self.output_dir = output_dir - self.stitched_dir = os.path.join(output_dir, "stitched_images") + self.stitched_dir = os.path.join(output_dir, "stitched") os.makedirs(self.stitched_dir, exist_ok=True) - self.font = self._load_font() + def stitch(self, image_paths, frame_num, view_type="vehicle"): + try: + from PIL import Image, ImageDraw + except ImportError: + Log.warning("PIL未安装,跳过图像拼接") + return False - def _load_font(self): - font_paths = [ - "arial.ttf", - "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", - "/System/Library/Fonts/Helvetica.ttc" - ] + positions = [(10, 10), (660, 10), (10, 390), (660, 390)] - for font_path in font_paths: - try: - return ImageFont.truetype(font_path, 20) - except: - continue - return ImageFont.load_default() - - def stitch_ego_vehicle_images(self, image_paths, frame_num): - positions = { - 'front_wide': (10, 10), - 'front_narrow': (660, 10), - 'right_side': (10, 390), - 'left_side': (660, 390) - } + canvas = Image.new('RGB', (640 * 2 + 20, 360 * 2 + 20), (40, 40, 40)) + draw = ImageDraw.Draw(canvas) - images = [] - for cam_name in positions.keys(): - img_path = image_paths.get(cam_name) + for idx, (cam_name, img_path) in enumerate(list(image_paths.items())[:4]): if img_path and os.path.exists(img_path): try: img = Image.open(img_path).resize((640, 360)) - images.append((cam_name, img)) except: - images.append((cam_name, Image.new('RGB', (640, 360), (100, 100, 100)))) + img = Image.new('RGB', (640, 360), (80, 80, 80)) else: - images.append((cam_name, Image.new('RGB', (640, 360), (100, 100, 100)))) + img = Image.new('RGB', (640, 360), (80, 80, 80)) - if len(images) < 4: - return False + canvas.paste(img, positions[idx]) + draw.text((positions[idx][0] + 5, positions[idx][1] + 5), + cam_name, fill=(255, 255, 200)) - canvas = Image.new('RGB', (640 * 2 + 20, 360 * 2 + 20), (50, 50, 50)) + output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") + canvas.save(output_path, "JPEG", quality=90) + return True - for cam_name, img in images: - x, y = positions[cam_name] - canvas.paste(img, (x, y)) - draw = ImageDraw.Draw(canvas) - label = cam_name.replace('_', ' ').title() - draw.text((x + 10, y + 10), label, fill=(255, 255, 255), font=self.font) - draw = ImageDraw.Draw(canvas) - title = f"CVIPS - Frame {frame_num:04d}" - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - draw.text((canvas.width // 2 - 150, 5), title, fill=(255, 255, 255), font=self.font) - draw.text((10, canvas.height - 30), timestamp, fill=(200, 200, 200), font=self.font) +class TrafficManager: + def __init__(self, world, config): + self.world = world + self.config = config + self.vehicles = [] + self.pedestrians = [] - output_path = os.path.join(self.stitched_dir, f"ego_stitched_{frame_num:04d}.jpg") - canvas.save(output_path, "JPEG", quality=95) + seed = config['scenario'].get('seed', random.randint(1, 1000)) + random.seed(seed) + Log.info(f"随机种子: {seed}") - return True + def spawn_ego_vehicle(self): + blueprint_lib = self.world.get_blueprint_library() + common_vehicles = [ + 'vehicle.tesla.model3', + 'vehicle.audi.tt', + 'vehicle.mini.cooperst', + 'vehicle.nissan.micra' + ] -class PedestrianController: - STATE_WAITING = "waiting" - STATE_CROSSING = "crossing" - STATE_WALKING = "walking" - STATE_STOPPED = "stopped" + for vtype in common_vehicles: + if blueprint_lib.filter(vtype): + vehicle_bp = random.choice(blueprint_lib.filter(vtype)) + break + else: + vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) - def __init__(self, world): - self.world = world - self.pedestrians = [] - self.running = True + spawn_points = self.world.get_map().get_spawn_points() + if not spawn_points: + return None - def spawn_pedestrian(self, location, behavior_type="crossing"): + spawn_point = random.choice(spawn_points) + try: + vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + vehicle.set_autopilot(True) + vehicle.apply_control(carla.VehicleControl(throttle=0.2)) + Log.info(f"主车: {vehicle.type_id}") + return vehicle + except Exception as e: + Log.warning(f"主车生成失败: {e}") + return None + + def spawn_traffic(self, center_location): + vehicles = self._spawn_vehicles() + pedestrians = self._spawn_pedestrians(center_location) + + Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人") + return vehicles + pedestrians + + def _spawn_vehicles(self): blueprint_lib = self.world.get_blueprint_library() - ped_bps = list(blueprint_lib.filter('walker.pedestrian.*')) + spawn_points = self.world.get_map().get_spawn_points() - if not ped_bps: - return None + if not spawn_points: + return 0 - ped_bp = random.choice(ped_bps) - location.z += 1.0 + num_vehicles = min(self.config['traffic']['background_vehicles'], 10) + spawned = 0 - try: - pedestrian = self.world.spawn_actor(ped_bp, carla.Transform(location)) - controller_bp = blueprint_lib.find('controller.ai.walker') - controller = self.world.spawn_actor(controller_bp, carla.Transform(), attach_to=pedestrian) - controller.start() - - behavior_state = { - 'state': self.STATE_WAITING if behavior_type in ["crossing", "hesitant"] else self.STATE_WALKING, - 'wait_start': time.time(), - 'wait_duration': random.uniform(2.0, 5.0), - 'target': None, - 'original': location, - 'behavior': behavior_type - } + for _ in range(num_vehicles): + try: + vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + spawn_point = random.choice(spawn_points) + vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + vehicle.set_autopilot(True) + self.vehicles.append(vehicle) + spawned += 1 + except: + pass - if behavior_type == "walking": - behavior_state['target'] = self._get_random_location() + return spawned - self.pedestrians.append((pedestrian, controller, behavior_state)) - return pedestrian + def _spawn_pedestrians(self, center_location): + blueprint_lib = self.world.get_blueprint_library() - except Exception as e: - print(f"生成行人失败: {e}") - return None + num_peds = min(self.config['traffic']['pedestrians'], 8) + spawned = 0 - def _get_random_location(self): - try: - return self.world.get_random_location_from_navigation() - except: - return None + for _ in range(num_peds): + try: + ped_bps = list(blueprint_lib.filter('walker.pedestrian.*')) + if not ped_bps: + continue - def update_behaviors(self): - current_time = time.time() + ped_bp = random.choice(ped_bps) - for pedestrian, controller, state in self.pedestrians: - if not pedestrian.is_alive or not controller.is_alive: - continue + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(5.0, 12.0) - if state['behavior'] == "crossing": - self._update_crossing(pedestrian, controller, state, current_time) - elif state['behavior'] == "hesitant": - self._update_hesitant(pedestrian, controller, state, current_time) - else: - self._update_walking(pedestrian, controller, state, current_time) - - def _update_crossing(self, pedestrian, controller, state, current_time): - if state['state'] == self.STATE_WAITING: - if current_time - state['wait_start'] >= state['wait_duration']: - target = carla.Location( - x=state['original'].x + random.uniform(15.0, 25.0), - y=state['original'].y + random.uniform(-5.0, 5.0), - z=state['original'].z + location = carla.Location( + x=center_location.x + distance * math.cos(angle), + y=center_location.y + distance * math.sin(angle), + z=center_location.z + 0.5 ) - state['target'] = target - state['state'] = self.STATE_CROSSING - state['cross_start'] = current_time - controller.go_to_location(target) - - elif state['state'] == self.STATE_CROSSING: - distance = pedestrian.get_location().distance(state['target']) - if distance < 2.0 or current_time - state['cross_start'] > 15.0: - state['state'] = self.STATE_STOPPED - - def _update_hesitant(self, pedestrian, controller, state, current_time): - if state['state'] == self.STATE_WAITING: - if current_time - state['wait_start'] >= state['wait_duration']: - target = self._get_random_location() - if target: - state['target'] = target - state['state'] = self.STATE_WALKING - state['walk_start'] = current_time - state['walk_duration'] = random.uniform(3.0, 8.0) - controller.go_to_location(target) - - elif state['state'] == self.STATE_WALKING: - if current_time - state['walk_start'] >= state['walk_duration']: - state['state'] = self.STATE_WAITING - state['wait_start'] = current_time - state['wait_duration'] = random.uniform(1.0, 4.0) - - def _update_walking(self, pedestrian, controller, state, current_time): - if state['state'] == self.STATE_WALKING and state['target']: - distance = pedestrian.get_location().distance(state['target']) - if distance < 2.0: - new_target = self._get_random_location() - if new_target: - state['target'] = new_target - controller.go_to_location(new_target) - - def start_updates(self): - def update_loop(): - while self.running: - try: - self.update_behaviors() - time.sleep(0.5) - except Exception as e: - print(f"行为更新错误: {e}") - time.sleep(1.0) - threading.Thread(target=update_loop, daemon=True).start() + pedestrian = self.world.spawn_actor(ped_bp, carla.Transform(location)) + self.pedestrians.append(pedestrian) + spawned += 1 + except Exception as e: + Log.debug(f"行人生成失败: {e}") + + return spawned def cleanup(self): - self.running = False - for pedestrian, controller, _ in self.pedestrians: + Log.info("清理交通...") + + for vehicle in self.vehicles: + try: + if vehicle.is_alive: + vehicle.destroy() + except: + pass + + for pedestrian in self.pedestrians: try: - if controller.is_alive: - controller.stop() - controller.destroy() if pedestrian.is_alive: pedestrian.destroy() except: pass + + self.vehicles.clear() self.pedestrians.clear() -class DataGenerator: - def __init__(self, args): - self.args = args - self.client = None - self.world = None - self.actors = [] +class SensorManager: + def __init__(self, world, config, data_dir): + self.world = world + self.config = config + self.data_dir = data_dir self.sensors = [] - self.frame_count = 0 - self.last_capture_time = 0 - self.setup_output_directory() - self.stitcher = ImageStitcher(self.output_dir) - self.ped_controller = None + self.frame_counter = 0 + self.last_capture_time = 0 - self.image_buffer = {} + self.vehicle_buffer = {} + self.infra_buffer = {} self.buffer_lock = threading.Lock() - def setup_output_directory(self): - timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") - self.output_dir = os.path.join("cvips_data", f"{self.args.scenario}_{timestamp}") + self.image_processor = ImageProcessor(data_dir) + self.lidar_processor = None + self.fusion_manager = None - self.raw_dirs = {} - for view in ['front_wide', 'front_narrow', 'right_side', 'left_side']: - dir_path = os.path.join(self.output_dir, "raw", "ego_vehicle", view) - os.makedirs(dir_path, exist_ok=True) - self.raw_dirs[view] = dir_path + if config['sensors'].get('lidar_sensors', 0) > 0: + self.lidar_processor = LidarProcessor(data_dir) - print(f"数据输出目录: {self.output_dir}") + if config['output'].get('save_fusion', False): + self.fusion_manager = MultiSensorFusion(data_dir) - def connect_to_server(self): - for attempt in range(1, 6): - try: - self.client = carla.Client('localhost', 2000) - self.client.set_timeout(15.0) - - if self.args.town: - self.world = self.client.load_world(self.args.town) - else: - self.world = self.client.get_world() - - settings = self.world.get_settings() - settings.synchronous_mode = False - self.world.apply_settings(settings) + def setup_cameras(self, vehicle, center_location): + vehicle_cams = self._setup_vehicle_cameras(vehicle) + infra_cams = self._setup_infrastructure_cameras(center_location) - print(f"连接成功! 地图: {self.world.get_map().name}") - return True + Log.info(f"摄像头: {vehicle_cams}车辆 + {infra_cams}基础设施") + return vehicle_cams + infra_cams - except Exception as e: - print(f"尝试 {attempt}/5 失败: {str(e)[:80]}") - if attempt < 5: - time.sleep(3) + def _setup_vehicle_cameras(self, vehicle): + if not vehicle: + return 0 - return False + camera_configs = { + 'front_wide': {'loc': (2.0, 0, 1.8), 'rot': (0, -3, 0), 'fov': 100}, + 'front_narrow': {'loc': (2.0, 0, 1.6), 'rot': (0, 0, 0), 'fov': 60}, + 'right_side': {'loc': (0.5, 1.0, 1.5), 'rot': (0, -2, 45), 'fov': 90}, + 'left_side': {'loc': (0.5, -1.0, 1.5), 'rot': (0, -2, -45), 'fov': 90} + } - def setup_scene(self): - self.ped_controller = PedestrianController(self.world) + installed = 0 + for cam_name, config_data in camera_configs.items(): + if self._create_camera(cam_name, config_data, vehicle, 'vehicle'): + installed += 1 - self.set_weather() - time.sleep(2.0) + return installed - ego_vehicle = self.spawn_ego_vehicle() - if not ego_vehicle: - return None + def _setup_infrastructure_cameras(self, center_location): + camera_configs = [ + {'name': 'north', 'offset': (0, -20, 12), 'rotation': (0, -25, 180)}, + {'name': 'south', 'offset': (0, 20, 12), 'rotation': (0, -25, 0)}, + {'name': 'east', 'offset': (20, 0, 12), 'rotation': (0, -25, -90)}, + {'name': 'west', 'offset': (-20, 0, 12), 'rotation': (0, -25, 90)} + ] - self.spawn_pedestrians() - self.spawn_background_vehicles() - time.sleep(5.0) + installed = 0 + for cam_config in camera_configs: + sensor_config = { + 'loc': ( + center_location.x + cam_config['offset'][0], + center_location.y + cam_config['offset'][1], + center_location.z + cam_config['offset'][2] + ), + 'rot': cam_config['rotation'], + 'fov': 90 + } - self.ped_controller.start_updates() - return ego_vehicle + if self._create_camera(cam_config['name'], sensor_config, None, 'infrastructure'): + installed += 1 - def set_weather(self): - weather = carla.WeatherParameters() + return installed - if self.args.weather == 'clear': - weather.sun_altitude_angle = 75 - weather.cloudiness = 5.0 - elif self.args.weather == 'rainy': - weather.sun_altitude_angle = 40 - weather.cloudiness = 90.0 - weather.precipitation = 60.0 - else: - weather.sun_altitude_angle = 60 - weather.cloudiness = 70.0 + def setup_lidar(self, vehicle): + if not vehicle or not self.config['sensors'].get('lidar_sensors', 0) > 0: + return 0 - if self.args.time_of_day == 'night': - weather.sun_altitude_angle = -10 - elif self.args.time_of_day == 'sunset': - weather.sun_altitude_angle = 5 + try: + blueprint_lib = self.world.get_blueprint_library() + lidar_bp = blueprint_lib.find('sensor.lidar.ray_cast') + + lidar_config = self.config['sensors'].get('lidar_config', {}) + + lidar_bp.set_attribute('channels', str(lidar_config.get('channels', 32))) + lidar_bp.set_attribute('range', str(lidar_config.get('range', 100))) + lidar_bp.set_attribute('points_per_second', str(lidar_config.get('points_per_second', 56000))) + lidar_bp.set_attribute('rotation_frequency', str(lidar_config.get('rotation_frequency', 10))) + + # 添加更多LiDAR参数 + lidar_bp.set_attribute('upper_fov', '10') + lidar_bp.set_attribute('lower_fov', '-20') + lidar_bp.set_attribute('horizontal_fov', '360') + + lidar_location = carla.Location(x=0, y=0, z=2.5) + lidar_rotation = carla.Rotation(0, 0, 0) + lidar_transform = carla.Transform(lidar_location, lidar_rotation) + + lidar_sensor = self.world.spawn_actor(lidar_bp, lidar_transform, attach_to=vehicle) + + def lidar_callback(lidar_data): + current_time = time.time() + if current_time - self.last_capture_time >= self.config['sensors']['capture_interval']: + if self.lidar_processor: + try: + metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) + if metadata and self.fusion_manager: + # 尝试获取最新的车辆图像 + vehicle_image_path = None + with self.buffer_lock: + if self.vehicle_buffer: + # 取第一个摄像头的图像 + for cam_name, img_path in self.vehicle_buffer.items(): + if os.path.exists(img_path): + vehicle_image_path = img_path + break + + sensor_data = { + 'lidar': os.path.join(self.data_dir, "lidar", f"lidar_{self.frame_counter:06d}.bin") + } + if vehicle_image_path: + sensor_data['camera'] = vehicle_image_path + + self.fusion_manager.create_synchronization_file(self.frame_counter, sensor_data) + except Exception as e: + print(f"LiDAR处理失败: {e}") + + lidar_sensor.listen(lidar_callback) + self.sensors.append(lidar_sensor) + + print("LiDAR传感器已安装") + return 1 - self.world.set_weather(weather) + except Exception as e: + print(f"LiDAR安装失败: {e}") + return 0 + def _create_camera(self, name, config, parent, sensor_type): + try: + blueprint = self.world.get_blueprint_library().find('sensor.camera.rgb') - def spawn_ego_vehicle(self): - blueprint_lib = self.world.get_blueprint_library() - vehicle_types = ['vehicle.tesla.model3', 'vehicle.audi.tt', 'vehicle.mini.cooperst'] + img_size = self.config['sensors'].get('image_size', [1280, 720]) + blueprint.set_attribute('image_size_x', str(img_size[0])) + blueprint.set_attribute('image_size_y', str(img_size[1])) + blueprint.set_attribute('fov', str(config.get('fov', 90))) - vehicle_bp = None - for vtype in vehicle_types: - if blueprint_lib.filter(vtype): - vehicle_bp = random.choice(blueprint_lib.filter(vtype)) - break + location = carla.Location(config['loc'][0], config['loc'][1], config['loc'][2]) + rotation = carla.Rotation(config['rot'][0], config['rot'][1], config['rot'][2]) + transform = carla.Transform(location, rotation) - if not vehicle_bp: - vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + if parent: + camera = self.world.spawn_actor(blueprint, transform, attach_to=parent) + else: + camera = self.world.spawn_actor(blueprint, transform) - spawn_points = self.world.get_map().get_spawn_points() - if not spawn_points: - return None + save_dir = os.path.join(self.data_dir, "raw", sensor_type, name) + os.makedirs(save_dir, exist_ok=True) - spawn_point = random.choice(spawn_points) + callback = self._create_callback(save_dir, name, sensor_type) + camera.listen(callback) - try: - vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) - self.actors.append(vehicle) - vehicle.set_autopilot(True) - vehicle.apply_control(carla.VehicleControl(throttle=0.2, steer=0.0)) + self.sensors.append(camera) + return True - print(f"主车辆: {vehicle.type_id}") - return vehicle except Exception as e: - print(f"生成主车辆失败: {e}") - return None - - def spawn_pedestrians(self): - spawn_points = self.world.get_map().get_spawn_points() - if not spawn_points: - return - - print(f"生成 {self.args.num_smart_pedestrians} 个行人...") + Log.warning(f"创建摄像头 {name} 失败: {e}") + return False - behaviors = ['crossing', 'hesitant', 'walking'] + def _create_callback(self, save_dir, name, sensor_type): + capture_interval = self.config['sensors']['capture_interval'] + + def callback(image): + current_time = time.time() + + if current_time - self.last_capture_time >= capture_interval: + self.frame_counter += 1 + self.last_capture_time = current_time + + filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") + image.save_to_disk(filename, carla.ColorConverter.Raw) + + with self.buffer_lock: + if sensor_type == 'vehicle': + self.vehicle_buffer[name] = filename + if len(self.vehicle_buffer) >= 4: + self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, 'vehicle') + self.vehicle_buffer.clear() + else: + self.infra_buffer[name] = filename + if len(self.infra_buffer) >= 4: + self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') + self.infra_buffer.clear() + + return callback + + def get_frame_count(self): + return self.frame_counter + + def generate_sensor_summary(self): + summary = { + 'total_sensors': len(self.sensors), + 'frame_count': self.frame_counter, + 'lidar_data': None, + 'fusion_data': None + } - for _ in range(self.args.num_smart_pedestrians): - behavior = random.choice(behaviors) - spawn_point = random.choice(spawn_points) + if self.lidar_processor: + summary['lidar_data'] = self.lidar_processor.generate_lidar_summary() - if self.ped_controller.spawn_pedestrian(spawn_point.location, behavior): - self.actors.append(self.ped_controller.pedestrians[-1][0]) + if self.fusion_manager: + summary['fusion_data'] = self.fusion_manager.generate_fusion_report() - def spawn_background_vehicles(self): - blueprint_lib = self.world.get_blueprint_library() - spawn_points = self.world.get_map().get_spawn_points() + return summary - if not spawn_points: - return - - spawned = 0 - for _ in range(min(5, self.args.num_background_vehicles)): + def cleanup(self): + Log.info(f"清理 {len(self.sensors)} 个传感器...") + for sensor in self.sensors: try: - vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) - spawn_point = random.choice(spawn_points) - - vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) - self.actors.append(vehicle) - vehicle.set_autopilot(True) - spawned += 1 + sensor.stop() + sensor.destroy() except: pass + self.sensors.clear() - print(f"背景车辆: {spawned} 辆") - def setup_cameras(self, vehicle): - if not vehicle: - return False +class DataCollector: + def __init__(self, config): + self.config = config + self.client = None + self.world = None + self.ego_vehicle = None + self.scene_center = None - blueprint_lib = self.world.get_blueprint_library() + self.setup_directories() - camera_configs = [ - ('front_wide', carla.Location(x=2.0, z=1.8), carla.Rotation(pitch=-3.0), 100), - ('front_narrow', carla.Location(x=2.0, z=1.6), carla.Rotation(pitch=0), 60), - ('right_side', carla.Location(x=0.5, y=1.0, z=1.5), carla.Rotation(pitch=-2.0, yaw=45), 90), - ('left_side', carla.Location(x=0.5, y=-1.0, z=1.5), carla.Rotation(pitch=-2.0, yaw=-45), 90), + self.traffic_manager = None + self.sensor_manager = None + + self.start_time = None + self.is_running = False + self.collected_frames = 0 + + def setup_directories(self): + scenario = self.config['scenario'] + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + + self.output_dir = os.path.join( + self.config['output']['data_dir'], + f"{scenario['name']}_{scenario['town']}_{timestamp}" + ) + + directories = [ + "raw/vehicle", + "raw/infrastructure", + "stitched", + "lidar", + "fusion", + "calibration", + "metadata" ] - installed = 0 + for subdir in directories: + os.makedirs(os.path.join(self.output_dir, subdir), exist_ok=True) + + Log.info(f"数据目录: {self.output_dir}") - for name, location, rotation, fov in camera_configs: + def connect(self): + for attempt in range(1, 6): try: - camera_bp = blueprint_lib.find('sensor.camera.rgb') - camera_bp.set_attribute('image_size_x', '1280') - camera_bp.set_attribute('image_size_y', '720') - camera_bp.set_attribute('fov', str(fov)) - - camera = self.world.spawn_actor( - camera_bp, - carla.Transform(location, rotation), - attach_to=vehicle - ) + self.client = carla.Client('localhost', 2000) + self.client.set_timeout(10.0) - def make_callback(save_dir, cam_name): - def callback(image): - current_time = time.time() + town = self.config['scenario']['town'] + self.world = self.client.load_world(town) - if current_time - self.last_capture_time >= self.args.capture_interval: - self.frame_count += 1 - self.last_capture_time = current_time + settings = self.world.get_settings() + settings.synchronous_mode = False + self.world.apply_settings(settings) - raw_filename = f"{save_dir}/{cam_name}_{self.frame_count:04d}.png" - image.save_to_disk(raw_filename, carla.ColorConverter.Raw) + Log.info(f"连接成功: {town}") + return True - with self.buffer_lock: - self.image_buffer[cam_name] = raw_filename + except Exception as e: + Log.warning(f"连接尝试 {attempt}/5 失败: {str(e)[:50]}") + time.sleep(2) - if len(self.image_buffer) == 4: - self.stitcher.stitch_ego_vehicle_images(self.image_buffer, self.frame_count) - self.image_buffer.clear() + return False - return callback + def setup_scene(self): + weather_cfg = self.config['scenario'] + weather = WeatherSystem.create_weather(weather_cfg['weather'], weather_cfg['time_of_day']) + self.world.set_weather(weather) + Log.info(f"天气: {weather_cfg['weather']}, 时间: {weather_cfg['time_of_day']}") - camera.listen(make_callback(self.raw_dirs[name], name)) - self.actors.append(camera) - self.sensors.append(camera) - installed += 1 + spawn_points = self.world.get_map().get_spawn_points() + if spawn_points: + self.scene_center = spawn_points[len(spawn_points) // 2].location + else: + self.scene_center = carla.Location(0, 0, 0) - except Exception as e: - print(f"安装 {name} 摄像头失败: {e}") + self.traffic_manager = TrafficManager(self.world, self.config) + + self.ego_vehicle = self.traffic_manager.spawn_ego_vehicle() + if not self.ego_vehicle: + Log.error("主车生成失败") + return False + + self.traffic_manager.spawn_traffic(self.scene_center) + + time.sleep(3.0) + return True - print(f"摄像头安装: {installed}/4") - return installed == 4 + def setup_sensors(self): + self.sensor_manager = SensorManager(self.world, self.config, self.output_dir) + + cameras = self.sensor_manager.setup_cameras(self.ego_vehicle, self.scene_center) + if cameras == 0: + Log.error("没有摄像头安装成功") + return False + + lidars = self.sensor_manager.setup_lidar(self.ego_vehicle) + Log.info(f"传感器: {cameras}摄像头 + {lidars}LiDAR") + + return True def collect_data(self): - print(f"\n开始数据收集...") - print(f"时长: {self.args.total_dura.tion}秒, 间隔: {self.args.capture_interval}秒") + duration = self.config['scenario']['duration'] + Log.info(f"开始数据收集,时长: {duration}秒") + + self.start_time = time.time() + self.is_running = True - start_time = time.time() - self.frame_count = 0 - self.last_capture_time = start_time + last_update = time.time() try: - while time.time() - start_time < self.args.total_duration: - elapsed = time.time() - start_time - remaining = self.args.total_duration - elapsed + while time.time() - self.start_time < duration and self.is_running: + current_time = time.time() + elapsed = current_time - self.start_time - if int(elapsed) % 10 == 0: - progress = (elapsed / self.args.total_duration) * 100 - print(f"进度: {elapsed:.0f}/{self.args.total_duration}秒 ({progress:.1f}%) | " - f"批次: {self.frame_count} | 剩余: {remaining:.0f}秒") + if current_time - last_update >= 5.0: + frames = self.sensor_manager.get_frame_count() + progress = (elapsed / duration) * 100 - time.sleep(0.1) + Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 帧数: {frames}") + last_update = current_time - print(f"\n数据收集完成! 总批次: {self.frame_count}") + time.sleep(0.05) except KeyboardInterrupt: - print(f"\n数据收集中断, 已收集 {self.frame_count} 批次") + Log.info("数据收集被用户中断") + finally: + self.is_running = False + elapsed = time.time() - self.start_time + + self.collected_frames = self.sensor_manager.get_frame_count() + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + + self._save_metadata() + self._print_summary() + + def _save_metadata(self): + metadata = { + 'scenario': self.config['scenario'], + 'traffic': self.config['traffic'], + 'sensors': self.config['sensors'], + 'output': self.config['output'], + 'collection': { + 'duration': round(time.time() - self.start_time, 2), + 'total_frames': self.collected_frames, + 'frame_rate': round(self.collected_frames / max(time.time() - self.start_time, 0.1), 2) + } + } + + if self.sensor_manager: + sensor_summary = self.sensor_manager.generate_sensor_summary() + metadata['sensor_summary'] = sensor_summary + + meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") + with open(meta_path, 'w', encoding='utf-8') as f: + json.dump(metadata, f, indent=2, ensure_ascii=False) - self.display_summary() + Log.info(f"元数据保存: {meta_path}") - def display_summary(self): + def _print_summary(self): print("\n" + "=" * 60) - print("数据收集摘要:") + print("数据收集摘要") print("=" * 60) - stitched_dir = os.path.join(self.output_dir, "stitched_images") + # 统计图像 + stitched_dir = os.path.join(self.output_dir, "stitched") if os.path.exists(stitched_dir): stitched_files = [f for f in os.listdir(stitched_dir) if f.endswith('.jpg')] print(f"拼接图像: {len(stitched_files)} 张") - raw_dir = os.path.join(self.output_dir, "raw") - if os.path.exists(raw_dir): - total_raw = 0 - for root, dirs, files in os.walk(raw_dir): - total_raw += len([f for f in files if f.endswith('.png')]) - print(f"原始图像: {total_raw} 张") + # 统计LiDAR + lidar_dir = os.path.join(self.output_dir, "lidar") + if os.path.exists(lidar_dir): + bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] + npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] + print(f"LiDAR数据: {len(bin_files)} .bin文件, {len(npy_files)} .npy文件") + + if bin_files: + total_points = 0 + for bin_file in bin_files[:3]: + bin_path = os.path.join(lidar_dir, bin_file) + if os.path.exists(bin_path): + file_size = os.path.getsize(bin_path) + points_in_file = file_size // (4 * 4) + total_points += points_in_file + print(f" 估计总点数: {total_points:,}") + + # 统计融合数据 + fusion_dir = os.path.join(self.output_dir, "fusion") + if os.path.exists(fusion_dir): + sync_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] + print(f"融合数据: {len(sync_files)} 个同步文件") + + print(f"\n输出目录: {self.output_dir}") + print("=" * 60) + + def run_validation(self): + if self.config['output'].get('validate_data', True): + Log.info("运行数据验证...") + DataValidator.validate_dataset(self.output_dir) - print(f"\n数据目录: {self.output_dir}") + def run_analysis(self): + if self.config['output'].get('run_analysis', False): + Log.info("运行数据分析...") + DataAnalyzer.analyze_dataset(self.output_dir) def cleanup(self): - if self.ped_controller: - self.ped_controller.cleanup() + Log.info("清理场景...") - for sensor in self.sensors: - try: - sensor.stop() - except: - pass + if self.sensor_manager: + self.sensor_manager.cleanup() - destroyed = 0 - for actor in self.actors: + if self.traffic_manager: + self.traffic_manager.cleanup() + + if self.ego_vehicle and self.ego_vehicle.is_alive: try: - if actor.is_alive: - actor.destroy() - destroyed += 1 + self.ego_vehicle.destroy() except: pass - print(f"清理 {destroyed} 个actor") - self.actors.clear() - self.sensors.clear() + Log.info("清理完成") def main(): - parser = argparse.ArgumentParser(description='CVIPS 数据生成器') + parser = argparse.ArgumentParser(description='CVIPS 多传感器数据收集系统') - parser.add_argument('--scenario', type=str, default='pedestrian_scene', help='场景名称') + # 基础参数 + parser.add_argument('--config', type=str, help='配置文件路径') + parser.add_argument('--scenario', type=str, default='multi_sensor_scene', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', - choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='CARLA地图') + choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='地图') parser.add_argument('--weather', type=str, default='clear', - choices=['clear', 'rainy', 'cloudy'], help='天气条件') + choices=['clear', 'rainy', 'cloudy', 'foggy'], help='天气') parser.add_argument('--time-of-day', type=str, default='noon', choices=['noon', 'sunset', 'night'], help='时间') - parser.add_argument('--num-smart-pedestrians', type=int, default=6, help='行人数') - parser.add_argument('--num-background-vehicles', type=int, default=4, help='背景车辆数') - parser.add_argument('--total-duration', type=int, default=90, help='总时长(秒)') - parser.add_argument('--capture-interval', type=float, default=2.5, help='捕捉间隔(秒)') + + # 交通参数 + parser.add_argument('--num-vehicles', type=int, default=8, help='背景车辆数') + parser.add_argument('--num-pedestrians', type=int, default=6, help='行人数') + + # 收集参数 + parser.add_argument('--duration', type=int, default=60, help='收集时长(秒)') + parser.add_argument('--capture-interval', type=float, default=2.0, help='捕捉间隔(秒)') + parser.add_argument('--seed', type=int, help='随机种子') + + # 传感器参数 + parser.add_argument('--enable-lidar', action='store_true', help='启用LiDAR传感器') + parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') + parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') + + # 功能参数 + parser.add_argument('--run-analysis', action='store_true', help='运行数据集分析') + parser.add_argument('--skip-validation', action='store_true', help='跳过数据验证') args = parser.parse_args(remaining_argv) - if args.capture_interval < 2.0: - args.capture_interval = 2.0 + # 加载配置 + config = ConfigManager.load_config(args.config) + config = ConfigManager.merge_args(config, args) - print(f"\n场景配置:") - print(f" 场景: {args.scenario}") - print(f" 地图: {args.town}") - print(f" 天气/时间: {args.weather}/{args.time_of_day}") - print(f" 行人: {args.num_smart_pedestrians}个") - print(f" 车辆: {args.num_background_vehicles}辆") - print(f" 时长: {args.total_duration}秒") - print(f" 间隔: {args.capture_interval}秒") + # 显示配置 + print("\n" + "=" * 60) + print("CVIPS 多传感器数据收集系统 v9.0") + print("=" * 60) - generator = DataGenerator(args) + print(f"场景: {config['scenario']['name']}") + print(f"地图: {config['scenario']['town']}") + print(f"天气/时间: {config['scenario']['weather']}/{config['scenario']['time_of_day']}") + print(f"时长: {config['scenario']['duration']}秒") + print(f"交通: {config['traffic']['background_vehicles']}车辆 + {config['traffic']['pedestrians']}行人") + + print(f"传感器:") + print( + f" 摄像头: {config['sensors']['vehicle_cameras']}车辆 + {config['sensors']['infrastructure_cameras']}基础设施") + print(f" LiDAR: {'启用' if config['sensors']['lidar_sensors'] > 0 else '禁用'}") + print(f" 融合: {'启用' if config['output']['save_fusion'] else '禁用'}") + print(f" 标注: {'启用' if config['output']['save_annotations'] else '禁用'}") + + collector = DataCollector(config) try: - if not generator.connect_to_server(): + if not collector.connect(): + print("连接CARLA服务器失败") return - ego_vehicle = generator.setup_scene() - if not ego_vehicle: - generator.cleanup() + if not collector.setup_scene(): + print("场景设置失败") + collector.cleanup() return - if not generator.setup_cameras(ego_vehicle): - generator.cleanup() + if not collector.setup_sensors(): + print("传感器设置失败") + collector.cleanup() return - generator.collect_data() + collector.collect_data() + + collector.run_analysis() + collector.run_validation() except KeyboardInterrupt: - print("\n程序中断") + print("\n程序被用户中断") except Exception as e: print(f"\n运行错误: {e}") traceback.print_exc() finally: - generator.cleanup() - print(f"\n数据保存到: {generator.output_dir}") + collector.cleanup() + print(f"\n数据集已保存到: {collector.output_dir}") if __name__ == "__main__": diff --git a/src/enhance_pedestrian_safety/scene_manager.py b/src/enhance_pedestrian_safety/scene_manager.py new file mode 100644 index 0000000000..dbe424d7d4 --- /dev/null +++ b/src/enhance_pedestrian_safety/scene_manager.py @@ -0,0 +1,245 @@ +import os +import json +import random +import math +import carla + + +class SceneManager: + """场景管理器 - 支持多种预定义场景""" + + # 场景预设配置 + SCENES = { + 'intersection_4way': { + 'description': '四路交叉口场景', + 'pedestrian_behavior': ['crossing', 'walking'], + 'vehicle_density': 0.7, + 'pedestrian_density': 0.8, + 'weather_variations': ['clear', 'cloudy'] + }, + 'highway': { + 'description': '高速公路场景', + 'pedestrian_behavior': [], + 'vehicle_density': 0.9, + 'pedestrian_density': 0.0, + 'weather_variations': ['clear', 'rainy'] + }, + 'urban_street': { + 'description': '城市街道场景', + 'pedestrian_behavior': ['walking', 'crossing', 'waiting'], + 'vehicle_density': 0.6, + 'pedestrian_density': 0.7, + 'weather_variations': ['clear', 'cloudy', 'rainy'] + }, + 'night_scene': { + 'description': '夜间场景', + 'pedestrian_behavior': ['walking'], + 'vehicle_density': 0.5, + 'pedestrian_density': 0.4, + 'weather_variations': ['clear'], + 'time_of_day': 'night' + }, + 'rainy_intersection': { + 'description': '雨天交叉口', + 'pedestrian_behavior': ['crossing'], + 'vehicle_density': 0.6, + 'pedestrian_density': 0.5, + 'weather_variations': ['rainy'] + } + } + + @staticmethod + def setup_scene(world, config, scene_type='intersection_4way'): + """设置特定场景""" + if scene_type not in SceneManager.SCENES: + print(f"未知场景类型: {scene_type}") + return config + + scene_config = SceneManager.SCENES[scene_type] + + # 更新配置 + if 'time_of_day' in scene_config: + config['scenario']['time_of_day'] = scene_config['time_of_day'] + + if scene_config['weather_variations']: + config['scenario']['weather'] = random.choice(scene_config['weather_variations']) + + # 调整交通密度 + base_vehicles = config['traffic']['background_vehicles'] + base_pedestrians = config['traffic']['pedestrians'] + + config['traffic']['background_vehicles'] = int(base_vehicles * scene_config['vehicle_density']) + config['traffic']['pedestrians'] = int(base_pedestrians * scene_config['pedestrian_density']) + + # 设置行人行为 + config['traffic']['pedestrian_behaviors'] = scene_config['pedestrian_behavior'] + + # 应用场景特定设置 + SceneManager._apply_scene_specifics(world, scene_type) + + return config + + @staticmethod + def _apply_scene_specifics(world, scene_type): + """应用场景特定的设置""" + try: + if scene_type == 'highway': + # 高速公路场景:设置较高车速 + for actor in world.get_actors(): + if 'vehicle' in actor.type_id: + try: + actor.enable_constant_velocity(carla.Vector3D(25, 0, 0)) + except: + pass + + elif scene_type == 'night_scene': + # 夜间场景:调整灯光 + for actor in world.get_actors(): + if 'vehicle' in actor.type_id: + try: + light_state = carla.VehicleLightState.Position | carla.VehicleLightState.LowBeam + actor.set_light_state(light_state) + except: + pass + + except Exception as e: + print(f"场景特定设置失败: {e}") + + @staticmethod + def spawn_traffic_cones(world, center_location, num_cones=10): + """生成交通锥桶""" + blueprint_lib = world.get_blueprint_library() + cone_bp = blueprint_lib.find('static.prop.roadcone') + + cones = [] + for i in range(num_cones): + try: + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(3.0, 8.0) + + location = carla.Location( + x=center_location.x + distance * math.cos(angle), + y=center_location.y + distance * math.sin(angle), + z=center_location.z + 0.2 + ) + + rotation = carla.Rotation(0, random.uniform(0, 360), 0) + transform = carla.Transform(location, rotation) + + cone = world.spawn_actor(cone_bp, transform) + cones.append(cone) + + except Exception as e: + print(f"生成交通锥桶失败: {e}") + + return cones + + @staticmethod + def spawn_construction_barriers(world, center_location, num_barriers=5): + """生成施工障碍物""" + blueprint_lib = world.get_blueprint_library() + barrier_bp = blueprint_lib.find('static.prop.constructionbarrier') + + barriers = [] + for i in range(num_barriers): + try: + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(5.0, 12.0) + + location = carla.Location( + x=center_location.x + distance * math.cos(angle), + y=center_location.y + distance * math.sin(angle), + z=center_location.z + 0.2 + ) + + rotation = carla.Rotation(0, random.uniform(0, 360), 0) + transform = carla.Transform(location, rotation) + + barrier = world.spawn_actor(barrier_bp, transform) + barriers.append(barrier) + + except Exception as e: + print(f"生成施工障碍物失败: {e}") + + return barriers + + @staticmethod + def setup_traffic_accident(world, center_location, severity='minor'): + """设置交通事故场景""" + blueprint_lib = world.get_blueprint_library() + + # 生成事故车辆 + accident_vehicles = [] + for i in range(2): # 两车事故 + try: + vehicle_bp = random.choice(list(blueprint_lib.filter('vehicle.*'))) + + # 稍微偏移位置,模拟碰撞 + offset_x = random.uniform(-3.0, 3.0) if i == 0 else random.uniform(2.0, 5.0) + offset_y = random.uniform(-2.0, 2.0) if i == 0 else random.uniform(-5.0, -2.0) + + location = carla.Location( + x=center_location.x + offset_x, + y=center_location.y + offset_y, + z=center_location.z + 0.5 + ) + + # 设置碰撞角度 + rotation = carla.Rotation( + 0, + random.uniform(-30, 30) + (90 if i == 1 else 0), + 0 + ) + + transform = carla.Transform(location, rotation) + vehicle = world.spawn_actor(vehicle_bp, transform) + + # 根据严重程度设置车辆损坏 + if severity == 'major': + vehicle.set_light_state(carla.VehicleLightState.Hazard) + + accident_vehicles.append(vehicle) + + except Exception as e: + print(f"生成事故车辆失败: {e}") + + # 生成应急车辆(警车、救护车) + emergency_vehicles = [] + try: + police_bp = blueprint_lib.find('vehicle.dodge.charger_police') + if police_bp: + location = carla.Location( + x=center_location.x - 8.0, + y=center_location.y + 4.0, + z=center_location.z + 0.5 + ) + rotation = carla.Rotation(0, 45, 0) + police = world.spawn_actor(police_bp, carla.Transform(location, rotation)) + police.set_light_state(carla.VehicleLightState.Special1) + emergency_vehicles.append(police) + except: + pass + + return accident_vehicles, emergency_vehicles + + @staticmethod + def save_scene_description(output_dir, scene_type, config, extra_info=None): + """保存场景描述文件""" + scene_info = { + 'scene_type': scene_type, + 'description': SceneManager.SCENES.get(scene_type, {}).get('description', '未知场景'), + 'config': config, + 'created': SceneManager._get_timestamp(), + 'extra_info': extra_info or {} + } + + scene_file = os.path.join(output_dir, "metadata", "scene_description.json") + with open(scene_file, 'w', encoding='utf-8') as f: + json.dump(scene_info, f, indent=2, ensure_ascii=False) + + print(f"场景描述保存: {scene_file}") + + @staticmethod + def _get_timestamp(): + from datetime import datetime + return datetime.now().isoformat() \ No newline at end of file From 8704ed79206674fae74ca61434cdb609f762db50 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Thu, 18 Dec 2025 22:29:03 +0800 Subject: [PATCH 02/21] =?UTF-8?q?=E5=A4=9A=E8=BD=A6=E8=BE=86=E5=8D=8F?= =?UTF-8?q?=E5=90=8C=E4=B8=8EV2X=E9=80=9A=E4=BF=A1=E6=A8=A1=E6=8B=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 28 ++ .../data_analyzer.py | 175 ++++++- .../data_validator.py | 204 +++++++- src/enhance_pedestrian_safety/main.py | 299 ++++++++++-- .../multi_vehicle_manager.py | 434 ++++++++++++++++++ .../v2x_communication.py | 328 +++++++++++++ 6 files changed, 1379 insertions(+), 89 deletions(-) create mode 100644 src/enhance_pedestrian_safety/multi_vehicle_manager.py create mode 100644 src/enhance_pedestrian_safety/v2x_communication.py diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 38622ee18a..499384a98f 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -36,6 +36,23 @@ def load_config(config_file=None): 'rotation_frequency': 10 } }, + 'v2x': { + 'enabled': True, + 'communication_range': 300.0, + 'bandwidth': 10.0, + 'latency_mean': 0.05, + 'latency_std': 0.01, + 'packet_loss_rate': 0.01, + 'message_types': ['bsm', 'spat', 'map', 'rsm'] + }, + 'cooperative': { + 'num_coop_vehicles': 2, + 'enable_shared_perception': True, + 'enable_traffic_warnings': True, + 'enable_maneuver_coordination': False, + 'data_fusion_interval': 1.0, + 'max_shared_objects': 50 + }, 'output': { 'data_dir': 'cvips_dataset', 'save_raw': True, @@ -43,6 +60,8 @@ def load_config(config_file=None): 'save_annotations': False, 'save_lidar': True, 'save_fusion': True, + 'save_cooperative': True, + 'save_v2x_messages': True, 'validate_data': True, 'run_analysis': False } @@ -86,9 +105,15 @@ def merge_args(config, args): if args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians + if args.num_coop_vehicles: + config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles + if args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval + if args.enable_v2x: + config['v2x']['enabled'] = True + if args.enable_lidar: config['sensors']['lidar_sensors'] = 1 config['output']['save_lidar'] = True @@ -96,6 +121,9 @@ def merge_args(config, args): if args.enable_fusion: config['output']['save_fusion'] = True + if args.enable_cooperative: + config['output']['save_cooperative'] = True + if args.enable_annotations: config['output']['save_annotations'] = True diff --git a/src/enhance_pedestrian_safety/data_analyzer.py b/src/enhance_pedestrian_safety/data_analyzer.py index a5802c2dc4..069d6d2ec7 100644 --- a/src/enhance_pedestrian_safety/data_analyzer.py +++ b/src/enhance_pedestrian_safety/data_analyzer.py @@ -17,6 +17,7 @@ def analyze_dataset(data_dir): 'file_distribution': DataAnalyzer._analyze_file_distribution(data_dir), 'object_statistics': DataAnalyzer._analyze_objects(data_dir), 'temporal_analysis': DataAnalyzer._analyze_temporal(data_dir), + 'cooperative_data': DataAnalyzer._analyze_cooperative_data(data_dir), 'quality_metrics': DataAnalyzer._calculate_quality_metrics(data_dir) } @@ -77,18 +78,21 @@ def _analyze_file_distribution(data_dir): distribution = {} # 分析原始图像 - raw_dirs = ['vehicle', 'infrastructure'] + raw_dirs = [] + raw_path = os.path.join(data_dir, "raw") + if os.path.exists(raw_path): + raw_dirs = [d for d in os.listdir(raw_path) if os.path.isdir(os.path.join(raw_path, d))] + for raw_dir in raw_dirs: path = os.path.join(data_dir, "raw", raw_dir) - if os.path.exists(path): - camera_stats = {} - for camera_dir in os.listdir(path): - camera_path = os.path.join(path, camera_dir) - if os.path.isdir(camera_path): - images = [f for f in os.listdir(camera_path) - if f.endswith(('.png', '.jpg', '.jpeg'))] - camera_stats[camera_dir] = len(images) - distribution[f'raw_{raw_dir}'] = camera_stats + camera_stats = {} + for camera_dir in os.listdir(path): + camera_path = os.path.join(path, camera_dir) + if os.path.isdir(camera_path): + images = [f for f in os.listdir(camera_path) + if f.endswith(('.png', '.jpg', '.jpeg'))] + camera_stats[camera_dir] = len(images) + distribution[f'raw_{raw_dir}'] = camera_stats # 分析拼接图像 stitched_dir = os.path.join(data_dir, "stitched") @@ -103,6 +107,19 @@ def _analyze_file_distribution(data_dir): json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] distribution['annotations'] = len(json_files) + # 分析LiDAR数据 + lidar_dir = os.path.join(data_dir, "lidar") + if os.path.exists(lidar_dir): + bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] + npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] + distribution['lidar'] = {'bin': len(bin_files), 'npy': len(npy_files)} + + # 分析融合数据 + fusion_dir = os.path.join(data_dir, "fusion") + if os.path.exists(fusion_dir): + json_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] + distribution['fusion'] = len(json_files) + return distribution @staticmethod @@ -111,7 +128,7 @@ def _analyze_objects(data_dir): annotations_dir = os.path.join(data_dir, "annotations") if not os.path.exists(annotations_dir): - return {'total_objects': 0, 'by_class': {}, 'by_frame': {}} + return {'total_objects': 0, 'by_class': {}, 'by_frame': {}, 'class_distribution': {}} object_stats = { 'total_objects': 0, @@ -173,6 +190,78 @@ def _analyze_temporal(data_dir): return temporal_stats + @staticmethod + def _analyze_cooperative_data(data_dir): + """分析协同数据""" + coop_dir = os.path.join(data_dir, "cooperative") + + if not os.path.exists(coop_dir): + return { + 'v2x_messages': 0, + 'shared_perception': 0, + 'vehicles_count': 0, + 'communication_stats': {} + } + + # V2X消息统计 + v2x_dir = os.path.join(coop_dir, "v2x_messages") + v2x_files = [] + if os.path.exists(v2x_dir): + v2x_files = [f for f in os.listdir(v2x_dir) if f.endswith('.json')] + + # 共享感知统计 + perception_dir = os.path.join(coop_dir, "shared_perception") + perception_files = [] + if os.path.exists(perception_dir): + perception_files = [f for f in os.listdir(perception_dir) if f.endswith('.json')] + + # 读取协同摘要 + coop_summary = {} + summary_file = os.path.join(coop_dir, "cooperative_summary.json") + if os.path.exists(summary_file): + try: + with open(summary_file, 'r') as f: + coop_summary = json.load(f) + except: + pass + + # 分析V2X消息内容 + v2x_stats = { + 'total_messages': len(v2x_files), + 'message_types': defaultdict(int), + 'average_message_size': 0 + } + + if v2x_files: + total_size = 0 + for v2x_file in v2x_files[:min(10, len(v2x_files))]: # 抽样分析 + try: + with open(os.path.join(v2x_dir, v2x_file), 'r') as f: + data = json.load(f) + message_type = data.get('message', {}).get('message_type', 'unknown') + v2x_stats['message_types'][message_type] += 1 + + file_size = os.path.getsize(os.path.join(v2x_dir, v2x_file)) + total_size += file_size + except: + pass + + v2x_stats['average_message_size'] = round(total_size / max(len(v2x_files), 1), 2) + + analysis = { + 'v2x_messages': len(v2x_files), + 'shared_perception_frames': len(perception_files), + 'total_vehicles': coop_summary.get('total_vehicles', 0), + 'ego_vehicles': coop_summary.get('ego_vehicles', 0), + 'cooperative_vehicles': coop_summary.get('cooperative_vehicles', 0), + 'v2x_stats': v2x_stats, + 'shared_objects_count': coop_summary.get('shared_objects_count', 0), + 'communication_range': coop_summary.get('communication_range', 0), + 'collaborative_detections': coop_summary.get('v2x_stats', {}).get('collaborative_detections', 0) + } + + return analysis + @staticmethod def _calculate_quality_metrics(data_dir): """计算质量指标""" @@ -180,20 +269,22 @@ def _calculate_quality_metrics(data_dir): 'completeness_score': 0, 'consistency_score': 0, 'diversity_score': 0, + 'cooperative_score': 0, 'issues_found': [] } # 检查完整性 - required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata"] + required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata", "cooperative"] missing_dirs = [] for dir_path in required_dirs: - if not os.path.exists(os.path.join(data_dir, dir_path)): + full_path = os.path.join(data_dir, dir_path) + if not os.path.exists(full_path): missing_dirs.append(dir_path) if missing_dirs: quality_metrics['issues_found'].append(f"缺失目录: {missing_dirs}") - quality_metrics['completeness_score'] = 50 + quality_metrics['completeness_score'] = 100 - (len(missing_dirs) * 20) else: quality_metrics['completeness_score'] = 100 @@ -209,7 +300,7 @@ def _calculate_quality_metrics(data_dir): camera_counts.append(len(images)) if camera_counts: - max_diff = max(camera_counts) - min(camera_counts) + max_diff = max(camera_counts) - min(camera_counts) if camera_counts else 0 if max_diff > 5: quality_metrics['issues_found'].append(f"摄像头图像数量不一致: 差异{max_diff}") quality_metrics['consistency_score'] = 70 @@ -228,16 +319,27 @@ def _calculate_quality_metrics(data_dir): quality_metrics['diversity_score'] = 50 quality_metrics['issues_found'].append(f"物体类别较少: {num_classes}类") + # 协同评分 + cooperative_data = DataAnalyzer._analyze_cooperative_data(data_dir) + if cooperative_data['v2x_messages'] > 10 and cooperative_data['shared_perception_frames'] > 5: + quality_metrics['cooperative_score'] = 90 + elif cooperative_data['v2x_messages'] > 0 or cooperative_data['shared_perception_frames'] > 0: + quality_metrics['cooperative_score'] = 60 + else: + quality_metrics['cooperative_score'] = 30 + quality_metrics['issues_found'].append("协同数据较少") + return quality_metrics @staticmethod def _calculate_overall_score(analysis): """计算总体评分""" weights = { - 'completeness': 0.3, - 'consistency': 0.25, - 'diversity': 0.25, - 'temporal': 0.2 + 'completeness': 0.25, + 'consistency': 0.20, + 'diversity': 0.15, + 'cooperative': 0.20, + 'temporal': 0.20 } quality = analysis['quality_metrics'] @@ -245,7 +347,8 @@ def _calculate_overall_score(analysis): score = ( quality['completeness_score'] * weights['completeness'] + quality['consistency_score'] * weights['consistency'] + - quality['diversity_score'] * weights['diversity'] + quality['diversity_score'] * weights['diversity'] + + quality['cooperative_score'] * weights['cooperative'] ) # 时间因素 @@ -257,7 +360,7 @@ def _calculate_overall_score(analysis): else: score += 5 * weights['temporal'] - return round(score, 1) + return round(min(score, 100), 1) @staticmethod def _save_analysis_report(data_dir, analysis): @@ -292,7 +395,11 @@ def _print_analysis_summary(analysis): if isinstance(value, dict): print(f" {key}:") for subkey, subvalue in value.items(): - print(f" {subkey}: {subvalue}") + if isinstance(subvalue, dict): + for subsubkey, subsubvalue in subvalue.items(): + print(f" {subsubkey}: {subsubvalue}") + else: + print(f" {subkey}: {subvalue}") else: print(f" {key}: {value}") @@ -305,6 +412,22 @@ def _print_analysis_summary(analysis): percentage = objects['class_distribution'].get(obj_class, 0) print(f" {obj_class}: {count} ({percentage}%)") + # 协同数据分析 + cooperative = analysis['cooperative_data'] + print(f"\n协同数据分析:") + print(f" V2X消息: {cooperative['v2x_messages']}") + print(f" 共享感知帧: {cooperative['shared_perception_frames']}") + print(f" 车辆总数: {cooperative['total_vehicles']}") + print(f" 主车: {cooperative['ego_vehicles']}") + print(f" 协同车: {cooperative['cooperative_vehicles']}") + print(f" 共享对象数: {cooperative['shared_objects_count']}") + print(f" 协作检测数: {cooperative['collaborative_detections']}") + + if cooperative['v2x_stats']['message_types']: + print(f" V2X消息类型:") + for msg_type, count in cooperative['v2x_stats']['message_types'].items(): + print(f" {msg_type}: {count}") + temporal = analysis['temporal_analysis'] print(f"\n时间分析:") print(f" 总时长: {temporal['total_duration']:.1f}秒") @@ -315,6 +438,7 @@ def _print_analysis_summary(analysis): print(f" 完整性: {quality['completeness_score']}/100") print(f" 一致性: {quality['consistency_score']}/100") print(f" 多样性: {quality['diversity_score']}/100") + print(f" 协同性: {quality['cooperative_score']}/100") if quality['issues_found']: print(f" 发现的问题 ({len(quality['issues_found'])}):") @@ -325,11 +449,12 @@ def _print_analysis_summary(analysis): print(f"\n总体评分: {analysis['overall_score']}/100") - if analysis['overall_score'] >= 90: + overall_score = analysis['overall_score'] + if overall_score >= 90: print("✓ 数据集质量优秀") - elif analysis['overall_score'] >= 75: + elif overall_score >= 75: print("✓ 数据集质量良好") - elif analysis['overall_score'] >= 60: + elif overall_score >= 60: print("⚠ 数据集质量一般") else: print("✗ 数据集质量需要改进") diff --git a/src/enhance_pedestrian_safety/data_validator.py b/src/enhance_pedestrian_safety/data_validator.py index f015231a42..fa67f6425b 100644 --- a/src/enhance_pedestrian_safety/data_validator.py +++ b/src/enhance_pedestrian_safety/data_validator.py @@ -14,7 +14,9 @@ def validate_dataset(data_dir): 'stitched_images': DataValidator._validate_stitched_images(data_dir), 'annotations': DataValidator._validate_annotations(data_dir), 'metadata': DataValidator._validate_metadata(data_dir), - 'lidar_data': DataValidator._validate_lidar_data(data_dir) + 'lidar_data': DataValidator._validate_lidar_data(data_dir), + 'cooperative_data': DataValidator._validate_cooperative_data(data_dir), + 'fusion_data': DataValidator._validate_fusion_data(data_dir) } validation_results['overall_score'] = DataValidator._calculate_score(validation_results) @@ -30,7 +32,11 @@ def _check_directory_structure(data_dir): "raw/vehicle", "raw/infrastructure", "stitched", - "metadata" + "metadata", + "cooperative", + "cooperative/v2x_messages", + "cooperative/shared_perception", + "fusion" ] missing_dirs = [] @@ -51,14 +57,17 @@ def _check_directory_structure(data_dir): @staticmethod def _validate_raw_images(data_dir): - raw_dirs = ["vehicle", "infrastructure"] + raw_path = os.path.join(data_dir, "raw") + + if not os.path.exists(raw_path): + return {'vehicle': {'status': 'MISSING', 'count': 0, 'errors': []}, + 'infrastructure': {'status': 'MISSING', 'count': 0, 'errors': []}} + + raw_dirs = [d for d in os.listdir(raw_path) if os.path.isdir(os.path.join(raw_path, d))] results = {} for raw_dir in raw_dirs: path = os.path.join(data_dir, "raw", raw_dir) - if not os.path.exists(path): - results[raw_dir] = {'status': 'MISSING', 'count': 0, 'errors': []} - continue camera_dirs = [] if os.path.exists(path): @@ -143,6 +152,13 @@ def _validate_annotations(data_dir): try: with open(json_path, 'r') as f: data = json.load(f) + + # 检查基本结构 + required_keys = ['frame_id', 'objects'] + for key in required_keys: + if key not in data: + errors.append(f"缺失必要键: {key} in {json_file}") + valid_files += 1 except Exception as e: errors.append(f"无效的JSON文件: {json_file} - {str(e)}") @@ -201,19 +217,152 @@ def _validate_lidar_data(data_dir): return {'status': 'MISSING', 'count': 0, 'errors': []} bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] + npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] + json_files = [f for f in os.listdir(lidar_dir) if f.endswith('.json')] + errors = [] - valid_files = 0 + valid_bin_files = 0 for bin_file in bin_files: bin_path = os.path.join(lidar_dir, bin_file) try: if os.path.getsize(bin_path) > 0: - valid_files += 1 + valid_bin_files += 1 else: errors.append(f"空文件: {bin_file}") except: errors.append(f"文件访问失败: {bin_file}") + total_files = len(bin_files) + len(npy_files) + len(json_files) + + if len(errors) == 0 and valid_bin_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_bin_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': total_files, + 'bin_files': len(bin_files), + 'npy_files': len(npy_files), + 'json_files': len(json_files), + 'errors': errors + } + + @staticmethod + def _validate_cooperative_data(data_dir): + """验证协同数据""" + coop_dir = os.path.join(data_dir, "cooperative") + + if not os.path.exists(coop_dir): + return {'status': 'MISSING', 'count': 0, 'errors': [], 'v2x_messages': 0, 'shared_perception': 0} + + errors = [] + + # 检查V2X消息目录 + v2x_dir = os.path.join(coop_dir, "v2x_messages") + v2x_files = [] + if os.path.exists(v2x_dir): + v2x_files = [f for f in os.listdir(v2x_dir) if f.endswith('.json')] + for v2x_file in v2x_files[:min(5, len(v2x_files))]: # 检查前5个文件 + try: + with open(os.path.join(v2x_dir, v2x_file), 'r') as f: + data = json.load(f) + + # 检查必要字段 + required_keys = ['message', 'recipients', 'transmission_time'] + for key in required_keys: + if key not in data: + errors.append(f"V2X消息缺失字段 {key}: {v2x_file}") + except Exception as e: + errors.append(f"V2X消息文件无效: {v2x_file} - {str(e)}") + else: + errors.append("V2X消息目录不存在") + + # 检查共享感知目录 + perception_dir = os.path.join(coop_dir, "shared_perception") + perception_files = [] + if os.path.exists(perception_dir): + perception_files = [f for f in os.listdir(perception_dir) if f.endswith('.json')] + for perception_file in perception_files[:min(5, len(perception_files))]: + try: + with open(os.path.join(perception_dir, perception_file), 'r') as f: + data = json.load(f) + + # 检查必要字段 + required_keys = ['frame_id', 'timestamp', 'shared_objects'] + for key in required_keys: + if key not in data: + errors.append(f"共享感知文件缺失字段 {key}: {perception_file}") + except Exception as e: + errors.append(f"共享感知文件无效: {perception_file} - {str(e)}") + else: + errors.append("共享感知目录不存在") + + # 检查协同摘要 + summary_file = os.path.join(coop_dir, "cooperative_summary.json") + if not os.path.exists(summary_file): + errors.append("协同摘要文件不存在") + else: + try: + with open(summary_file, 'r') as f: + data = json.load(f) + + # 检查摘要字段 + required_keys = ['total_vehicles', 'ego_vehicles', 'cooperative_vehicles', 'v2x_stats'] + for key in required_keys: + if key not in data: + errors.append(f"协同摘要缺失字段: {key}") + except Exception as e: + errors.append(f"协同摘要文件无效: {str(e)}") + + total_files = len(v2x_files) + len(perception_files) + + if len(errors) == 0 and total_files > 0: + status = 'PASS' + elif len(errors) < 3 and total_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': total_files, + 'v2x_messages': len(v2x_files), + 'shared_perception': len(perception_files), + 'errors': errors + } + + @staticmethod + def _validate_fusion_data(data_dir): + """验证融合数据""" + fusion_dir = os.path.join(data_dir, "fusion") + + if not os.path.exists(fusion_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + json_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] + errors = [] + valid_files = 0 + + for json_file in json_files[:min(5, len(json_files))]: # 检查前5个文件 + json_path = os.path.join(fusion_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + + # 检查必要字段 + required_keys = ['frame_id', 'timestamp', 'sensors'] + for key in required_keys: + if key not in data: + errors.append(f"融合文件缺失字段 {key}: {json_file}") + + valid_files += 1 + except Exception as e: + errors.append(f"融合文件无效: {json_file} - {str(e)}") + if len(errors) == 0 and valid_files > 0: status = 'PASS' elif len(errors) < 3 and valid_files > 0: @@ -223,19 +372,21 @@ def _validate_lidar_data(data_dir): return { 'status': status, - 'count': valid_files, + 'count': len(json_files), 'errors': errors } @staticmethod def _calculate_score(results): weights = { - 'directory_structure': 0.15, - 'raw_images': 0.25, - 'stitched_images': 0.15, - 'annotations': 0.1, - 'metadata': 0.15, - 'lidar_data': 0.2 + 'directory_structure': 0.10, + 'raw_images': 0.20, + 'stitched_images': 0.10, + 'annotations': 0.10, + 'metadata': 0.10, + 'lidar_data': 0.15, + 'cooperative_data': 0.15, + 'fusion_data': 0.10 } score = 0 @@ -280,13 +431,34 @@ def _print_validation_report(results): print(f"\n{key.replace('_', ' ').title()}:") if 'status' in result: - print(f" 状态: {result['status']}") + status_icon = '✓' if result['status'] == 'PASS' else '⚠' if result['status'] == 'WARNING' else '✗' + print(f" 状态: {status_icon} {result['status']}") else: print(f" 状态: 未知") if 'count' in result: print(f" 数量: {result['count']}") + # 特定类型数据的额外信息 + if key == 'raw_images' and isinstance(result, dict): + for subkey, subresult in result.items(): + if isinstance(subresult, dict) and 'count' in subresult: + print(f" {subkey}: {subresult['count']} 图像") + + if key == 'cooperative_data' and isinstance(result, dict): + if 'v2x_messages' in result: + print(f" V2X消息: {result['v2x_messages']}") + if 'shared_perception' in result: + print(f" 共享感知: {result['shared_perception']}") + + if key == 'lidar_data' and isinstance(result, dict): + if 'bin_files' in result: + print(f" BIN文件: {result['bin_files']}") + if 'npy_files' in result: + print(f" NPY文件: {result['npy_files']}") + if 'json_files' in result: + print(f" JSON文件: {result['json_files']}") + if 'errors' in result and result['errors']: print(f" 错误 ({len(result['errors'])}):") for error in result['errors'][:3]: diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 64f7caf9ea..2f855d36cc 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -16,6 +16,8 @@ from scene_manager import SceneManager from data_analyzer import DataAnalyzer from lidar_processor import LidarProcessor, MultiSensorFusion +from multi_vehicle_manager import MultiVehicleManager +from v2x_communication import V2XCommunication carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() @@ -254,14 +256,14 @@ def __init__(self, world, config, data_dir): if config['output'].get('save_fusion', False): self.fusion_manager = MultiSensorFusion(data_dir) - def setup_cameras(self, vehicle, center_location): - vehicle_cams = self._setup_vehicle_cameras(vehicle) + def setup_cameras(self, vehicle, center_location, vehicle_id=0): + vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) infra_cams = self._setup_infrastructure_cameras(center_location) Log.info(f"摄像头: {vehicle_cams}车辆 + {infra_cams}基础设施") return vehicle_cams + infra_cams - def _setup_vehicle_cameras(self, vehicle): + def _setup_vehicle_cameras(self, vehicle, vehicle_id): if not vehicle: return 0 @@ -274,7 +276,7 @@ def _setup_vehicle_cameras(self, vehicle): installed = 0 for cam_name, config_data in camera_configs.items(): - if self._create_camera(cam_name, config_data, vehicle, 'vehicle'): + if self._create_camera(cam_name, config_data, vehicle, 'vehicle', vehicle_id): installed += 1 return installed @@ -304,7 +306,7 @@ def _setup_infrastructure_cameras(self, center_location): return installed - def setup_lidar(self, vehicle): + def setup_lidar(self, vehicle, vehicle_id=0): if not vehicle or not self.config['sensors'].get('lidar_sensors', 0) > 0: return 0 @@ -319,7 +321,6 @@ def setup_lidar(self, vehicle): lidar_bp.set_attribute('points_per_second', str(lidar_config.get('points_per_second', 56000))) lidar_bp.set_attribute('rotation_frequency', str(lidar_config.get('rotation_frequency', 10))) - # 添加更多LiDAR参数 lidar_bp.set_attribute('upper_fov', '10') lidar_bp.set_attribute('lower_fov', '-20') lidar_bp.set_attribute('horizontal_fov', '360') @@ -337,11 +338,9 @@ def lidar_callback(lidar_data): try: metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) if metadata and self.fusion_manager: - # 尝试获取最新的车辆图像 vehicle_image_path = None with self.buffer_lock: if self.vehicle_buffer: - # 取第一个摄像头的图像 for cam_name, img_path in self.vehicle_buffer.items(): if os.path.exists(img_path): vehicle_image_path = img_path @@ -366,7 +365,8 @@ def lidar_callback(lidar_data): except Exception as e: print(f"LiDAR安装失败: {e}") return 0 - def _create_camera(self, name, config, parent, sensor_type): + + def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): try: blueprint = self.world.get_blueprint_library().find('sensor.camera.rgb') @@ -384,10 +384,15 @@ def _create_camera(self, name, config, parent, sensor_type): else: camera = self.world.spawn_actor(blueprint, transform) - save_dir = os.path.join(self.data_dir, "raw", sensor_type, name) + # 为不同车辆创建不同目录 + if sensor_type == 'vehicle' and vehicle_id > 0: + save_dir = os.path.join(self.data_dir, "raw", f"vehicle_{vehicle_id}", name) + else: + save_dir = os.path.join(self.data_dir, "raw", sensor_type, name) + os.makedirs(save_dir, exist_ok=True) - callback = self._create_callback(save_dir, name, sensor_type) + callback = self._create_callback(save_dir, name, sensor_type, vehicle_id) camera.listen(callback) self.sensors.append(camera) @@ -397,7 +402,7 @@ def _create_camera(self, name, config, parent, sensor_type): Log.warning(f"创建摄像头 {name} 失败: {e}") return False - def _create_callback(self, save_dir, name, sensor_type): + def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): capture_interval = self.config['sensors']['capture_interval'] def callback(image): @@ -414,7 +419,8 @@ def callback(image): if sensor_type == 'vehicle': self.vehicle_buffer[name] = filename if len(self.vehicle_buffer) >= 4: - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, 'vehicle') + self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, + f'vehicle_{vehicle_id}') self.vehicle_buffer.clear() else: self.infra_buffer[name] = filename @@ -459,13 +465,15 @@ def __init__(self, config): self.config = config self.client = None self.world = None - self.ego_vehicle = None + self.ego_vehicles = [] # 多个主车 self.scene_center = None self.setup_directories() self.traffic_manager = None - self.sensor_manager = None + self.sensor_managers = {} # 车辆ID -> SensorManager + self.multi_vehicle_manager = None + self.v2x_communication = None self.start_time = None self.is_running = False @@ -481,12 +489,15 @@ def setup_directories(self): ) directories = [ - "raw/vehicle", + "raw/vehicle_1", # 主车1 + "raw/vehicle_2", # 主车2(如果有) "raw/infrastructure", "stitched", "lidar", "fusion", "calibration", + "cooperative", + "v2x_messages", "metadata" ] @@ -531,26 +542,74 @@ def setup_scene(self): self.traffic_manager = TrafficManager(self.world, self.config) - self.ego_vehicle = self.traffic_manager.spawn_ego_vehicle() - if not self.ego_vehicle: + # 生成多个主车 + num_ego_vehicles = min(self.config['cooperative'].get('num_coop_vehicles', 2) + 1, 3) + for i in range(num_ego_vehicles): + ego_vehicle = self.traffic_manager.spawn_ego_vehicle() + if ego_vehicle: + self.ego_vehicles.append(ego_vehicle) + Log.info(f"主车 {i + 1} 生成: {ego_vehicle.type_id}") + + if not self.ego_vehicles: Log.error("主车生成失败") return False self.traffic_manager.spawn_traffic(self.scene_center) + # 初始化V2X通信 + if self.config['v2x']['enabled']: + self.v2x_communication = V2XCommunication(self.config['v2x']) + + # 注册车辆到V2X网络 + for i, vehicle in enumerate(self.ego_vehicles): + location = vehicle.get_location() + self.v2x_communication.register_node( + f'vehicle_{vehicle.id}', + (location.x, location.y, location.z), + {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} + ) + + # 初始化多车辆管理器 + self.multi_vehicle_manager = MultiVehicleManager( + self.world, + self.config, + self.output_dir + ) + + # 设置主车 + self.multi_vehicle_manager.ego_vehicles = self.ego_vehicles + + # 生成协同车辆 + num_coop_vehicles = self.config['cooperative'].get('num_coop_vehicles', 2) + coop_vehicles = self.multi_vehicle_manager.spawn_cooperative_vehicles(num_coop_vehicles) + + # 注册协同车辆到V2X网络 + if self.v2x_communication: + for vehicle in coop_vehicles: + location = vehicle.get_location() + self.v2x_communication.register_node( + f'vehicle_{vehicle.id}', + (location.x, location.y, location.z), + {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} + ) + time.sleep(3.0) return True def setup_sensors(self): - self.sensor_manager = SensorManager(self.world, self.config, self.output_dir) + # 为每个主车设置传感器 + for i, vehicle in enumerate(self.ego_vehicles): + sensor_manager = SensorManager(self.world, self.config, self.output_dir) - cameras = self.sensor_manager.setup_cameras(self.ego_vehicle, self.scene_center) - if cameras == 0: - Log.error("没有摄像头安装成功") - return False + cameras = sensor_manager.setup_cameras(vehicle, self.scene_center, i + 1) + if cameras == 0: + Log.error(f"车辆 {i + 1} 没有摄像头安装成功") + return False + + lidars = sensor_manager.setup_lidar(vehicle, i + 1) + Log.info(f"车辆 {i + 1} 传感器: {cameras}摄像头 + {lidars}LiDAR") - lidars = self.sensor_manager.setup_lidar(self.ego_vehicle) - Log.info(f"传感器: {cameras}摄像头 + {lidars}LiDAR") + self.sensor_managers[vehicle.id] = sensor_manager return True @@ -562,17 +621,39 @@ def collect_data(self): self.is_running = True last_update = time.time() + last_v2x_update = time.time() + last_perception_share = time.time() try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time + # 更新车辆状态 + if self.multi_vehicle_manager: + self.multi_vehicle_manager.update_vehicle_states() + + # V2X通信更新 + if self.v2x_communication and current_time - last_v2x_update >= 0.1: + self._update_v2x_communication() + last_v2x_update = current_time + + # 共享感知数据 + if (self.config['cooperative'].get('enable_shared_perception', True) and + current_time - last_perception_share >= 2.0): + self._share_perception_data() + last_perception_share = current_time + + # 定期保存共享感知 + frame_count = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) + if frame_count % 10 == 0 and self.multi_vehicle_manager: + self.multi_vehicle_manager.save_shared_perception(frame_count) + if current_time - last_update >= 5.0: - frames = self.sensor_manager.get_frame_count() + total_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) progress = (elapsed / duration) * 100 - Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 帧数: {frames}") + Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 总帧数: {total_frames}") last_update = current_time time.sleep(0.05) @@ -583,17 +664,99 @@ def collect_data(self): self.is_running = False elapsed = time.time() - self.start_time - self.collected_frames = self.sensor_manager.get_frame_count() + self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") self._save_metadata() self._print_summary() + def _update_v2x_communication(self): + """更新V2X通信""" + if not self.v2x_communication: + return + + # 为每辆车发送基本安全消息 + for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + if not vehicle.is_alive: + continue + + try: + location = vehicle.get_location() + velocity = vehicle.get_velocity() + speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) + + vehicle_data = { + 'position': (location.x, location.y, location.z), + 'speed': speed, + 'heading': vehicle.get_transform().rotation.yaw, + 'acceleration': (0, 0, 0) # 简化处理 + } + + self.v2x_communication.broadcast_basic_safety_message( + f'vehicle_{vehicle.id}', + vehicle_data + ) + except: + pass + + # 处理接收到的消息 + for vehicle in self.ego_vehicles: + messages = self.v2x_communication.get_messages_for_node(f'vehicle_{vehicle.id}') + if messages: + Log.debug(f"车辆 {vehicle.id} 收到 {len(messages)} 条V2X消息") + + def _share_perception_data(self): + """共享感知数据""" + if not self.multi_vehicle_manager or not self.config['cooperative']['enable_shared_perception']: + return + + # 模拟车辆感知数据(简化处理,实际应从传感器获取) + for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + if not vehicle.is_alive: + continue + + # 模拟检测到的物体 + detected_objects = self._simulate_object_detection(vehicle) + + if detected_objects: + self.multi_vehicle_manager.share_perception_data(vehicle.id, detected_objects) + + def _simulate_object_detection(self, vehicle): + """模拟对象检测(简化)""" + detected_objects = [] + + # 获取车辆周围的其他车辆 + for other_vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + if other_vehicle.id == vehicle.id or not other_vehicle.is_alive: + continue + + try: + location = other_vehicle.get_location() + distance = vehicle.get_location().distance(location) + + # 模拟检测范围(50米) + if distance < 50.0: + obj_data = { + 'class': 'vehicle', + 'position': {'x': location.x, 'y': location.y, 'z': location.z}, + 'velocity': {'x': 0, 'y': 0, 'z': 0}, + 'confidence': max(0.7, 1.0 - distance / 50.0), + 'size': {'width': 2.0, 'length': 4.5, 'height': 1.5}, + 'id': other_vehicle.id + } + detected_objects.append(obj_data) + except: + pass + + return detected_objects + def _save_metadata(self): metadata = { 'scenario': self.config['scenario'], 'traffic': self.config['traffic'], 'sensors': self.config['sensors'], + 'v2x': self.config['v2x'], + 'cooperative': self.config['cooperative'], 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), @@ -602,9 +765,19 @@ def _save_metadata(self): } } - if self.sensor_manager: - sensor_summary = self.sensor_manager.generate_sensor_summary() - metadata['sensor_summary'] = sensor_summary + # 传感器摘要 + sensor_summaries = {} + for vehicle_id, sensor_manager in self.sensor_managers.items(): + sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() + metadata['sensor_summaries'] = sensor_summaries + + # V2X通信状态 + if self.v2x_communication: + metadata['v2x_status'] = self.v2x_communication.get_network_status() + + # 协同摘要 + if self.multi_vehicle_manager: + metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: @@ -640,11 +813,24 @@ def _print_summary(self): total_points += points_in_file print(f" 估计总点数: {total_points:,}") - # 统计融合数据 - fusion_dir = os.path.join(self.output_dir, "fusion") - if os.path.exists(fusion_dir): - sync_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] - print(f"融合数据: {len(sync_files)} 个同步文件") + # 统计协同数据 + coop_dir = os.path.join(self.output_dir, "cooperative") + if os.path.exists(coop_dir): + v2x_files = len([f for f in os.listdir(os.path.join(coop_dir, "v2x_messages")) if f.endswith('.json')]) + perception_files = len( + [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) + print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") + + # V2X统计 + if self.v2x_communication: + v2x_status = self.v2x_communication.get_network_status() + print(f"V2X通信: {v2x_status['stats']['messages_sent']} 发送, " + f"{v2x_status['stats']['messages_received']} 接收, " + f"{v2x_status['stats']['messages_dropped']} 丢包") + + # 车辆统计 + print(f"车辆总数: {len(self.ego_vehicles)} 主车 + " + f"{len(self.multi_vehicle_manager.cooperative_vehicles)} 协同车") print(f"\n输出目录: {self.output_dir}") print("=" * 60) @@ -662,27 +848,39 @@ def run_analysis(self): def cleanup(self): Log.info("清理场景...") - if self.sensor_manager: - self.sensor_manager.cleanup() + # 清理传感器 + for sensor_manager in self.sensor_managers.values(): + sensor_manager.cleanup() + # 清理交通 if self.traffic_manager: self.traffic_manager.cleanup() - if self.ego_vehicle and self.ego_vehicle.is_alive: - try: - self.ego_vehicle.destroy() - except: - pass + # 清理协同管理 + if self.multi_vehicle_manager: + self.multi_vehicle_manager.cleanup() + + # 清理V2X通信 + if self.v2x_communication: + self.v2x_communication.stop() + + # 清理车辆 + for vehicle in self.ego_vehicles: + if vehicle and vehicle.is_alive: + try: + vehicle.destroy() + except: + pass Log.info("清理完成") def main(): - parser = argparse.ArgumentParser(description='CVIPS 多传感器数据收集系统') + parser = argparse.ArgumentParser(description='CVIPS 多车辆协同数据收集系统 v10.0') # 基础参数 parser.add_argument('--config', type=str, help='配置文件路径') - parser.add_argument('--scenario', type=str, default='multi_sensor_scene', help='场景名称') + parser.add_argument('--scenario', type=str, default='multi_vehicle_cooperative', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='地图') parser.add_argument('--weather', type=str, default='clear', @@ -693,6 +891,7 @@ def main(): # 交通参数 parser.add_argument('--num-vehicles', type=int, default=8, help='背景车辆数') parser.add_argument('--num-pedestrians', type=int, default=6, help='行人数') + parser.add_argument('--num-coop-vehicles', type=int, default=2, help='协同车辆数') # 收集参数 parser.add_argument('--duration', type=int, default=60, help='收集时长(秒)') @@ -702,6 +901,8 @@ def main(): # 传感器参数 parser.add_argument('--enable-lidar', action='store_true', help='启用LiDAR传感器') parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') + parser.add_argument('--enable-v2x', action='store_true', help='启用V2X通信') + parser.add_argument('--enable-cooperative', action='store_true', help='启用协同感知') parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') # 功能参数 @@ -716,21 +917,23 @@ def main(): # 显示配置 print("\n" + "=" * 60) - print("CVIPS 多传感器数据收集系统 v9.0") + print("CVIPS 多车辆协同数据收集系统 v10.0") print("=" * 60) print(f"场景: {config['scenario']['name']}") print(f"地图: {config['scenario']['town']}") print(f"天气/时间: {config['scenario']['weather']}/{config['scenario']['time_of_day']}") print(f"时长: {config['scenario']['duration']}秒") - print(f"交通: {config['traffic']['background_vehicles']}车辆 + {config['traffic']['pedestrians']}行人") + print(f"交通: {config['traffic']['background_vehicles']}背景车辆 + {config['traffic']['pedestrians']}行人") + print(f"协同: {config['cooperative']['num_coop_vehicles']} 协同车辆") print(f"传感器:") print( f" 摄像头: {config['sensors']['vehicle_cameras']}车辆 + {config['sensors']['infrastructure_cameras']}基础设施") print(f" LiDAR: {'启用' if config['sensors']['lidar_sensors'] > 0 else '禁用'}") print(f" 融合: {'启用' if config['output']['save_fusion'] else '禁用'}") - print(f" 标注: {'启用' if config['output']['save_annotations'] else '禁用'}") + print(f" V2X: {'启用' if config['v2x']['enabled'] else '禁用'}") + print(f" 协同: {'启用' if config['output']['save_cooperative'] else '禁用'}") collector = DataCollector(config) diff --git a/src/enhance_pedestrian_safety/multi_vehicle_manager.py b/src/enhance_pedestrian_safety/multi_vehicle_manager.py new file mode 100644 index 0000000000..0f4492829c --- /dev/null +++ b/src/enhance_pedestrian_safety/multi_vehicle_manager.py @@ -0,0 +1,434 @@ +import random +import math +import carla +import time +import json +import os +from collections import defaultdict +from typing import List, Dict, Tuple, Optional +from dataclasses import dataclass, asdict + + +@dataclass +class VehicleState: + """车辆状态信息""" + vehicle_id: int + type_id: str + position: Tuple[float, float, float] + velocity: Tuple[float, float, float] + rotation: Tuple[float, float, float] + timestamp: float + sensors_available: List[str] + + +@dataclass +class V2XMessage: + """V2X通信消息""" + sender_id: int + message_type: str # 'state', 'object', 'warning', 'control' + data: Dict + timestamp: float + ttl: float # 生存时间 + priority: int # 优先级 + + +class MultiVehicleManager: + """多车辆协同管理器""" + + def __init__(self, world, config, output_dir): + self.world = world + self.config = config + self.output_dir = output_dir + + # 创建协同数据目录 + self.coop_dir = os.path.join(output_dir, "cooperative") + os.makedirs(self.coop_dir, exist_ok=True) + os.makedirs(os.path.join(self.coop_dir, "v2x_messages"), exist_ok=True) + os.makedirs(os.path.join(self.coop_dir, "shared_perception"), exist_ok=True) + + # 车辆管理 + self.ego_vehicles = [] # 主车辆列表 + self.cooperative_vehicles = [] # 协同车辆列表 + self.vehicle_states = {} # 车辆ID -> 车辆状态 + self.vehicle_sensors = {} # 车辆ID -> 传感器列表 + + # V2X通信 + self.v2x_messages = [] + self.communication_range = config.get('v2x', {}).get('communication_range', 300.0) # 通信范围 + self.message_buffer = defaultdict(list) # 车辆ID -> 接收的消息列表 + + # 协同感知 + self.shared_objects = [] # 共享的感知对象 + self.fusion_results = {} # 融合结果 + + # 统计 + self.stats = { + 'total_messages': 0, + 'successful_transmissions': 0, + 'collaborative_detections': 0, + 'data_exchange_mb': 0.0 + } + + def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor]: + """生成协同车辆""" + blueprint_lib = self.world.get_blueprint_library() + spawn_points = self.world.get_map().get_spawn_points() + + if not spawn_points: + print("警告:无生成点") + return [] + + # 车辆类型 + vehicle_types = [ + 'vehicle.tesla.model3', + 'vehicle.audi.tt', + 'vehicle.nissan.patrol', + 'vehicle.bmw.grandtourer', + 'vehicle.mercedes.coupe' + ] + + spawned_vehicles = [] + + for i in range(min(num_vehicles, len(spawn_points))): + try: + # 选择车辆类型 + vtype = random.choice(vehicle_types) + vehicle_bp = random.choice(blueprint_lib.filter(vtype)) + + # 设置车辆属性 + vehicle_bp.set_attribute('role_name', f'coop_vehicle_{i}') + + # 选择生成点 + spawn_point = spawn_points[i % len(spawn_points)] + + # 调整位置,使车辆不在同一位置 + offset_x = random.uniform(-5.0, 5.0) + offset_y = random.uniform(-5.0, 5.0) + location = carla.Location( + x=spawn_point.location.x + offset_x, + y=spawn_point.location.y + offset_y, + z=spawn_point.location.z + ) + + # 轻微调整朝向 + rotation = carla.Rotation( + pitch=spawn_point.rotation.pitch, + yaw=spawn_point.rotation.yaw + random.uniform(-15, 15), + roll=spawn_point.rotation.roll + ) + + transform = carla.Transform(location, rotation) + + # 生成车辆 + vehicle = self.world.spawn_actor(vehicle_bp, transform) + + # 设置自动驾驶 + vehicle.set_autopilot(True) + + # 添加到列表 + self.cooperative_vehicles.append(vehicle) + spawned_vehicles.append(vehicle) + + # 初始化车辆状态 + self.vehicle_states[vehicle.id] = VehicleState( + vehicle_id=vehicle.id, + type_id=vehicle.type_id, + position=(0, 0, 0), + velocity=(0, 0, 0), + rotation=(0, 0, 0), + timestamp=time.time(), + sensors_available=[] + ) + + print(f"协同车辆 {i + 1} 生成: {vehicle.type_id}") + + except Exception as e: + print(f"生成协同车辆失败: {e}") + + return spawned_vehicles + + def update_vehicle_states(self): + """更新所有车辆状态""" + current_time = time.time() + + for vehicle in self.ego_vehicles + self.cooperative_vehicles: + try: + if vehicle.is_alive: + location = vehicle.get_location() + velocity = vehicle.get_velocity() + rotation = vehicle.get_transform().rotation + + self.vehicle_states[vehicle.id] = VehicleState( + vehicle_id=vehicle.id, + type_id=vehicle.type_id, + position=(location.x, location.y, location.z), + velocity=(velocity.x, velocity.y, velocity.z), + rotation=(rotation.pitch, rotation.yaw, rotation.roll), + timestamp=current_time, + sensors_available=self.vehicle_sensors.get(vehicle.id, []) + ) + except: + pass + + def create_v2x_message(self, sender_id: int, message_type: str, data: Dict, + priority: int = 1) -> V2XMessage: + """创建V2X消息""" + message = V2XMessage( + sender_id=sender_id, + message_type=message_type, + data=data, + timestamp=time.time(), + ttl=5.0, # 5秒生存时间 + priority=priority + ) + + self.v2x_messages.append(message) + self.stats['total_messages'] += 1 + + return message + + def broadcast_message(self, message: V2XMessage): + """广播消息给范围内的车辆""" + if message.sender_id not in self.vehicle_states: + return + + sender_state = self.vehicle_states[message.sender_id] + sender_pos = sender_state.position + + recipients = [] + + # 检查所有车辆是否在通信范围内 + for vehicle in self.ego_vehicles + self.cooperative_vehicles: + if vehicle.id != message.sender_id and vehicle.id in self.vehicle_states: + receiver_state = self.vehicle_states[vehicle.id] + receiver_pos = receiver_state.position + + # 计算距离 + distance = math.sqrt( + (sender_pos[0] - receiver_pos[0]) ** 2 + + (sender_pos[1] - receiver_pos[1]) ** 2 + + (sender_pos[2] - receiver_pos[2]) ** 2 + ) + + if distance <= self.communication_range: + recipients.append(vehicle.id) + + # 添加到接收者消息缓冲区 + self.message_buffer[vehicle.id].append({ + 'message': message, + 'receive_time': time.time(), + 'signal_strength': 1.0 - (distance / self.communication_range) + }) + + self.stats['successful_transmissions'] += len(recipients) + + # 保存消息 + self._save_v2x_message(message, recipients) + + return recipients + + def share_perception_data(self, vehicle_id: int, detected_objects: List[Dict]): + """共享感知数据""" + if not detected_objects: + return + + # 创建感知消息 + perception_data = { + 'vehicle_id': vehicle_id, + 'timestamp': time.time(), + 'objects': detected_objects, + 'vehicle_state': asdict( + self.vehicle_states.get(vehicle_id, VehicleState(0, '', (0, 0, 0), (0, 0, 0), (0, 0, 0), 0, []))) + } + + message = self.create_v2x_message( + vehicle_id, + 'perception', + perception_data, + priority=2 # 感知数据优先级较高 + ) + + # 广播消息 + recipients = self.broadcast_message(message) + + # 融合共享的感知数据 + if recipients: + self._fuse_shared_perception(vehicle_id, detected_objects, recipients) + + return message + + def share_traffic_warning(self, vehicle_id: int, warning_type: str, + location: Tuple[float, float, float], + severity: str = 'medium'): + """共享交通警告""" + warning_data = { + 'warning_type': warning_type, # 'accident', 'congestion', 'hazard', 'construction' + 'location': location, + 'severity': severity, + 'timestamp': time.time(), + 'source_vehicle': vehicle_id + } + + message = self.create_v2x_message( + vehicle_id, + 'warning', + warning_data, + priority=3 # 警告消息优先级最高 + ) + + self.broadcast_message(message) + + return message + + def _fuse_shared_perception(self, source_id: int, objects: List[Dict], recipients: List[int]): + """融合共享的感知数据""" + fused_objects = [] + + for obj in objects: + # 转换为全局坐标系(简化处理,实际需要坐标变换) + global_obj = obj.copy() + global_obj['source_vehicles'] = [source_id] + global_obj['confidence'] = obj.get('confidence', 0.8) # 降低置信度 + + # 检查是否已有类似对象 + matched = False + for existing_obj in self.shared_objects: + # 简单的对象匹配(基于位置) + if self._objects_match(global_obj, existing_obj): + # 更新现有对象 + existing_obj['source_vehicles'].append(source_id) + existing_obj['confidence'] = min(1.0, existing_obj.get('confidence', 0) + 0.1) + existing_obj['update_time'] = time.time() + matched = True + break + + if not matched: + global_obj['detection_time'] = time.time() + fused_objects.append(global_obj) + + self.shared_objects.extend(fused_objects) + + # 清理旧对象 + current_time = time.time() + self.shared_objects = [ + obj for obj in self.shared_objects + if current_time - obj.get('detection_time', 0) < 10.0 # 保留10秒内的对象 + ] + + if fused_objects: + self.stats['collaborative_detections'] += len(fused_objects) + + def _objects_match(self, obj1: Dict, obj2: Dict, distance_threshold: float = 5.0) -> bool: + """判断两个对象是否匹配""" + if obj1.get('class') != obj2.get('class'): + return False + + # 计算位置距离 + pos1 = obj1.get('position', {'x': 0, 'y': 0, 'z': 0}) + pos2 = obj2.get('position', {'x': 0, 'y': 0, 'z': 0}) + + distance = math.sqrt( + (pos1['x'] - pos2['x']) ** 2 + + (pos1['y'] - pos2['y']) ** 2 + + (pos1['z'] - pos2['z']) ** 2 + ) + + return distance < distance_threshold + + def get_shared_perception_for_vehicle(self, vehicle_id: int) -> List[Dict]: + """获取车辆可用的共享感知数据""" + shared_data = [] + + for obj in self.shared_objects: + # 检查对象是否在车辆视野内(简化) + shared_data.append(obj) + + return shared_data + + def coordinate_maneuvers(self, maneuvers: List[Dict]): + """协调多车辆机动""" + # 分配优先级和时序 + coordinated = [] + + for i, maneuver in enumerate(maneuvers): + coordinated_maneuver = maneuver.copy() + coordinated_maneuver['sequence'] = i + coordinated_maneuver['start_time'] = time.time() + i * 2.0 # 间隔2秒 + coordinated.append(coordinated_maneuver) + + # 发送协调消息 + message = self.create_v2x_message( + maneuver.get('vehicle_id', 0), + 'coordination', + coordinated_maneuver, + priority=2 + ) + + self.broadcast_message(message) + + return coordinated + + def _save_v2x_message(self, message: V2XMessage, recipients: List[int]): + """保存V2X消息到文件""" + message_data = { + 'message': asdict(message), + 'recipients': recipients, + 'transmission_time': time.time() + } + + filename = f"v2x_{int(time.time() * 1000)}_{message.sender_id}_{message.message_type}.json" + filepath = os.path.join(self.coop_dir, "v2x_messages", filename) + + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(message_data, f, indent=2, ensure_ascii=False) + + def save_shared_perception(self, frame_num: int): + """保存共享感知数据""" + data = { + 'frame_id': frame_num, + 'timestamp': time.time(), + 'shared_objects': self.shared_objects, + 'active_vehicles': len(self.ego_vehicles + self.cooperative_vehicles), + 'stats': self.stats + } + + filepath = os.path.join(self.coop_dir, "shared_perception", f"frame_{frame_num:06d}.json") + + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + + def generate_summary(self): + """生成协同摘要报告""" + summary = { + 'total_vehicles': len(self.ego_vehicles) + len(self.cooperative_vehicles), + 'ego_vehicles': len(self.ego_vehicles), + 'cooperative_vehicles': len(self.cooperative_vehicles), + 'v2x_stats': self.stats, + 'shared_objects_count': len(self.shared_objects), + 'communication_range': self.communication_range, + 'average_messages_per_vehicle': self.stats['total_messages'] / max(1, len(self.ego_vehicles) + len( + self.cooperative_vehicles)) + } + + filepath = os.path.join(self.coop_dir, "cooperative_summary.json") + + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(summary, f, indent=2, ensure_ascii=False) + + return summary + + def cleanup(self): + """清理资源""" + print("清理协同车辆...") + + for vehicle in self.cooperative_vehicles: + try: + if vehicle.is_alive: + vehicle.destroy() + except: + pass + + self.cooperative_vehicles.clear() + self.ego_vehicles.clear() + self.vehicle_states.clear() + self.message_buffer.clear() \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/v2x_communication.py b/src/enhance_pedestrian_safety/v2x_communication.py new file mode 100644 index 0000000000..63079cc46a --- /dev/null +++ b/src/enhance_pedestrian_safety/v2x_communication.py @@ -0,0 +1,328 @@ +import socket +import threading +import json +import time +import struct +import numpy as np +from typing import Dict, List, Any, Optional +from dataclasses import dataclass, asdict +import queue + + +@dataclass +class V2XMessage: + """V2X通信消息""" + message_id: str + sender_id: str + message_type: str # 'bsm', 'spat', 'map', 'rsm', 'rsa' + data: Dict[str, Any] + timestamp: float + ttl: float + priority: int + position: Optional[tuple] = None + + +class V2XCommunication: + """V2X通信模拟器""" + + def __init__(self, config: Dict): + self.config = config + self.enabled = config.get('enabled', True) + + # 通信参数 + self.communication_range = config.get('communication_range', 300.0) # 通信范围(米) + self.bandwidth = config.get('bandwidth', 10.0) # 带宽(Mbps) + self.latency_mean = config.get('latency_mean', 0.05) # 平均延迟(秒) + self.latency_std = config.get('latency_std', 0.01) # 延迟标准差 + self.packet_loss_rate = config.get('packet_loss_rate', 0.01) # 丢包率 + + # 消息管理 + self.message_queue = queue.PriorityQueue() + self.received_messages = [] + self.message_counter = 0 + + # 网络模拟 + self.network_nodes = {} # 节点ID -> 节点信息 + self.connections = {} # 连接状态 + + # 统计信息 + self.stats = { + 'messages_sent': 0, + 'messages_received': 0, + 'messages_dropped': 0, + 'total_latency': 0.0, + 'bandwidth_used': 0.0 + } + + # 启动消息处理线程 + if self.enabled: + self.running = True + self.processor_thread = threading.Thread(target=self._message_processor, daemon=True) + self.processor_thread.start() + + def register_node(self, node_id: str, position: tuple, capabilities: Dict): + """注册网络节点(车辆)""" + self.network_nodes[node_id] = { + 'position': position, + 'capabilities': capabilities, + 'last_seen': time.time(), + 'status': 'online' + } + + def unregister_node(self, node_id: str): + """注销网络节点""" + if node_id in self.network_nodes: + del self.network_nodes[node_id] + + def send_message(self, message: V2XMessage) -> bool: + """发送V2X消息""" + if not self.enabled: + return False + + # 模拟网络延迟和丢包 + if np.random.random() < self.packet_loss_rate: + self.stats['messages_dropped'] += 1 + return False + + # 添加延迟 + latency = np.random.normal(self.latency_mean, self.latency_std) + delivery_time = time.time() + max(0, latency) + + # 添加到消息队列(按优先级和发送时间排序) + priority = -message.priority # 负号因为PriorityQueue是小顶堆 + self.message_queue.put((priority, delivery_time, message)) + + self.stats['messages_sent'] += 1 + self.stats['total_latency'] += latency + + return True + + def broadcast_basic_safety_message(self, node_id: str, vehicle_data: Dict) -> Optional[V2XMessage]: + """广播基本安全消息(BSM)""" + bsm_data = { + 'msgCnt': self.message_counter % 128, + 'id': node_id, + 'secMark': int(time.time() * 1000) % 60000, + 'position': vehicle_data.get('position', (0, 0, 0)), + 'accuracy': vehicle_data.get('accuracy', {'semiMajor': 1.0, 'semiMinor': 1.0}), + 'transmissionAndSpeed': { + 'transmission': vehicle_data.get('transmission', 'automatic'), + 'speed': vehicle_data.get('speed', 0.0) + }, + 'heading': vehicle_data.get('heading', 0.0), + 'steeringWheelAngle': vehicle_data.get('steering_wheel_angle', 0.0), + 'accelerationSet4Way': vehicle_data.get('acceleration', {'long': 0, 'lat': 0, 'vert': 0, 'yaw': 0}), + 'brakeSystemStatus': vehicle_data.get('brake_status', {'wheelBrakes': '00000'}), + 'vehicleSize': vehicle_data.get('size', {'width': 1.8, 'length': 4.5}) + } + + message = V2XMessage( + message_id=f"bsm_{node_id}_{self.message_counter}", + sender_id=node_id, + message_type='bsm', + data=bsm_data, + timestamp=time.time(), + ttl=1.0, + priority=1, + position=vehicle_data.get('position') + ) + + self.message_counter += 1 + + if self.send_message(message): + return message + + return None + + def broadcast_signal_phase_and_timing(self, intersection_id: str, spat_data: Dict) -> Optional[V2XMessage]: + """广播信号相位和时序消息(SPaT)""" + message = V2XMessage( + message_id=f"spat_{intersection_id}_{self.message_counter}", + sender_id=intersection_id, + message_type='spat', + data=spat_data, + timestamp=time.time(), + ttl=5.0, + priority=2, + position=spat_data.get('intersection_position') + ) + + self.message_counter += 1 + + if self.send_message(message): + return message + + return None + + def broadcast_map_data(self, map_id: str, map_data: Dict) -> Optional[V2XMessage]: + """广播地图数据(MAP)""" + message = V2XMessage( + message_id=f"map_{map_id}_{self.message_counter}", + sender_id=map_id, + message_type='map', + data=map_data, + timestamp=time.time(), + ttl=30.0, # 地图数据TTL较长 + priority=1, + position=map_data.get('reference_point') + ) + + self.message_counter += 1 + + if self.send_message(message): + return message + + return None + + def broadcast_roadside_safety_message(self, rsu_id: str, warning_data: Dict) -> Optional[V2XMessage]: + """广播路侧安全消息(RSM/RSA)""" + message = V2XMessage( + message_id=f"rsm_{rsu_id}_{self.message_counter}", + sender_id=rsu_id, + message_type='rsm', + data=warning_data, + timestamp=time.time(), + ttl=3.0, + priority=3, # 安全消息优先级高 + position=warning_data.get('event_position') + ) + + self.message_counter += 1 + + if self.send_message(message): + return message + + return None + + def get_reachable_nodes(self, sender_id: str, sender_position: tuple) -> List[str]: + """获取可达的网络节点""" + reachable = [] + + for node_id, node_info in self.network_nodes.items(): + if node_id == sender_id: + continue + + # 计算距离 + distance = self._calculate_distance(sender_position, node_info['position']) + + if distance <= self.communication_range: + # 模拟信号衰减 + signal_strength = 1.0 - (distance / self.communication_range) + if signal_strength > 0.3: # 最小信号强度阈值 + reachable.append(node_id) + + return reachable + + def _calculate_distance(self, pos1: tuple, pos2: tuple) -> float: + """计算两点间距离""" + if not pos1 or not pos2: + return float('inf') + + return np.sqrt( + (pos1[0] - pos2[0]) ** 2 + + (pos1[1] - pos2[1]) ** 2 + + (pos1[2] - pos2[2]) ** 2 + ) + + def _message_processor(self): + """消息处理线程""" + while self.running: + try: + # 获取下一个要传递的消息 + if not self.message_queue.empty(): + priority, delivery_time, message = self.message_queue.get_nowait() + + current_time = time.time() + + if current_time >= delivery_time: + # 消息已到传递时间 + self._deliver_message(message) + else: + # 重新放回队列 + self.message_queue.put((priority, delivery_time, message)) + time.sleep(0.001) # 短暂休眠 + else: + time.sleep(0.01) + + except queue.Empty: + time.sleep(0.01) + except Exception as e: + print(f"消息处理器错误: {e}") + + def _deliver_message(self, message: V2XMessage): + """传递消息到接收者""" + if not message.position: + return + + # 获取可达节点 + reachable_nodes = self.get_reachable_nodes(message.sender_id, message.position) + + # 模拟带宽限制 + message_size = len(json.dumps(asdict(message)).encode('utf-8')) / 1024 / 1024 # MB + bandwidth_required = message_size * 8 * len(reachable_nodes) # Mbps + + if bandwidth_required > self.bandwidth * 0.8: # 带宽超过80%时随机丢包 + drop_probability = min(1.0, bandwidth_required / self.bandwidth - 0.8) + reachable_nodes = [n for n in reachable_nodes if np.random.random() > drop_probability] + + # 添加到接收消息列表 + for node_id in reachable_nodes: + received_msg = { + 'message': asdict(message), + 'receiver_id': node_id, + 'receive_time': time.time(), + 'signal_strength': 1.0 - (self._calculate_distance(message.position, self.network_nodes[node_id][ + 'position']) / self.communication_range) + } + + self.received_messages.append(received_msg) + self.stats['messages_received'] += 1 + + # 更新带宽使用统计 + self.stats['bandwidth_used'] += bandwidth_required + + def get_messages_for_node(self, node_id: str, message_types: List[str] = None) -> List[Dict]: + """获取指定节点的消息""" + messages = [] + + for msg_record in self.received_messages: + if msg_record['receiver_id'] == node_id: + message = msg_record['message'] + if not message_types or message['message_type'] in message_types: + messages.append(msg_record) + + # 清理已处理的消息 + self.received_messages = [ + msg for msg in self.received_messages + if msg['receiver_id'] != node_id or + (message_types and msg['message']['message_type'] not in message_types) + ] + + return messages + + def get_network_status(self) -> Dict: + """获取网络状态""" + return { + 'active_nodes': len(self.network_nodes), + 'stats': self.stats, + 'bandwidth_utilization': (self.stats['bandwidth_used'] / ( + self.bandwidth * time.time())) * 100 if time.time() > 0 else 0, + 'message_delivery_rate': self.stats['messages_received'] / max(1, self.stats['messages_sent']), + 'average_latency': self.stats['total_latency'] / max(1, self.stats['messages_sent']) + } + + def reset_stats(self): + """重置统计信息""" + self.stats = { + 'messages_sent': 0, + 'messages_received': 0, + 'messages_dropped': 0, + 'total_latency': 0.0, + 'bandwidth_used': 0.0 + } + + def stop(self): + """停止通信模拟""" + self.running = False + if hasattr(self, 'processor_thread'): + self.processor_thread.join(timeout=1.0) \ No newline at end of file From 7eee0e6d09b99b9d609b1f8ac1fbd519cbe9c947 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Fri, 19 Dec 2025 10:15:15 +0800 Subject: [PATCH 03/21] =?UTF-8?q?=E4=BC=A0=E6=84=9F=E5=99=A8=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E5=A2=9E=E5=BC=BA=E5=92=8C=E5=A4=9A=E5=A4=A9=E6=B0=94?= =?UTF-8?q?=E6=A8=A1=E6=8B=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 32 +- .../data_analyzer.py | 83 -- .../data_validator.py | 53 -- src/enhance_pedestrian_safety/main.py | 384 +++++---- .../sensor_enhancer.py | 784 ++++++++++++++++++ 5 files changed, 1006 insertions(+), 330 deletions(-) create mode 100644 src/enhance_pedestrian_safety/sensor_enhancer.py diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 9e80f69f2d..54477406ba 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -36,7 +36,6 @@ def load_config(config_file=None): 'rotation_frequency': 10 } }, - 'v2x': { 'enabled': True, 'communication_range': 300.0, @@ -54,8 +53,15 @@ def load_config(config_file=None): 'data_fusion_interval': 1.0, 'max_shared_objects': 50 }, - - + 'enhancement': { + 'enabled': True, + 'enable_random': True, + 'quality_check': True, + 'save_original': True, + 'save_enhanced': True, + 'calibration_generation': True, + 'enhanced_dir_name': 'enhanced' + }, 'output': { 'data_dir': 'cvips_dataset', 'save_raw': True, @@ -63,13 +69,12 @@ def load_config(config_file=None): 'save_annotations': False, 'save_lidar': True, 'save_fusion': True, - 'save_cooperative': True, 'save_v2x_messages': True, - - + 'save_enhanced': True, 'validate_data': True, - 'run_analysis': False + 'run_analysis': False, + 'run_quality_check': True } } @@ -111,7 +116,6 @@ def merge_args(config, args): if args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians - if args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles @@ -121,10 +125,8 @@ def merge_args(config, args): if args.enable_v2x: config['v2x']['enabled'] = True - - if args.capture_interval: - config['sensors']['capture_interval'] = args.capture_interval - + if args.enable_enhancement: + config['enhancement']['enabled'] = True if args.enable_lidar: config['sensors']['lidar_sensors'] = 1 @@ -133,18 +135,18 @@ def merge_args(config, args): if args.enable_fusion: config['output']['save_fusion'] = True - if args.enable_cooperative: config['output']['save_cooperative'] = True - - if args.enable_annotations: config['output']['save_annotations'] = True if args.skip_validation: config['output']['validate_data'] = False + if args.skip_quality_check: + config['output']['run_quality_check'] = False + if args.run_analysis: config['output']['run_analysis'] = True diff --git a/src/enhance_pedestrian_safety/data_analyzer.py b/src/enhance_pedestrian_safety/data_analyzer.py index f805fe2fcb..069d6d2ec7 100644 --- a/src/enhance_pedestrian_safety/data_analyzer.py +++ b/src/enhance_pedestrian_safety/data_analyzer.py @@ -17,10 +17,7 @@ def analyze_dataset(data_dir): 'file_distribution': DataAnalyzer._analyze_file_distribution(data_dir), 'object_statistics': DataAnalyzer._analyze_objects(data_dir), 'temporal_analysis': DataAnalyzer._analyze_temporal(data_dir), - 'cooperative_data': DataAnalyzer._analyze_cooperative_data(data_dir), - - 'quality_metrics': DataAnalyzer._calculate_quality_metrics(data_dir) } @@ -81,7 +78,6 @@ def _analyze_file_distribution(data_dir): distribution = {} # 分析原始图像 - raw_dirs = [] raw_path = os.path.join(data_dir, "raw") if os.path.exists(raw_path): @@ -98,20 +94,6 @@ def _analyze_file_distribution(data_dir): camera_stats[camera_dir] = len(images) distribution[f'raw_{raw_dir}'] = camera_stats - raw_dirs = ['vehicle', 'infrastructure'] - for raw_dir in raw_dirs: - path = os.path.join(data_dir, "raw", raw_dir) - if os.path.exists(path): - camera_stats = {} - for camera_dir in os.listdir(path): - camera_path = os.path.join(path, camera_dir) - if os.path.isdir(camera_path): - images = [f for f in os.listdir(camera_path) - if f.endswith(('.png', '.jpg', '.jpeg'))] - camera_stats[camera_dir] = len(images) - distribution[f'raw_{raw_dir}'] = camera_stats - - # 分析拼接图像 stitched_dir = os.path.join(data_dir, "stitched") if os.path.exists(stitched_dir): @@ -125,7 +107,6 @@ def _analyze_file_distribution(data_dir): json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] distribution['annotations'] = len(json_files) - # 分析LiDAR数据 lidar_dir = os.path.join(data_dir, "lidar") if os.path.exists(lidar_dir): @@ -139,8 +120,6 @@ def _analyze_file_distribution(data_dir): json_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] distribution['fusion'] = len(json_files) - - return distribution @staticmethod @@ -149,12 +128,8 @@ def _analyze_objects(data_dir): annotations_dir = os.path.join(data_dir, "annotations") if not os.path.exists(annotations_dir): - return {'total_objects': 0, 'by_class': {}, 'by_frame': {}, 'class_distribution': {}} - return {'total_objects': 0, 'by_class': {}, 'by_frame': {}} - - object_stats = { 'total_objects': 0, 'by_class': defaultdict(int), @@ -216,7 +191,6 @@ def _analyze_temporal(data_dir): return temporal_stats @staticmethod - def _analyze_cooperative_data(data_dir): """分析协同数据""" coop_dir = os.path.join(data_dir, "cooperative") @@ -289,45 +263,28 @@ def _analyze_cooperative_data(data_dir): return analysis @staticmethod - - def _calculate_quality_metrics(data_dir): """计算质量指标""" quality_metrics = { 'completeness_score': 0, 'consistency_score': 0, 'diversity_score': 0, - 'cooperative_score': 0, - - 'issues_found': [] } # 检查完整性 - required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata", "cooperative"] missing_dirs = [] for dir_path in required_dirs: full_path = os.path.join(data_dir, dir_path) if not os.path.exists(full_path): - - required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata"] - missing_dirs = [] - - for dir_path in required_dirs: - if not os.path.exists(os.path.join(data_dir, dir_path)): - missing_dirs.append(dir_path) if missing_dirs: quality_metrics['issues_found'].append(f"缺失目录: {missing_dirs}") - quality_metrics['completeness_score'] = 100 - (len(missing_dirs) * 20) - - quality_metrics['completeness_score'] = 50 - else: quality_metrics['completeness_score'] = 100 @@ -343,11 +300,7 @@ def _calculate_quality_metrics(data_dir): camera_counts.append(len(images)) if camera_counts: - max_diff = max(camera_counts) - min(camera_counts) if camera_counts else 0 - - max_diff = max(camera_counts) - min(camera_counts) - if max_diff > 5: quality_metrics['issues_found'].append(f"摄像头图像数量不一致: 差异{max_diff}") quality_metrics['consistency_score'] = 70 @@ -366,7 +319,6 @@ def _calculate_quality_metrics(data_dir): quality_metrics['diversity_score'] = 50 quality_metrics['issues_found'].append(f"物体类别较少: {num_classes}类") - # 协同评分 cooperative_data = DataAnalyzer._analyze_cooperative_data(data_dir) if cooperative_data['v2x_messages'] > 10 and cooperative_data['shared_perception_frames'] > 5: @@ -377,26 +329,17 @@ def _calculate_quality_metrics(data_dir): quality_metrics['cooperative_score'] = 30 quality_metrics['issues_found'].append("协同数据较少") - - return quality_metrics @staticmethod def _calculate_overall_score(analysis): """计算总体评分""" weights = { - 'completeness': 0.25, 'consistency': 0.20, 'diversity': 0.15, 'cooperative': 0.20, 'temporal': 0.20 - - 'completeness': 0.3, - 'consistency': 0.25, - 'diversity': 0.25, - 'temporal': 0.2 - } quality = analysis['quality_metrics'] @@ -404,12 +347,8 @@ def _calculate_overall_score(analysis): score = ( quality['completeness_score'] * weights['completeness'] + quality['consistency_score'] * weights['consistency'] + - quality['diversity_score'] * weights['diversity'] + quality['cooperative_score'] * weights['cooperative'] - - quality['diversity_score'] * weights['diversity'] - ) # 时间因素 @@ -421,12 +360,8 @@ def _calculate_overall_score(analysis): else: score += 5 * weights['temporal'] - return round(min(score, 100), 1) - return round(score, 1) - - @staticmethod def _save_analysis_report(data_dir, analysis): """保存分析报告""" @@ -460,15 +395,11 @@ def _print_analysis_summary(analysis): if isinstance(value, dict): print(f" {key}:") for subkey, subvalue in value.items(): - if isinstance(subvalue, dict): for subsubkey, subsubvalue in subvalue.items(): print(f" {subsubkey}: {subsubvalue}") else: print(f" {subkey}: {subvalue}") - - print(f" {subkey}: {subvalue}") - else: print(f" {key}: {value}") @@ -481,7 +412,6 @@ def _print_analysis_summary(analysis): percentage = objects['class_distribution'].get(obj_class, 0) print(f" {obj_class}: {count} ({percentage}%)") - # 协同数据分析 cooperative = analysis['cooperative_data'] print(f"\n协同数据分析:") @@ -498,8 +428,6 @@ def _print_analysis_summary(analysis): for msg_type, count in cooperative['v2x_stats']['message_types'].items(): print(f" {msg_type}: {count}") - - temporal = analysis['temporal_analysis'] print(f"\n时间分析:") print(f" 总时长: {temporal['total_duration']:.1f}秒") @@ -510,11 +438,8 @@ def _print_analysis_summary(analysis): print(f" 完整性: {quality['completeness_score']}/100") print(f" 一致性: {quality['consistency_score']}/100") print(f" 多样性: {quality['diversity_score']}/100") - print(f" 协同性: {quality['cooperative_score']}/100") - - if quality['issues_found']: print(f" 发现的问题 ({len(quality['issues_found'])}):") for issue in quality['issues_found'][:3]: @@ -524,20 +449,12 @@ def _print_analysis_summary(analysis): print(f"\n总体评分: {analysis['overall_score']}/100") - overall_score = analysis['overall_score'] if overall_score >= 90: print("✓ 数据集质量优秀") elif overall_score >= 75: print("✓ 数据集质量良好") elif overall_score >= 60: - - if analysis['overall_score'] >= 90: - print("✓ 数据集质量优秀") - elif analysis['overall_score'] >= 75: - print("✓ 数据集质量良好") - elif analysis['overall_score'] >= 60: - print("⚠ 数据集质量一般") else: print("✗ 数据集质量需要改进") diff --git a/src/enhance_pedestrian_safety/data_validator.py b/src/enhance_pedestrian_safety/data_validator.py index 80c65d52f9..fa67f6425b 100644 --- a/src/enhance_pedestrian_safety/data_validator.py +++ b/src/enhance_pedestrian_safety/data_validator.py @@ -14,13 +14,9 @@ def validate_dataset(data_dir): 'stitched_images': DataValidator._validate_stitched_images(data_dir), 'annotations': DataValidator._validate_annotations(data_dir), 'metadata': DataValidator._validate_metadata(data_dir), - 'lidar_data': DataValidator._validate_lidar_data(data_dir), 'cooperative_data': DataValidator._validate_cooperative_data(data_dir), 'fusion_data': DataValidator._validate_fusion_data(data_dir) - - 'lidar_data': DataValidator._validate_lidar_data(data_dir) - } validation_results['overall_score'] = DataValidator._calculate_score(validation_results) @@ -36,15 +32,11 @@ def _check_directory_structure(data_dir): "raw/vehicle", "raw/infrastructure", "stitched", - "metadata", "cooperative", "cooperative/v2x_messages", "cooperative/shared_perception", "fusion" - - "metadata" - ] missing_dirs = [] @@ -65,7 +57,6 @@ def _check_directory_structure(data_dir): @staticmethod def _validate_raw_images(data_dir): - raw_path = os.path.join(data_dir, "raw") if not os.path.exists(raw_path): @@ -73,20 +64,11 @@ def _validate_raw_images(data_dir): 'infrastructure': {'status': 'MISSING', 'count': 0, 'errors': []}} raw_dirs = [d for d in os.listdir(raw_path) if os.path.isdir(os.path.join(raw_path, d))] - - raw_dirs = ["vehicle", "infrastructure"] - results = {} for raw_dir in raw_dirs: path = os.path.join(data_dir, "raw", raw_dir) - - if not os.path.exists(path): - results[raw_dir] = {'status': 'MISSING', 'count': 0, 'errors': []} - continue - - camera_dirs = [] if os.path.exists(path): camera_dirs = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))] @@ -171,15 +153,12 @@ def _validate_annotations(data_dir): with open(json_path, 'r') as f: data = json.load(f) - # 检查基本结构 required_keys = ['frame_id', 'objects'] for key in required_keys: if key not in data: errors.append(f"缺失必要键: {key} in {json_file}") - - valid_files += 1 except Exception as e: errors.append(f"无效的JSON文件: {json_file} - {str(e)}") @@ -238,32 +217,22 @@ def _validate_lidar_data(data_dir): return {'status': 'MISSING', 'count': 0, 'errors': []} bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] - npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] json_files = [f for f in os.listdir(lidar_dir) if f.endswith('.json')] errors = [] valid_bin_files = 0 - errors = [] - valid_files = 0 - - for bin_file in bin_files: bin_path = os.path.join(lidar_dir, bin_file) try: if os.path.getsize(bin_path) > 0: - valid_bin_files += 1 - - valid_files += 1 - else: errors.append(f"空文件: {bin_file}") except: errors.append(f"文件访问失败: {bin_file}") - total_files = len(bin_files) + len(npy_files) + len(json_files) if len(errors) == 0 and valid_bin_files > 0: @@ -394,8 +363,6 @@ def _validate_fusion_data(data_dir): except Exception as e: errors.append(f"融合文件无效: {json_file} - {str(e)}") - - if len(errors) == 0 and valid_files > 0: status = 'PASS' elif len(errors) < 3 and valid_files > 0: @@ -405,18 +372,13 @@ def _validate_fusion_data(data_dir): return { 'status': status, - 'count': len(json_files), - - 'count': valid_files, - 'errors': errors } @staticmethod def _calculate_score(results): weights = { - 'directory_structure': 0.10, 'raw_images': 0.20, 'stitched_images': 0.10, @@ -425,14 +387,6 @@ def _calculate_score(results): 'lidar_data': 0.15, 'cooperative_data': 0.15, 'fusion_data': 0.10 - - 'directory_structure': 0.15, - 'raw_images': 0.25, - 'stitched_images': 0.15, - 'annotations': 0.1, - 'metadata': 0.15, - 'lidar_data': 0.2 - } score = 0 @@ -477,19 +431,14 @@ def _print_validation_report(results): print(f"\n{key.replace('_', ' ').title()}:") if 'status' in result: - status_icon = '✓' if result['status'] == 'PASS' else '⚠' if result['status'] == 'WARNING' else '✗' print(f" 状态: {status_icon} {result['status']}") - - print(f" 状态: {result['status']}") - else: print(f" 状态: 未知") if 'count' in result: print(f" 数量: {result['count']}") - # 特定类型数据的额外信息 if key == 'raw_images' and isinstance(result, dict): for subkey, subresult in result.items(): @@ -510,8 +459,6 @@ def _print_validation_report(results): if 'json_files' in result: print(f" JSON文件: {result['json_files']}") - - if 'errors' in result and result['errors']: print(f" 错误 ({len(result['errors'])}):") for error in result['errors'][:3]: diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index bd8376d1a8..b6f4c384c5 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -7,6 +7,8 @@ import math import threading import json +import cv2 +import numpy as np from datetime import datetime from carla_utils import setup_carla_path, import_carla_module @@ -16,11 +18,9 @@ from scene_manager import SceneManager from data_analyzer import DataAnalyzer from lidar_processor import LidarProcessor, MultiSensorFusion - from multi_vehicle_manager import MultiVehicleManager from v2x_communication import V2XCommunication - - +from sensor_enhancer import SensorDataEnhancer, SensorCalibrator, DataQualityMonitor carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() @@ -253,29 +253,34 @@ def __init__(self, world, config, data_dir): self.lidar_processor = None self.fusion_manager = None + # 新增:数据增强组件 + self.enhancer = None + self.calibrator = None + self.quality_monitor = None + + if config['enhancement']['enabled']: + self.enhancer = SensorDataEnhancer(config) + self.calibrator = SensorCalibrator(config) + self.quality_monitor = DataQualityMonitor(data_dir) + + # 创建增强数据目录 + enhanced_dir = os.path.join(data_dir, config['enhancement'].get('enhanced_dir_name', 'enhanced')) + os.makedirs(enhanced_dir, exist_ok=True) + if config['sensors'].get('lidar_sensors', 0) > 0: self.lidar_processor = LidarProcessor(data_dir) if config['output'].get('save_fusion', False): self.fusion_manager = MultiSensorFusion(data_dir) - def setup_cameras(self, vehicle, center_location, vehicle_id=0): vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) - - def setup_cameras(self, vehicle, center_location): - vehicle_cams = self._setup_vehicle_cameras(vehicle) - infra_cams = self._setup_infrastructure_cameras(center_location) Log.info(f"摄像头: {vehicle_cams}车辆 + {infra_cams}基础设施") return vehicle_cams + infra_cams - def _setup_vehicle_cameras(self, vehicle, vehicle_id): - - def _setup_vehicle_cameras(self, vehicle): - if not vehicle: return 0 @@ -288,11 +293,7 @@ def _setup_vehicle_cameras(self, vehicle): installed = 0 for cam_name, config_data in camera_configs.items(): - if self._create_camera(cam_name, config_data, vehicle, 'vehicle', vehicle_id): - - if self._create_camera(cam_name, config_data, vehicle, 'vehicle'): - installed += 1 return installed @@ -322,11 +323,7 @@ def _setup_infrastructure_cameras(self, center_location): return installed - def setup_lidar(self, vehicle, vehicle_id=0): - - def setup_lidar(self, vehicle): - if not vehicle or not self.config['sensors'].get('lidar_sensors', 0) > 0: return 0 @@ -341,10 +338,6 @@ def setup_lidar(self, vehicle): lidar_bp.set_attribute('points_per_second', str(lidar_config.get('points_per_second', 56000))) lidar_bp.set_attribute('rotation_frequency', str(lidar_config.get('rotation_frequency', 10))) - - - # 添加更多LiDAR参数 - lidar_bp.set_attribute('upper_fov', '10') lidar_bp.set_attribute('lower_fov', '-20') lidar_bp.set_attribute('horizontal_fov', '360') @@ -362,17 +355,9 @@ def lidar_callback(lidar_data): try: metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) if metadata and self.fusion_manager: - - vehicle_image_path = None - with self.buffer_lock: - if self.vehicle_buffer: - - # 尝试获取最新的车辆图像 vehicle_image_path = None with self.buffer_lock: if self.vehicle_buffer: - # 取第一个摄像头的图像 - for cam_name, img_path in self.vehicle_buffer.items(): if os.path.exists(img_path): vehicle_image_path = img_path @@ -398,11 +383,7 @@ def lidar_callback(lidar_data): print(f"LiDAR安装失败: {e}") return 0 - def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): - - def _create_camera(self, name, config, parent, sensor_type): - try: blueprint = self.world.get_blueprint_library().find('sensor.camera.rgb') @@ -420,7 +401,6 @@ def _create_camera(self, name, config, parent, sensor_type): else: camera = self.world.spawn_actor(blueprint, transform) - # 为不同车辆创建不同目录 if sensor_type == 'vehicle' and vehicle_id > 0: save_dir = os.path.join(self.data_dir, "raw", f"vehicle_{vehicle_id}", name) @@ -430,11 +410,6 @@ def _create_camera(self, name, config, parent, sensor_type): os.makedirs(save_dir, exist_ok=True) callback = self._create_callback(save_dir, name, sensor_type, vehicle_id) - save_dir = os.path.join(self.data_dir, "raw", sensor_type, name) - os.makedirs(save_dir, exist_ok=True) - - callback = self._create_callback(save_dir, name, sensor_type) - camera.listen(callback) self.sensors.append(camera) @@ -444,11 +419,7 @@ def _create_camera(self, name, config, parent, sensor_type): Log.warning(f"创建摄像头 {name} 失败: {e}") return False - def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): - - def _create_callback(self, save_dir, name, sensor_type): - capture_interval = self.config['sensors']['capture_interval'] def callback(image): @@ -458,28 +429,112 @@ def callback(image): self.frame_counter += 1 self.last_capture_time = current_time - filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") - image.save_to_disk(filename, carla.ColorConverter.Raw) + # 原始图像保存路径 + original_filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") + + # 保存原始图像 + image.save_to_disk(original_filename, carla.ColorConverter.Raw) + + # 数据增强处理 + if self.enhancer and self.config['enhancement']['enabled']: + enhanced_image = self._enhance_sensor_data(image, name, sensor_type) + + # 保存增强后的图像 + if self.config['enhancement']['save_enhanced']: + enhanced_dir = os.path.join( + self.data_dir, + self.config['enhancement'].get('enhanced_dir_name', 'enhanced'), + sensor_type, + name + ) + os.makedirs(enhanced_dir, exist_ok=True) + + enhanced_filename = os.path.join( + enhanced_dir, + f"{name}_{self.frame_counter:06d}_enhanced.png" + ) + + # 转换为RGB格式 + img_array = cv2.cvtColor(enhanced_image, cv2.COLOR_RGB2BGR) + cv2.imwrite(enhanced_filename, img_array) + + # 生成增强元数据 + metadata = { + 'frame_id': self.frame_counter, + 'sensor_type': sensor_type, + 'sensor_name': name, + 'vehicle_id': vehicle_id, + 'enhancement_methods': self.enhancer.enhancement_methods, + 'original_path': original_filename, + 'enhanced_path': enhanced_filename, + 'timestamp': datetime.now().isoformat() + } + + # 保存元数据 + meta_filename = enhanced_filename.replace('.png', '_meta.json') + with open(meta_filename, 'w', encoding='utf-8') as f: + json.dump(metadata, f, indent=2, ensure_ascii=False) + + # 质量检查 + if self.quality_monitor and self.config['output']['run_quality_check']: + quality_result = self.quality_monitor.check_image_quality(original_filename) + self.quality_monitor.update_metrics('images', quality_result) + + if not quality_result.get('valid', False): + print(f"⚠ 图像质量问题: {original_filename} - {quality_result.get('error', '')}") with self.buffer_lock: if sensor_type == 'vehicle': - self.vehicle_buffer[name] = filename + self.vehicle_buffer[name] = original_filename if len(self.vehicle_buffer) >= 4: - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, f'vehicle_{vehicle_id}') - - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, 'vehicle') - self.vehicle_buffer.clear() else: - self.infra_buffer[name] = filename + self.infra_buffer[name] = original_filename if len(self.infra_buffer) >= 4: self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') self.infra_buffer.clear() return callback + def _enhance_sensor_data(self, carla_image, name: str, sensor_type: str) -> np.ndarray: + """增强传感器数据""" + # 将CARLA图像转换为numpy数组 + img_array = np.frombuffer(carla_image.raw_data, dtype=np.uint8) + img_array = img_array.reshape((carla_image.height, carla_image.width, 4)) + img_array = img_array[:, :, :3] # 去掉alpha通道 + + # 根据传感器类型应用增强 + if sensor_type == 'camera': + enhanced_image = self.enhancer.enhance_image(img_array, 'camera') + else: + enhanced_image = img_array # 其他传感器暂时不增强 + + return enhanced_image + + def generate_calibration_files(self, vehicle_locations: list, + camera_positions: list): + """生成传感器校准文件""" + if self.calibrator and self.config['enhancement']['calibration_generation']: + self.calibrator.generate_calibration_files( + self.data_dir, + vehicle_locations, + camera_positions + ) + + def generate_enhancement_report(self): + """生成增强报告""" + if self.enhancer: + return self.enhancer.generate_enhancement_report(self.data_dir) + return None + + def generate_quality_report(self): + """生成质量报告""" + if self.quality_monitor: + return self.quality_monitor.generate_quality_report() + return None + def get_frame_count(self): return self.frame_counter @@ -515,24 +570,16 @@ def __init__(self, config): self.config = config self.client = None self.world = None - - self.ego_vehicles = [] # 多个主车 - - self.ego_vehicle = None - + self.ego_vehicles = [] self.scene_center = None self.setup_directories() self.traffic_manager = None - - self.sensor_managers = {} # 车辆ID -> SensorManager + self.sensor_managers = {} self.multi_vehicle_manager = None self.v2x_communication = None - self.sensor_manager = None - - self.start_time = None self.is_running = False self.collected_frames = 0 @@ -547,21 +594,17 @@ def setup_directories(self): ) directories = [ - - "raw/vehicle_1", # 主车1 - "raw/vehicle_2", # 主车2(如果有) - - "raw/vehicle", - + "raw/vehicle_1", + "raw/vehicle_2", "raw/infrastructure", "stitched", "lidar", "fusion", "calibration", - "cooperative", "v2x_messages", - + "enhanced/vehicle", + "enhanced/infrastructure", "metadata" ] @@ -606,7 +649,6 @@ def setup_scene(self): self.traffic_manager = TrafficManager(self.world, self.config) - # 生成多个主车 num_ego_vehicles = min(self.config['cooperative'].get('num_coop_vehicles', 2) + 1, 3) for i in range(num_ego_vehicles): @@ -616,16 +658,11 @@ def setup_scene(self): Log.info(f"主车 {i + 1} 生成: {ego_vehicle.type_id}") if not self.ego_vehicles: - - self.ego_vehicle = self.traffic_manager.spawn_ego_vehicle() - if not self.ego_vehicle: - Log.error("主车生成失败") return False self.traffic_manager.spawn_traffic(self.scene_center) - # 初始化V2X通信 if self.config['v2x']['enabled']: self.v2x_communication = V2XCommunication(self.config['v2x']) @@ -663,13 +700,34 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) + # 在场景设置完成后,如果有传感器管理器,生成校准文件 + if hasattr(self, 'sensor_managers') and self.sensor_managers: + # 获取车辆和相机位置信息 + vehicle_locations = [] + camera_positions = [] + for vehicle in self.ego_vehicles: + location = vehicle.get_location() + vehicle_locations.append({ + 'id': vehicle.id, + 'position': [location.x, location.y, location.z], + 'rotation': [0, 0, 0] + }) + + # 简化:假设相机位置相对于车辆 + camera_positions.append({ + 'translation': [2.0, 0, 1.5], # 相机相对于车辆的位置 + 'rotation': [0, 0, 0] # 相机的旋转 + }) + + # 为每个传感器管理器生成校准文件 + for sensor_manager in self.sensor_managers.values(): + sensor_manager.generate_calibration_files(vehicle_locations, camera_positions) time.sleep(3.0) return True def setup_sensors(self): - # 为每个主车设置传感器 for i, vehicle in enumerate(self.ego_vehicles): sensor_manager = SensorManager(self.world, self.config, self.output_dir) @@ -684,17 +742,6 @@ def setup_sensors(self): self.sensor_managers[vehicle.id] = sensor_manager - self.sensor_manager = SensorManager(self.world, self.config, self.output_dir) - - cameras = self.sensor_manager.setup_cameras(self.ego_vehicle, self.scene_center) - if cameras == 0: - Log.error("没有摄像头安装成功") - return False - - lidars = self.sensor_manager.setup_lidar(self.ego_vehicle) - Log.info(f"传感器: {cameras}摄像头 + {lidars}LiDAR") - - return True def collect_data(self): @@ -705,7 +752,6 @@ def collect_data(self): self.is_running = True last_update = time.time() - last_v2x_update = time.time() last_perception_share = time.time() @@ -714,7 +760,6 @@ def collect_data(self): current_time = time.time() elapsed = current_time - self.start_time - # 更新车辆状态 if self.multi_vehicle_manager: self.multi_vehicle_manager.update_vehicle_states() @@ -740,13 +785,6 @@ def collect_data(self): progress = (elapsed / duration) * 100 Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 总帧数: {total_frames}") - - if current_time - last_update >= 5.0: - frames = self.sensor_manager.get_frame_count() - progress = (elapsed / duration) * 100 - - Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 帧数: {frames}") - last_update = current_time time.sleep(0.05) @@ -757,17 +795,20 @@ def collect_data(self): self.is_running = False elapsed = time.time() - self.start_time - self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") - self.collected_frames = self.sensor_manager.get_frame_count() + # 生成增强报告 + if self.config['enhancement']['enabled']: + self._generate_enhancement_reports() - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + # 生成质量报告 + if self.config['output']['run_quality_check']: + self._generate_quality_reports() self._save_metadata() self._print_summary() - def _update_v2x_communication(self): """更新V2X通信""" if not self.v2x_communication: @@ -848,17 +889,28 @@ def _simulate_object_detection(self, vehicle): return detected_objects + def _generate_enhancement_reports(self): + """生成增强报告""" + Log.info("生成增强报告...") + for sensor_manager in self.sensor_managers.values(): + if hasattr(sensor_manager, 'enhancer'): + sensor_manager.generate_enhancement_report() + + def _generate_quality_reports(self): + """生成质量报告""" + Log.info("生成质量报告...") + for sensor_manager in self.sensor_managers.values(): + if hasattr(sensor_manager, 'quality_monitor'): + sensor_manager.quality_monitor.print_quality_summary() def _save_metadata(self): metadata = { 'scenario': self.config['scenario'], 'traffic': self.config['traffic'], 'sensors': self.config['sensors'], - 'v2x': self.config['v2x'], 'cooperative': self.config['cooperative'], - - + 'enhancement': self.config['enhancement'], 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), @@ -867,11 +919,23 @@ def _save_metadata(self): } } - # 传感器摘要 sensor_summaries = {} for vehicle_id, sensor_manager in self.sensor_managers.items(): sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() + + # 添加增强报告 + if hasattr(sensor_manager, 'enhancer'): + enhancement_report = sensor_manager.generate_enhancement_report() + if enhancement_report: + sensor_summaries[vehicle_id]['enhancement_report'] = enhancement_report + + # 添加质量报告 + if hasattr(sensor_manager, 'quality_monitor'): + quality_report = sensor_manager.generate_quality_report() + if quality_report: + sensor_summaries[vehicle_id]['quality_report'] = quality_report + metadata['sensor_summaries'] = sensor_summaries # V2X通信状态 @@ -882,11 +946,6 @@ def _save_metadata(self): if self.multi_vehicle_manager: metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() - if self.sensor_manager: - sensor_summary = self.sensor_manager.generate_sensor_summary() - metadata['sensor_summary'] = sensor_summary - - meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: json.dump(metadata, f, indent=2, ensure_ascii=False) @@ -898,11 +957,28 @@ def _print_summary(self): print("数据收集摘要") print("=" * 60) - # 统计图像 - stitched_dir = os.path.join(self.output_dir, "stitched") - if os.path.exists(stitched_dir): - stitched_files = [f for f in os.listdir(stitched_dir) if f.endswith('.jpg')] - print(f"拼接图像: {len(stitched_files)} 张") + # 统计原始图像 + raw_dirs = [d for d in os.listdir(self.output_dir) if d.startswith('raw')] + total_raw_images = 0 + for raw_dir in raw_dirs: + raw_path = os.path.join(self.output_dir, raw_dir) + if os.path.exists(raw_path): + # 递归统计图像文件 + for root, dirs, files in os.walk(raw_path): + total_raw_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) + + print(f"原始图像: {total_raw_images} 张") + + # 统计增强图像 + if self.config['enhancement']['enabled']: + enhanced_dir = os.path.join(self.output_dir, + self.config['enhancement'].get('enhanced_dir_name', 'enhanced')) + if os.path.exists(enhanced_dir): + total_enhanced_images = 0 + for root, dirs, files in os.walk(enhanced_dir): + total_enhanced_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) + + print(f"增强图像: {total_enhanced_images} 张") # 统计LiDAR lidar_dir = os.path.join(self.output_dir, "lidar") @@ -911,17 +987,6 @@ def _print_summary(self): npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] print(f"LiDAR数据: {len(bin_files)} .bin文件, {len(npy_files)} .npy文件") - if bin_files: - total_points = 0 - for bin_file in bin_files[:3]: - bin_path = os.path.join(lidar_dir, bin_file) - if os.path.exists(bin_path): - file_size = os.path.getsize(bin_path) - points_in_file = file_size // (4 * 4) - total_points += points_in_file - print(f" 估计总点数: {total_points:,}") - - # 统计协同数据 coop_dir = os.path.join(self.output_dir, "cooperative") if os.path.exists(coop_dir): @@ -930,6 +995,12 @@ def _print_summary(self): [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") + # 校准文件 + calib_dir = os.path.join(self.output_dir, "calibration") + if os.path.exists(calib_dir): + calib_files = len([f for f in os.listdir(calib_dir) if f.endswith('.json')]) + print(f"校准文件: {calib_files} 个") + # V2X统计 if self.v2x_communication: v2x_status = self.v2x_communication.get_network_status() @@ -941,13 +1012,6 @@ def _print_summary(self): print(f"车辆总数: {len(self.ego_vehicles)} 主车 + " f"{len(self.multi_vehicle_manager.cooperative_vehicles)} 协同车") - # 统计融合数据 - fusion_dir = os.path.join(self.output_dir, "fusion") - if os.path.exists(fusion_dir): - sync_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] - print(f"融合数据: {len(sync_files)} 个同步文件") - - print(f"\n输出目录: {self.output_dir}") print("=" * 60) @@ -964,7 +1028,6 @@ def run_analysis(self): def cleanup(self): Log.info("清理场景...") - # 清理传感器 for sensor_manager in self.sensor_managers.values(): sensor_manager.cleanup() @@ -989,37 +1052,15 @@ def cleanup(self): except: pass - - if self.sensor_manager: - self.sensor_manager.cleanup() - - if self.traffic_manager: - self.traffic_manager.cleanup() - - if self.ego_vehicle and self.ego_vehicle.is_alive: - try: - self.ego_vehicle.destroy() - except: - pass - - Log.info("清理完成") def main(): - - parser = argparse.ArgumentParser(description='CVIPS 多车辆协同数据收集系统 v10.0') - - # 基础参数 - parser.add_argument('--config', type=str, help='配置文件路径') - parser.add_argument('--scenario', type=str, default='multi_vehicle_cooperative', help='场景名称') - - parser = argparse.ArgumentParser(description='CVIPS 多传感器数据收集系统') + parser = argparse.ArgumentParser(description='CVIPS 数据增强采集系统 v11.0') # 基础参数 parser.add_argument('--config', type=str, help='配置文件路径') - parser.add_argument('--scenario', type=str, default='multi_sensor_scene', help='场景名称') - + parser.add_argument('--scenario', type=str, default='enhanced_data_collection', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='地图') parser.add_argument('--weather', type=str, default='clear', @@ -1030,11 +1071,8 @@ def main(): # 交通参数 parser.add_argument('--num-vehicles', type=int, default=8, help='背景车辆数') parser.add_argument('--num-pedestrians', type=int, default=6, help='行人数') - parser.add_argument('--num-coop-vehicles', type=int, default=2, help='协同车辆数') - - # 收集参数 parser.add_argument('--duration', type=int, default=60, help='收集时长(秒)') parser.add_argument('--capture-interval', type=float, default=2.0, help='捕捉间隔(秒)') @@ -1043,16 +1081,15 @@ def main(): # 传感器参数 parser.add_argument('--enable-lidar', action='store_true', help='启用LiDAR传感器') parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') - parser.add_argument('--enable-v2x', action='store_true', help='启用V2X通信') parser.add_argument('--enable-cooperative', action='store_true', help='启用协同感知') - - + parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') # 功能参数 parser.add_argument('--run-analysis', action='store_true', help='运行数据集分析') parser.add_argument('--skip-validation', action='store_true', help='跳过数据验证') + parser.add_argument('--skip-quality-check', action='store_true', help='跳过质量检查') args = parser.parse_args(remaining_argv) @@ -1062,35 +1099,24 @@ def main(): # 显示配置 print("\n" + "=" * 60) - - print("CVIPS 多车辆协同数据收集系统 v10.0") - - print("CVIPS 多传感器数据收集系统 v9.0") - + print("CVIPS 数据增强采集系统 v11.0") print("=" * 60) print(f"场景: {config['scenario']['name']}") print(f"地图: {config['scenario']['town']}") print(f"天气/时间: {config['scenario']['weather']}/{config['scenario']['time_of_day']}") print(f"时长: {config['scenario']['duration']}秒") - print(f"交通: {config['traffic']['background_vehicles']}背景车辆 + {config['traffic']['pedestrians']}行人") print(f"协同: {config['cooperative']['num_coop_vehicles']} 协同车辆") - print(f"交通: {config['traffic']['background_vehicles']}车辆 + {config['traffic']['pedestrians']}行人") - - print(f"传感器:") print( f" 摄像头: {config['sensors']['vehicle_cameras']}车辆 + {config['sensors']['infrastructure_cameras']}基础设施") print(f" LiDAR: {'启用' if config['sensors']['lidar_sensors'] > 0 else '禁用'}") print(f" 融合: {'启用' if config['output']['save_fusion'] else '禁用'}") - print(f" V2X: {'启用' if config['v2x']['enabled'] else '禁用'}") print(f" 协同: {'启用' if config['output']['save_cooperative'] else '禁用'}") - - print(f" 标注: {'启用' if config['output']['save_annotations'] else '禁用'}") - + print(f" 增强: {'启用' if config['enhancement']['enabled'] else '禁用'}") collector = DataCollector(config) diff --git a/src/enhance_pedestrian_safety/sensor_enhancer.py b/src/enhance_pedestrian_safety/sensor_enhancer.py new file mode 100644 index 0000000000..f484831c94 --- /dev/null +++ b/src/enhance_pedestrian_safety/sensor_enhancer.py @@ -0,0 +1,784 @@ +""" +传感器数据增强模块 - 提高数据质量和多样性 +""" + +import numpy as np +import cv2 +import random +import os +import json +from PIL import Image, ImageEnhance, ImageFilter +from datetime import datetime +from typing import Dict, List, Tuple, Optional +import carla + + +class SensorDataEnhancer: + """传感器数据增强器""" + + def __init__(self, config: Dict): + self.config = config + self.enhancement_methods = [] + self._setup_enhancement_methods() + + def _setup_enhancement_methods(self): + """设置增强方法""" + # 根据场景配置启用不同的增强方法 + weather = self.config.get('scenario', {}).get('weather', 'clear') + time_of_day = self.config.get('scenario', {}).get('time_of_day', 'noon') + + # 基础增强方法 + self.enhancement_methods = ['normalize'] + + # 根据天气和时间添加特定增强 + if weather == 'rainy': + self.enhancement_methods.extend(['rain_effect', 'motion_blur', 'brightness_adjust']) + elif weather == 'foggy': + self.enhancement_methods.extend(['fog_effect', 'contrast_reduce']) + elif weather == 'night': + self.enhancement_methods.extend(['night_effect', 'noise_add', 'gamma_correction']) + elif weather == 'cloudy': + self.enhancement_methods.extend(['cloud_effect', 'color_temperature']) + + # 随机增强(可选) + if self.config.get('enhancement', {}).get('enable_random', True): + self.enhancement_methods.extend(self._get_random_enhancements()) + + def _get_random_enhancements(self) -> List[str]: + """获取随机增强方法""" + random_methods = [ + 'hue_shift', 'saturation_adjust', 'sharpness_enhance', + 'gaussian_blur', 'jpeg_compression', 'color_jitter' + ] + # 随机选择1-3个增强方法 + num_methods = random.randint(1, 3) + return random.sample(random_methods, num_methods) + + def enhance_image(self, image_data: np.ndarray, sensor_type: str = 'camera') -> np.ndarray: + """ + 增强图像数据 + + Args: + image_data: 原始图像数据 (H, W, C) + sensor_type: 传感器类型 ('camera', 'depth', 'semantic') + + Returns: + 增强后的图像数据 + """ + if sensor_type != 'camera': + # 深度和语义分割图像使用不同的增强 + return self._enhance_non_rgb_image(image_data, sensor_type) + + # 转换为PIL图像进行处理 + pil_image = Image.fromarray(image_data) + + # 按顺序应用增强方法 + for method in self.enhancement_methods: + pil_image = self._apply_enhancement_method(pil_image, method) + + # 确保图像在有效范围内 + enhanced_image = np.array(pil_image) + enhanced_image = np.clip(enhanced_image, 0, 255).astype(np.uint8) + + return enhanced_image + + def _apply_enhancement_method(self, image: Image.Image, method: str) -> Image.Image: + """应用单个增强方法""" + try: + if method == 'normalize': + return self._normalize_image(image) + elif method == 'rain_effect': + return self._add_rain_effect(image) + elif method == 'fog_effect': + return self._add_fog_effect(image) + elif method == 'night_effect': + return self._apply_night_effect(image) + elif method == 'motion_blur': + return self._apply_motion_blur(image) + elif method == 'brightness_adjust': + return self._adjust_brightness(image) + elif method == 'contrast_reduce': + return self._reduce_contrast(image) + elif method == 'noise_add': + return self._add_noise(image) + elif method == 'gamma_correction': + return self._gamma_correction(image) + elif method == 'cloud_effect': + return self._add_cloud_effect(image) + elif method == 'color_temperature': + return self._adjust_color_temperature(image) + elif method == 'hue_shift': + return self._shift_hue(image) + elif method == 'saturation_adjust': + return self._adjust_saturation(image) + elif method == 'sharpness_enhance': + return self._enhance_sharpness(image) + elif method == 'gaussian_blur': + return self._apply_gaussian_blur(image) + elif method == 'jpeg_compression': + return self._simulate_jpeg_compression(image) + elif method == 'color_jitter': + return self._color_jitter(image) + else: + return image + except Exception as e: + print(f"增强方法 {method} 失败: {e}") + return image + + def _enhance_non_rgb_image(self, image_data: np.ndarray, sensor_type: str) -> np.ndarray: + """增强非RGB图像(深度、语义分割)""" + if sensor_type == 'depth': + # 深度图增强:归一化和噪声去除 + normalized = cv2.normalize(image_data, None, 0, 255, cv2.NORM_MINMAX) + # 应用轻微的高斯模糊去除噪声 + enhanced = cv2.GaussianBlur(normalized, (3, 3), 0) + return enhanced.astype(np.uint8) + + elif sensor_type == 'semantic': + # 语义分割图增强:保持类别不变,只做边界平滑 + kernel = np.ones((3, 3), np.uint8) + # 形态学开运算去除小噪声 + enhanced = cv2.morphologyEx(image_data, cv2.MORPH_OPEN, kernel) + return enhanced + + return image_data + + def _normalize_image(self, image: Image.Image) -> Image.Image: + """图像归一化""" + # 转换为numpy数组 + img_array = np.array(image) + + # 归一化到0-255 + if img_array.dtype != np.uint8: + img_array = cv2.normalize(img_array, None, 0, 255, cv2.NORM_MINMAX) + img_array = img_array.astype(np.uint8) + + return Image.fromarray(img_array) + + def _add_rain_effect(self, image: Image.Image) -> Image.Image: + """添加雨滴效果""" + img_array = np.array(image) + h, w, _ = img_array.shape + + # 创建雨滴层 + rain_layer = np.zeros((h, w), dtype=np.float32) + + # 生成随机雨滴位置 + num_drops = random.randint(100, 500) + for _ in range(num_drops): + x = random.randint(0, w - 1) + y = random.randint(0, h - 1) + length = random.randint(5, 20) + thickness = random.randint(1, 2) + brightness = random.uniform(0.7, 0.9) + + # 绘制雨滴(斜线) + for i in range(length): + if y + i < h and x + i < w: + rain_layer[y + i, x + i] += brightness + # 加粗雨滴 + for j in range(thickness): + if x + i + j < w: + rain_layer[y + i, x + i + j] += brightness * 0.5 + + # 模糊雨滴层 + rain_layer = cv2.GaussianBlur(rain_layer, (5, 5), 0) + + # 叠加到原图 + rain_layer_3d = np.stack([rain_layer] * 3, axis=2) + enhanced = cv2.addWeighted(img_array.astype(np.float32), 0.8, + rain_layer_3d * 255, 0.2, 0) + + return Image.fromarray(enhanced.astype(np.uint8)) + + def _add_fog_effect(self, image: Image.Image) -> Image.Image: + """添加雾效""" + img_array = np.array(image) + h, w, _ = img_array.shape + + # 创建雾效层 + fog_intensity = random.uniform(0.3, 0.6) + fog_color = random.choice([200, 210, 220]) # 雾的颜色 + + fog_layer = np.ones((h, w, 3), dtype=np.float32) * fog_color + + # 根据深度添加雾效(这里简化处理,实际应该使用深度图) + # 创建简单的深度渐变(假设图像中心最近) + center_y, center_x = h // 2, w // 2 + y_coords, x_coords = np.ogrid[:h, :w] + distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) + distance = distance / np.max(distance) # 归一化 + + # 雾效随距离增强 + fog_strength = distance * fog_intensity + fog_strength_3d = np.stack([fog_strength] * 3, axis=2) + + # 混合原图和雾效 + enhanced = img_array.astype(np.float32) * (1 - fog_strength_3d) + \ + fog_layer * fog_strength_3d + + return Image.fromarray(enhanced.astype(np.uint8)) + + def _apply_night_effect(self, image: Image.Image) -> Image.Image: + """应用夜间效果""" + # 降低亮度 + enhancer = ImageEnhance.Brightness(image) + image = enhancer.enhance(random.uniform(0.3, 0.6)) + + # 降低对比度 + enhancer = ImageEnhance.Contrast(image) + image = enhancer.enhance(random.uniform(0.7, 0.9)) + + # 添加暗角效果 + img_array = np.array(image) + h, w, _ = img_array.shape + + # 创建暗角蒙版 + center_y, center_x = h // 2, w // 2 + y_coords, x_coords = np.ogrid[:h, :w] + distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) + distance = distance / np.max(distance) + + vignette = 1 - distance * 0.3 # 暗角强度 + vignette_3d = np.stack([vignette] * 3, axis=2) + + enhanced = img_array.astype(np.float32) * vignette_3d + enhanced = np.clip(enhanced, 0, 255) + + return Image.fromarray(enhanced.astype(np.uint8)) + + def _apply_motion_blur(self, image: Image.Image) -> Image.Image: + """应用运动模糊""" + img_array = np.array(image) + + # 随机选择模糊方向和强度 + kernel_size = random.choice([5, 7, 9]) + direction = random.choice(['horizontal', 'vertical']) + + if direction == 'horizontal': + kernel = np.zeros((kernel_size, kernel_size)) + kernel[kernel_size // 2, :] = 1.0 / kernel_size + else: # vertical + kernel = np.zeros((kernel_size, kernel_size)) + kernel[:, kernel_size // 2] = 1.0 / kernel_size + + # 应用卷积 + blurred = cv2.filter2D(img_array, -1, kernel) + + # 混合原图和模糊图 + alpha = random.uniform(0.3, 0.7) + enhanced = cv2.addWeighted(img_array, 1 - alpha, blurred, alpha, 0) + + return Image.fromarray(enhanced) + + def _adjust_brightness(self, image: Image.Image) -> Image.Image: + """调整亮度""" + factor = random.uniform(0.8, 1.2) + enhancer = ImageEnhance.Brightness(image) + return enhancer.enhance(factor) + + def _reduce_contrast(self, image: Image.Image) -> Image.Image: + """降低对比度""" + factor = random.uniform(0.7, 0.9) + enhancer = ImageEnhance.Contrast(image) + return enhancer.enhance(factor) + + def _add_noise(self, image: Image.Image) -> Image.Image: + """添加噪声""" + img_array = np.array(image) + + # 选择噪声类型 + noise_type = random.choice(['gaussian', 'salt_pepper']) + + if noise_type == 'gaussian': + # 高斯噪声 + mean = 0 + var = random.uniform(0.001, 0.005) + sigma = var ** 0.5 + gauss = np.random.normal(mean, sigma, img_array.shape) + noisy = img_array + gauss * 255 + noisy = np.clip(noisy, 0, 255) + + else: # salt_pepper + # 椒盐噪声 + amount = random.uniform(0.001, 0.005) + s_vs_p = random.uniform(0.3, 0.7) # 盐 vs 椒的比例 + + noisy = np.copy(img_array) + + # 盐噪声 + num_salt = np.ceil(amount * img_array.size * s_vs_p) + coords = [np.random.randint(0, i - 1, int(num_salt)) for i in img_array.shape] + noisy[coords[0], coords[1], :] = 255 + + # 椒噪声 + num_pepper = np.ceil(amount * img_array.size * (1. - s_vs_p)) + coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in img_array.shape] + noisy[coords[0], coords[1], :] = 0 + + return Image.fromarray(noisy.astype(np.uint8)) + + def _gamma_correction(self, image: Image.Image) -> Image.Image: + """伽马校正""" + img_array = np.array(image).astype(np.float32) / 255.0 + gamma = random.uniform(0.8, 1.2) + + corrected = np.power(img_array, gamma) + corrected = (corrected * 255).astype(np.uint8) + + return Image.fromarray(corrected) + + def _add_cloud_effect(self, image: Image.Image) -> Image.Image: + """添加云层效果""" + img_array = np.array(image) + + # 轻微降低饱和度和对比度,模拟多云天气 + hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV) + hsv[:, :, 1] = hsv[:, :, 1] * random.uniform(0.8, 0.9) # 降低饱和度 + hsv[:, :, 2] = hsv[:, :, 2] * random.uniform(0.9, 1.0) # 轻微降低亮度 + + enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB) + + return Image.fromarray(enhanced) + + def _adjust_color_temperature(self, image: Image.Image) -> Image.Image: + """调整色温""" + img_array = np.array(image).astype(np.float32) + + # 随机选择冷色调或暖色调 + temp_type = random.choice(['warm', 'cool']) + + if temp_type == 'warm': + # 暖色调:增加红色,减少蓝色 + img_array[:, :, 0] *= random.uniform(1.0, 1.1) # 红色通道 + img_array[:, :, 2] *= random.uniform(0.9, 1.0) # 蓝色通道 + else: + # 冷色调:增加蓝色,减少红色 + img_array[:, :, 0] *= random.uniform(0.9, 1.0) # 红色通道 + img_array[:, :, 2] *= random.uniform(1.0, 1.1) # 蓝色通道 + + img_array = np.clip(img_array, 0, 255) + + return Image.fromarray(img_array.astype(np.uint8)) + + def _shift_hue(self, image: Image.Image) -> Image.Image: + """色调偏移""" + img_array = np.array(image) + hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV) + + # 随机偏移色调 + shift = random.randint(-10, 10) + hsv[:, :, 0] = (hsv[:, :, 0] + shift) % 180 + + enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB) + + return Image.fromarray(enhanced) + + def _adjust_saturation(self, image: Image.Image) -> Image.Image: + """调整饱和度""" + factor = random.uniform(0.8, 1.2) + enhancer = ImageEnhance.Color(image) + return enhancer.enhance(factor) + + def _enhance_sharpness(self, image: Image.Image) -> Image.Image: + """增强锐度""" + factor = random.uniform(1.2, 1.5) + enhancer = ImageEnhance.Sharpness(image) + return enhancer.enhance(factor) + + def _apply_gaussian_blur(self, image: Image.Image) -> Image.Image: + """应用高斯模糊""" + kernel_size = random.choice([3, 5]) + return image.filter(ImageFilter.GaussianBlur(radius=kernel_size)) + + def _simulate_jpeg_compression(self, image: Image.Image) -> Image.Image: + """模拟JPEG压缩""" + # 将图像保存为JPEG并重新加载以模拟压缩 + import io + buffer = io.BytesIO() + + # 随机质量 + quality = random.randint(70, 95) + image.save(buffer, format='JPEG', quality=quality) + buffer.seek(0) + + compressed = Image.open(buffer) + return compressed + + def _color_jitter(self, image: Image.Image) -> Image.Image: + """颜色抖动""" + # 应用随机颜色变换 + transforms = [] + + # 随机亮度调整 + if random.random() > 0.5: + brightness = random.uniform(0.8, 1.2) + transforms.append(lambda img: ImageEnhance.Brightness(img).enhance(brightness)) + + # 随机对比度调整 + if random.random() > 0.5: + contrast = random.uniform(0.8, 1.2) + transforms.append(lambda img: ImageEnhance.Contrast(img).enhance(contrast)) + + # 随机饱和度调整 + if random.random() > 0.5: + saturation = random.uniform(0.8, 1.2) + transforms.append(lambda img: ImageEnhance.Color(img).enhance(saturation)) + + # 随机应用变换 + if transforms: + random.shuffle(transforms) + for transform in transforms[:2]: # 最多应用2个变换 + image = transform(image) + + return image + + def save_enhanced_image(self, image_data: np.ndarray, output_path: str, + metadata: Optional[Dict] = None): + """ + 保存增强后的图像和元数据 + + Args: + image_data: 图像数据 + output_path: 输出路径 + metadata: 增强元数据 + """ + # 保存图像 + cv2.imwrite(output_path, cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) + + # 保存元数据 + if metadata: + meta_path = output_path.replace('.png', '_meta.json').replace('.jpg', '_meta.json') + with open(meta_path, 'w', encoding='utf-8') as f: + json.dump(metadata, f, indent=2, ensure_ascii=False) + + def generate_enhancement_report(self, output_dir: str): + """生成增强报告""" + report = { + 'timestamp': datetime.now().isoformat(), + 'enhancement_methods': self.enhancement_methods, + 'config': self.config.get('enhancement', {}), + 'weather': self.config.get('scenario', {}).get('weather', 'clear'), + 'time_of_day': self.config.get('scenario', {}).get('time_of_day', 'noon'), + 'statistics': { + 'total_methods': len(self.enhancement_methods), + 'weather_specific_methods': [ + m for m in self.enhancement_methods + if m in ['rain_effect', 'fog_effect', 'night_effect', 'cloud_effect'] + ], + 'quality_methods': [ + m for m in self.enhancement_methods + if m in ['normalize', 'sharpness_enhance', 'gamma_correction'] + ], + 'random_methods': [ + m for m in self.enhancement_methods + if m in ['hue_shift', 'saturation_adjust', 'color_jitter', 'jpeg_compression'] + ] + } + } + + report_path = os.path.join(output_dir, 'enhancement_report.json') + with open(report_path, 'w', encoding='utf-8') as f: + json.dump(report, f, indent=2, ensure_ascii=False) + + return report + + +class SensorCalibrator: + """传感器校准模块""" + + def __init__(self, config: Dict): + self.config = config + self.calibration_data = {} + + def generate_calibration_files(self, output_dir: str, + vehicle_locations: List[Dict], + camera_positions: List[Dict]): + """ + 生成传感器校准文件 + + Args: + output_dir: 输出目录 + vehicle_locations: 车辆位置信息 + camera_positions: 相机位置信息 + """ + calib_dir = os.path.join(output_dir, "calibration") + os.makedirs(calib_dir, exist_ok=True) + + # 1. 生成相机内参 + self._generate_camera_intrinsics(calib_dir) + + # 2. 生成外参(相机到车辆) + self._generate_extrinsics(calib_dir, vehicle_locations, camera_positions) + + # 3. 生成传感器间标定 + self._generate_sensor_calibration(calib_dir) + + # 4. 生成时间同步校准 + self._generate_temporal_calibration(calib_dir) + + print(f"校准文件已生成到: {calib_dir}") + + def _generate_camera_intrinsics(self, calib_dir: str): + """生成相机内参""" + image_size = self.config.get('sensors', {}).get('image_size', [1280, 720]) + width, height = image_size[0], image_size[1] + + # 内参矩阵 [fx, 0, cx; 0, fy, cy; 0, 0, 1] + fx = width * 0.8 # 假设焦距 + fy = fx + cx = width / 2.0 + cy = height / 2.0 + + intrinsics = { + 'camera_matrix': [ + [fx, 0, cx], + [0, fy, cy], + [0, 0, 1] + ], + 'distortion_coefficients': [0.0, 0.0, 0.0, 0.0, 0.0], # 无畸变 + 'image_size': [width, height], + 'fov': 90.0, + 'sensor_type': 'pinhole' + } + + # 为每个相机生成内参(简化处理,实际应该每个相机不同) + for i in range(4): # 假设4个车辆相机 + file_path = os.path.join(calib_dir, f'camera_{i + 1}_intrinsic.json') + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(intrinsics, f, indent=2, ensure_ascii=False) + + # 基础设施相机内参(可能不同) + for i in range(4): # 假设4个基础设施相机 + file_path = os.path.join(calib_dir, f'infra_camera_{i + 1}_intrinsic.json') + # 基础设施相机可能有不同的参数 + infra_intrinsics = intrinsics.copy() + infra_intrinsics['fov'] = 120.0 # 更广的视角 + infra_intrinsics['sensor_type'] = 'fisheye' # 鱼眼相机 + + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(infra_intrinsics, f, indent=2, ensure_ascii=False) + + def _generate_extrinsics(self, calib_dir: str, + vehicle_locations: List[Dict], + camera_positions: List[Dict]): + """生成外参(相机到车辆坐标系)""" + for i, (vehicle_loc, cam_pos) in enumerate(zip(vehicle_locations, camera_positions)): + # 外参矩阵 [R|t] + # 这里简化为单位矩阵,实际应根据安装位置计算 + extrinsics = { + 'vehicle_id': vehicle_loc.get('id', i + 1), + 'translation': cam_pos.get('translation', [0, 0, 0]), + 'rotation': cam_pos.get('rotation', [0, 0, 0]), + 'transform_matrix': [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, 1] + ], + 'timestamp': datetime.now().isoformat() + } + + file_path = os.path.join(calib_dir, f'vehicle_{i + 1}_extrinsic.json') + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(extrinsics, f, indent=2, ensure_ascii=False) + + def _generate_sensor_calibration(self, calib_dir: str): + """生成传感器间标定(相机到LiDAR等)""" + # 相机到LiDAR标定 + cam_to_lidar = { + 'sensor_pair': ['camera_1', 'lidar_1'], + 'translation': [0.5, 0.0, -0.2], # 相机相对于LiDAR的位置 + 'rotation': [0, 0, 0], # 旋转 + 'calibration_method': 'manual', + 'accuracy': 0.01, # 标定精度(米) + 'timestamp': datetime.now().isoformat() + } + + file_path = os.path.join(calib_dir, 'camera_to_lidar_calib.json') + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(cam_to_lidar, f, indent=2, ensure_ascii=False) + + # 基础设施相机到全局坐标系标定 + infra_to_global = { + 'sensor_type': 'infrastructure_camera', + 'global_position': [0, 0, 12], # 安装位置 + 'orientation': [0, -25, 0], # 俯仰角 + 'calibration_method': 'gps_imu', + 'accuracy': 0.05, + 'timestamp': datetime.now().isoformat() + } + + file_path = os.path.join(calib_dir, 'infrastructure_global_calib.json') + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(infra_to_global, f, indent=2, ensure_ascii=False) + + def _generate_temporal_calibration(self, calib_dir: str): + """生成时间同步校准""" + temporal_calib = { + 'sensor_latencies': { + 'camera': 0.033, # 33ms延迟 + 'lidar': 0.010, # 10ms延迟 + 'gps': 0.001, # 1ms延迟 + 'imu': 0.005 # 5ms延迟 + }, + 'sync_method': 'hardware_trigger', + 'sync_accuracy': 0.001, # 1ms同步精度 + 'master_clock': 'gps_time', + 'timestamp': datetime.now().isoformat() + } + + file_path = os.path.join(calib_dir, 'temporal_calibration.json') + with open(file_path, 'w', encoding='utf-8') as f: + json.dump(temporal_calib, f, indent=2, ensure_ascii=False) + + +class DataQualityMonitor: + """数据质量监控器""" + + def __init__(self, output_dir: str): + self.output_dir = output_dir + self.quality_metrics = { + 'images': {'total': 0, 'valid': 0, 'issues': []}, + 'lidar': {'total': 0, 'valid': 0, 'issues': []}, + 'annotations': {'total': 0, 'valid': 0, 'issues': []}, + 'calibration': {'total': 0, 'valid': 0, 'issues': []} + } + + def check_image_quality(self, image_path: str) -> Dict: + """检查图像质量""" + try: + img = cv2.imread(image_path) + if img is None: + return {'valid': False, 'error': '无法读取图像'} + + # 检查图像尺寸 + h, w, c = img.shape + if h == 0 or w == 0: + return {'valid': False, 'error': '图像尺寸无效'} + + # 检查图像是否全黑或全白 + mean_brightness = np.mean(img) + if mean_brightness < 10 or mean_brightness > 245: + return {'valid': False, 'warning': f'图像过暗或过亮: {mean_brightness}'} + + # 检查图像对比度 + contrast = np.std(img) + if contrast < 20: + return {'valid': True, 'warning': f'图像对比度过低: {contrast}'} + + return {'valid': True, 'dimensions': (w, h), 'brightness': mean_brightness, 'contrast': contrast} + + except Exception as e: + return {'valid': False, 'error': str(e)} + + def check_lidar_quality(self, lidar_path: str) -> Dict: + """检查LiDAR数据质量""" + try: + # 检查文件是否存在和大小 + if not os.path.exists(lidar_path): + return {'valid': False, 'error': '文件不存在'} + + file_size = os.path.getsize(lidar_path) + if file_size == 0: + return {'valid': False, 'error': '文件为空'} + + # 如果是.bin文件,检查点云数据 + if lidar_path.endswith('.bin'): + points = np.fromfile(lidar_path, dtype=np.float32) + num_points = len(points) // 4 # 假设每个点4个float + + if num_points < 100: + return {'valid': False, 'error': f'点云数量过少: {num_points}'} + + return { + 'valid': True, + 'num_points': num_points, + 'file_size': file_size + } + + return {'valid': True, 'file_size': file_size} + + except Exception as e: + return {'valid': False, 'error': str(e)} + + def update_metrics(self, data_type: str, check_result: Dict): + """更新质量指标""" + self.quality_metrics[data_type]['total'] += 1 + + if check_result.get('valid', False): + self.quality_metrics[data_type]['valid'] += 1 + else: + self.quality_metrics[data_type]['issues'].append(check_result.get('error', '未知错误')) + + def generate_quality_report(self) -> Dict: + """生成质量报告""" + report = { + 'timestamp': datetime.now().isoformat(), + 'summary': {}, + 'issues_by_type': {}, + 'quality_score': 0 + } + + total_valid = 0 + total_count = 0 + + for data_type, metrics in self.quality_metrics.items(): + total = metrics['total'] + valid = metrics['valid'] + + if total > 0: + valid_ratio = valid / total + report['summary'][data_type] = { + 'total': total, + 'valid': valid, + 'valid_ratio': round(valid_ratio * 100, 2), + 'issues_count': len(metrics['issues']) + } + + total_valid += valid + total_count += total + + # 记录问题 + if metrics['issues']: + report['issues_by_type'][data_type] = metrics['issues'][:10] # 只显示前10个问题 + + # 计算总体质量分数 + if total_count > 0: + report['quality_score'] = round((total_valid / total_count) * 100, 2) + + # 保存报告 + report_path = os.path.join(self.output_dir, 'data_quality_report.json') + with open(report_path, 'w', encoding='utf-8') as f: + json.dump(report, f, indent=2, ensure_ascii=False) + + return report + + def print_quality_summary(self): + """打印质量摘要""" + print("\n" + "=" * 60) + print("数据质量报告") + print("=" * 60) + + report = self.generate_quality_report() + + for data_type, summary in report['summary'].items(): + print(f"\n{data_type.upper()}:") + print(f" 总数: {summary['total']}") + print(f" 有效: {summary['valid']}") + print(f" 有效率: {summary['valid_ratio']}%") + if summary['issues_count'] > 0: + print(f" 问题数: {summary['issues_count']}") + + print(f"\n总体质量分数: {report['quality_score']}/100") + + if report['quality_score'] >= 90: + print("✓ 数据质量优秀") + elif report['quality_score'] >= 75: + print("✓ 数据质量良好") + elif report['quality_score'] >= 60: + print("⚠ 数据质量一般") + else: + print("✗ 数据质量需要改进") + + print("=" * 60) \ No newline at end of file From 8dcf6e21ea6427f5565539f1d20356fe8667dc4a Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Fri, 19 Dec 2025 14:20:02 +0800 Subject: [PATCH 04/21] =?UTF-8?q?=E5=86=85=E5=AD=98=E5=92=8C=E6=80=A7?= =?UTF-8?q?=E8=83=BD=E4=BC=98=E5=8C=96=EF=BC=8C=E6=95=B0=E6=8D=AE=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F=E6=A0=87=E5=87=86=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 67 +- .../lidar_processor.py | 380 ++++++++-- src/enhance_pedestrian_safety/main.py | 675 +++++++++++------- 3 files changed, 791 insertions(+), 331 deletions(-) diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 54477406ba..0ef2d0bff3 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -20,7 +20,9 @@ def load_config(config_file=None): 'ego_vehicles': 1, 'background_vehicles': 8, 'pedestrians': 6, - 'traffic_lights': True + 'traffic_lights': True, + 'batch_spawn': True, + 'max_spawn_attempts': 5 }, 'sensors': { 'vehicle_cameras': 4, @@ -33,7 +35,9 @@ def load_config(config_file=None): 'channels': 32, 'range': 100, 'points_per_second': 56000, - 'rotation_frequency': 10 + 'rotation_frequency': 10, + 'max_points_per_frame': 100000, + 'downsample_ratio': 0.5 } }, 'v2x': { @@ -62,6 +66,27 @@ def load_config(config_file=None): 'calibration_generation': True, 'enhanced_dir_name': 'enhanced' }, + 'performance': { + 'batch_size': 5, + 'enable_compression': True, + 'compression_level': 3, + 'enable_downsampling': True, + 'enable_memory_cache': True, + 'max_cache_size': 50, + 'image_processing': { + 'compress_images': True, + 'compression_quality': 85 + }, + 'lidar_processing': { + 'batch_size': 10, + 'enable_compression': True, + 'enable_downsampling': True, + 'max_points_per_frame': 100000 + }, + 'fusion': { + 'fusion_cache_size': 100 + } + }, 'output': { 'data_dir': 'cvips_dataset', 'save_raw': True, @@ -74,7 +99,8 @@ def load_config(config_file=None): 'save_enhanced': True, 'validate_data': True, 'run_analysis': False, - 'run_quality_check': True + 'run_quality_check': True, + 'output_format': 'standard' } } @@ -116,38 +142,51 @@ def merge_args(config, args): if args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians - if args.num_coop_vehicles: + if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles - if args.capture_interval: + if hasattr(args, 'capture_interval') and args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval - if args.enable_v2x: + if hasattr(args, 'enable_v2x') and args.enable_v2x: config['v2x']['enabled'] = True - if args.enable_enhancement: + if hasattr(args, 'enable_enhancement') and args.enable_enhancement: config['enhancement']['enabled'] = True - if args.enable_lidar: + if hasattr(args, 'enable_lidar') and args.enable_lidar: config['sensors']['lidar_sensors'] = 1 config['output']['save_lidar'] = True - if args.enable_fusion: + if hasattr(args, 'enable_fusion') and args.enable_fusion: config['output']['save_fusion'] = True - if args.enable_cooperative: + if hasattr(args, 'enable_cooperative') and args.enable_cooperative: config['output']['save_cooperative'] = True - if args.enable_annotations: + if hasattr(args, 'enable_annotations') and args.enable_annotations: config['output']['save_annotations'] = True - if args.skip_validation: + if hasattr(args, 'skip_validation') and args.skip_validation: config['output']['validate_data'] = False - if args.skip_quality_check: + if hasattr(args, 'skip_quality_check') and args.skip_quality_check: config['output']['run_quality_check'] = False - if args.run_analysis: + if hasattr(args, 'run_analysis') and args.run_analysis: config['output']['run_analysis'] = True + # 性能参数 + if hasattr(args, 'batch_size') and args.batch_size: + config['performance']['batch_size'] = args.batch_size + + if hasattr(args, 'enable_compression') and args.enable_compression: + config['performance']['enable_compression'] = True + + if hasattr(args, 'enable_downsampling') and args.enable_downsampling: + config['performance']['enable_downsampling'] = True + + if hasattr(args, 'output_format') and args.output_format: + config['output']['output_format'] = args.output_format + return config \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index fdcc61637b..c9a960ac5f 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -3,12 +3,15 @@ import os import json import threading +import gc from datetime import datetime +import zlib +import pickle class LidarProcessor: - def __init__(self, output_dir): + def __init__(self, output_dir, config=None): self.output_dir = output_dir self.lidar_dir = os.path.join(output_dir, "lidar") os.makedirs(self.lidar_dir, exist_ok=True) @@ -19,6 +22,17 @@ def __init__(self, output_dir): self.frame_counter = 0 self.data_lock = threading.Lock() + # 性能优化:批量处理设置 + self.batch_size = config.get('batch_size', 10) if config else 10 + self.point_cloud_batch = [] + self.enable_compression = config.get('enable_compression', True) if config else True + self.compression_level = config.get('compression_level', 3) if config else 3 + + # 内存管理 + self.max_points_per_frame = config.get('max_points_per_frame', 100000) if config else 100000 + self.enable_downsampling = config.get('enable_downsampling', True) if config else True + self.downsample_ratio = config.get('downsample_ratio', 0.5) if config else 0.5 + self._init_calibration_files() def _init_calibration_files(self): @@ -62,65 +76,175 @@ def process_lidar_data(self, lidar_data, frame_num): if points is None or points.shape[0] == 0: return None + # 下采样以减少内存使用 + if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: + points = self._downsample_point_cloud(points) + + # 添加到批处理 + self.point_cloud_batch.append((frame_num, points)) + + # 如果达到批处理大小,保存批处理数据 + if len(self.point_cloud_batch) >= self.batch_size: + self._save_batch() + + # 保存单个文件(向后兼容) bin_path = self._save_as_bin(points, frame_num) npy_path = self._save_as_npy(points, frame_num) - csv_path = self._save_as_csv(points, frame_num) - metadata = self._generate_metadata(points, bin_path, npy_path, csv_path) + # 生成V2XFormer兼容格式 + v2xformer_path = self._save_as_v2xformer_format(points, frame_num) + + metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) return metadata def _carla_lidar_to_numpy(self, lidar_data): + """高效转换LiDAR数据""" try: + # 使用内存视图减少内存分配 points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) points = np.reshape(points, (int(points.shape[0] / 4), 4)) + # 只保留位置信息(x, y, z),忽略强度 points = points[:, :3] + # 清理临时数组 + del lidar_data + gc.collect() + return points except Exception as e: print(f"LiDAR数据转换失败: {e}") + # 备选转换方法 try: points = [] - for point in lidar_data: + for i in range(0, len(lidar_data), 4): + point = lidar_data[i:i + 4] points.append([point.x, point.y, point.z]) return np.array(points, dtype=np.float32) except: return None + def _downsample_point_cloud(self, points): + """下采样点云以减少内存使用""" + if points.shape[0] <= self.max_points_per_frame: + return points + + # 随机下采样 + indices = np.random.choice(points.shape[0], + int(points.shape[0] * self.downsample_ratio), + replace=False) + downsampled = points[indices] + + # 清理内存 + del points + gc.collect() + + return downsampled + + def _save_batch(self): + """批量保存点云数据(提高效率)""" + if not self.point_cloud_batch: + return + + batch_data = [] + for frame_num, points in self.point_cloud_batch: + batch_data.append({ + 'frame_num': frame_num, + 'points': points.tolist(), + 'num_points': points.shape[0] + }) + + # 生成批处理文件名 + min_frame = min([item[0] for item in self.point_cloud_batch]) + max_frame = max([item[0] for item in self.point_cloud_batch]) + batch_filename = f"lidar_batch_{min_frame:06d}_{max_frame:06d}.json" + batch_path = os.path.join(self.lidar_dir, batch_filename) + + # 压缩保存 + if self.enable_compression: + compressed_data = zlib.compress( + json.dumps(batch_data).encode('utf-8'), + level=self.compression_level + ) + with open(batch_path, 'wb') as f: + f.write(compressed_data) + else: + with open(batch_path, 'w') as f: + json.dump(batch_data, f) + + # 清理批处理缓存 + self.point_cloud_batch.clear() + gc.collect() + + print(f"批量保存LiDAR数据: {batch_filename}") + def _save_as_bin(self, points, frame_num): + """保存为二进制格式(兼容KITTI)""" bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") + # 添加强度信息(全为1) points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) points_with_intensity[:, :3] = points - points_with_intensity[:, 3] = 0.0 + points_with_intensity[:, 3] = 1.0 # 强度值 points_with_intensity.tofile(bin_path) return bin_path def _save_as_npy(self, points, frame_num): + """保存为numpy格式""" npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") - np.save(npy_path, points) + + # 使用内存映射减少内存使用 + memmap_array = np.lib.format.open_memmap( + npy_path, + mode='w+', + dtype=np.float32, + shape=points.shape + ) + memmap_array[:] = points[:] + memmap_array.flush() + return npy_path - def _save_as_csv(self, points, frame_num): - csv_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.csv") + def _save_as_v2xformer_format(self, points, frame_num): + """保存为V2XFormer兼容格式""" + v2x_dir = os.path.join(self.output_dir, "v2xformer_format") + os.makedirs(v2x_dir, exist_ok=True) - sample_points = points[:min(1000, points.shape[0])] + # 创建V2XFormer格式的数据结构 + v2x_data = { + 'frame_id': frame_num, + 'timestamp': datetime.now().timestamp(), + 'point_cloud': { + 'points': points.tolist(), + 'num_points': points.shape[0], + 'range': [np.min(points[:, 0]), np.max(points[:, 0]), + np.min(points[:, 1]), np.max(points[:, 1]), + np.min(points[:, 2]), np.max(points[:, 2])] + }, + 'metadata': { + 'sensor_type': 'lidar', + 'format_version': '1.0', + 'coordinate_system': 'carla_world' + } + } - header = "x,y,z\n" + # 保存为压缩的JSON格式 + filename = f"{frame_num:06d}.pkl.gz" + filepath = os.path.join(v2x_dir, filename) - with open(csv_path, 'w') as f: - f.write(header) - np.savetxt(f, sample_points, delimiter=',', fmt='%.6f') + # 使用pickle+gzip压缩保存 + with gzip.open(filepath, 'wb') as f: + pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) - return csv_path + return filepath - def _generate_metadata(self, points, bin_path, npy_path, csv_path): + def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): metadata = { 'frame_id': self.frame_counter, 'timestamp': datetime.now().isoformat(), @@ -128,7 +252,7 @@ def _generate_metadata(self, points, bin_path, npy_path, csv_path): 'file_paths': { 'bin': os.path.basename(bin_path), 'npy': os.path.basename(npy_path), - 'csv': os.path.basename(csv_path) + 'v2xformer': os.path.basename(v2xformer_path) }, 'statistics': { 'x_range': [float(points[:, 0].min()), float(points[:, 0].max())], @@ -137,10 +261,11 @@ def _generate_metadata(self, points, bin_path, npy_path, csv_path): 'mean': [float(points[:, 0].mean()), float(points[:, 1].mean()), float(points[:, 2].mean())], 'std': [float(points[:, 0].std()), float(points[:, 1].std()), float(points[:, 2].std())] }, - 'file_sizes': { - 'bin': os.path.getsize(bin_path) if os.path.exists(bin_path) else 0, - 'npy': os.path.getsize(npy_path) if os.path.exists(npy_path) else 0, - 'csv': os.path.getsize(csv_path) if os.path.exists(csv_path) else 0 + 'processing_info': { + 'downsampled': self.enable_downsampling and points.shape[0] > self.max_points_per_frame, + 'downsample_ratio': self.downsample_ratio if self.enable_downsampling else 1.0, + 'compression_enabled': self.enable_compression, + 'compression_level': self.compression_level } } @@ -150,33 +275,57 @@ def _generate_metadata(self, points, bin_path, npy_path, csv_path): return metadata + def flush_batch(self): + """强制刷新批处理数据""" + if self.point_cloud_batch: + self._save_batch() + def generate_lidar_summary(self): + """生成LiDAR数据摘要(优化版)""" if not os.path.exists(self.lidar_dir): return None - bin_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.bin')] - npy_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.npy')] - meta_files = [f for f in os.listdir(self.lidar_dir) if f.endswith('.json')] + # 快速统计文件 + import glob + bin_files = glob.glob(os.path.join(self.lidar_dir, "*.bin")) + npy_files = glob.glob(os.path.join(self.lidar_dir, "*.npy")) + batch_files = glob.glob(os.path.join(self.lidar_dir, "*batch*.json")) + v2x_files = glob.glob(os.path.join(self.output_dir, "v2xformer_format", "*.pkl.gz")) total_points = 0 - for bin_file in bin_files: - bin_path = os.path.join(self.lidar_dir, bin_file) - if os.path.exists(bin_path): - file_size = os.path.getsize(bin_path) - points_in_file = file_size // (4 * 4) + total_size = 0 + + # 采样统计,避免读取所有文件 + sample_files = bin_files[:10] if len(bin_files) > 10 else bin_files + for bin_file in sample_files: + if os.path.exists(bin_file): + file_size = os.path.getsize(bin_file) + total_size += file_size + # 估算点数 + points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 total_points += points_in_file + # 根据采样估算总数 + if sample_files: + avg_points_per_file = total_points / len(sample_files) + total_points_estimated = avg_points_per_file * len(bin_files) + else: + total_points_estimated = 0 + summary = { 'total_frames': len(bin_files), - 'total_points': total_points, - 'average_points_per_frame': total_points // max(len(bin_files), 1), + 'total_points_estimated': int(total_points_estimated), + 'average_points_per_frame': int(avg_points_per_file) if sample_files else 0, 'file_types': { 'bin': len(bin_files), 'npy': len(npy_files), - 'meta': len(meta_files) + 'batch': len(batch_files), + 'v2xformer': len(v2x_files) }, - 'total_size_mb': round(sum(os.path.getsize(os.path.join(self.lidar_dir, f)) - for f in bin_files + npy_files + meta_files) / (1024 * 1024), 2) + 'total_size_mb': round(total_size / (1024 * 1024), 2), + 'compression_ratio': round(sum([os.path.getsize(f) for f in batch_files]) / + max(1, sum([os.path.getsize(f) for f in bin_files])), 2) + if bin_files and batch_files else 1.0 } summary_path = os.path.join(self.output_dir, "metadata", "lidar_summary.json") @@ -187,86 +336,167 @@ def generate_lidar_summary(self): class MultiSensorFusion: + """多传感器融合(优化版)""" - def __init__(self, output_dir): + def __init__(self, output_dir, config=None): self.output_dir = output_dir self.fusion_dir = os.path.join(output_dir, "fusion") os.makedirs(self.fusion_dir, exist_ok=True) self.calibration_data = {} + self.fusion_cache = {} # 融合缓存 + self.cache_size = config.get('fusion_cache_size', 100) if config else 100 + self._load_calibration() def _load_calibration(self): calibration_dir = os.path.join(self.output_dir, "calibration") if os.path.exists(calibration_dir): - for file in os.listdir(calibration_dir): - if file.endswith('.json'): - filepath = os.path.join(calibration_dir, file) + # 批量读取校准文件 + calibration_files = [] + for root, dirs, files in os.walk(calibration_dir): + for file in files: + if file.endswith('.json'): + calibration_files.append(os.path.join(root, file)) + + # 并行读取校准文件 + import concurrent.futures + with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor: + future_to_file = { + executor.submit(self._load_calibration_file, file): file + for file in calibration_files + } + + for future in concurrent.futures.as_completed(future_to_file): + file = future_to_file[future] try: - with open(filepath, 'r') as f: - data = json.load(f) - sensor_name = file.replace('.json', '') - self.calibration_data[sensor_name] = data - except: - pass + sensor_name, data = future.result() + if sensor_name and data: + self.calibration_data[sensor_name] = data + except Exception as e: + print(f"加载校准文件 {file} 失败: {e}") + + def _load_calibration_file(self, filepath): + """加载单个校准文件""" + try: + with open(filepath, 'r') as f: + data = json.load(f) + sensor_name = os.path.basename(filepath).replace('.json', '') + return sensor_name, data + except: + return None, None def create_synchronization_file(self, frame_num, sensor_data): + """创建同步文件(优化版)""" + # 检查缓存 + cache_key = f"{frame_num}_{hash(str(sensor_data))}" + if cache_key in self.fusion_cache: + return self.fusion_cache[cache_key] + sync_data = { 'frame_id': frame_num, - 'timestamp': datetime.now().isoformat(), - 'sensors': {} + 'timestamp': datetime.now().timestamp(), # 使用时间戳而不是ISO格式 + 'sensors': {}, + 'transformations': {} } + # 批量处理传感器数据 for sensor_type, data_path in sensor_data.items(): if data_path and os.path.exists(data_path): - sync_data['sensors'][sensor_type] = { + # 获取文件信息(不加载完整文件) + file_info = { 'file_path': os.path.basename(data_path), 'file_size': os.path.getsize(data_path), - 'timestamp': datetime.fromtimestamp(os.path.getctime(data_path)).isoformat() + 'modified_time': os.path.getmtime(data_path) } + # 如果是图像,获取尺寸信息 + if data_path.endswith(('.png', '.jpg', '.jpeg')): + try: + import cv2 + img = cv2.imread(data_path) + if img is not None: + file_info['dimensions'] = img.shape[:2] + except: + pass + + sync_data['sensors'][sensor_type] = file_info + + # 添加变换信息(如果可用) + if sensor_type in self.calibration_data: + sync_data['transformations'][sensor_type] = { + 'matrix': self.calibration_data[sensor_type].get('matrix', + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], + [0, 0, 0, 1]]) + } + + # 压缩保存 sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") - with open(sync_file, 'w') as f: - json.dump(sync_data, f, indent=2) + + # 使用压缩的JSON + if len(str(sync_data)) > 1000: # 如果数据较大,压缩保存 + compressed_data = zlib.compress( + json.dumps(sync_data).encode('utf-8'), + level=3 + ) + sync_file = sync_file.replace('.json', '.json.gz') + with open(sync_file, 'wb') as f: + f.write(compressed_data) + else: + with open(sync_file, 'w') as f: + json.dump(sync_data, f, separators=(',', ':')) # 紧凑格式 + + # 更新缓存 + if len(self.fusion_cache) >= self.cache_size: + # 移除最旧的缓存项 + oldest_key = next(iter(self.fusion_cache)) + del self.fusion_cache[oldest_key] + + self.fusion_cache[cache_key] = sync_file return sync_file def generate_fusion_report(self): + """生成融合报告(优化版)""" if not os.path.exists(self.fusion_dir): return None - sync_files = [f for f in os.listdir(self.fusion_dir) if f.endswith('.json')] + # 快速扫描文件 + import glob + sync_files = glob.glob(os.path.join(self.fusion_dir, "*.json*")) + + # 解析文件名获取帧范围(避免读取所有文件) + frame_ids = [] + for sync_file in sync_files: + try: + # 从文件名提取帧号 + filename = os.path.basename(sync_file) + if filename.startswith('sync_'): + frame_id = int(filename.split('_')[1].split('.')[0]) + frame_ids.append(frame_id) + except: + continue report = { 'total_sync_frames': len(sync_files), - 'calibration_data': list(self.calibration_data.keys()), - 'sensor_types': set(), - 'frame_range': [] + 'calibration_data_count': len(self.calibration_data), + 'sensor_types': list(set([f.split('_')[0] for f in self.calibration_data.keys()])), + 'frame_range': [min(frame_ids), max(frame_ids)] if frame_ids else [], + 'file_sizes': { + 'total_mb': round(sum([os.path.getsize(f) for f in sync_files]) / (1024 * 1024), 2), + 'average_kb': round(np.mean([os.path.getsize(f) / 1024 for f in sync_files]), 2) if sync_files else 0 + }, + 'compression_info': { + 'compressed_files': len([f for f in sync_files if f.endswith('.gz')]), + 'compression_ratio': round( + sum([os.path.getsize(f) for f in sync_files if f.endswith('.gz')]) / + max(1, sum([os.path.getsize(f) for f in sync_files if not f.endswith('.gz')])), + 2 + ) if sync_files else 1.0 + } } - if sync_files: - frame_ids = [] - for sync_file in sync_files: - try: - frame_id = int(sync_file.split('_')[1].split('.')[0]) - frame_ids.append(frame_id) - - filepath = os.path.join(self.fusion_dir, sync_file) - with open(filepath, 'r') as f: - data = json.load(f) - - for sensor_type in data.get('sensors', {}).keys(): - report['sensor_types'].add(sensor_type) - - except: - continue - - if frame_ids: - report['frame_range'] = [min(frame_ids), max(frame_ids)] - - report['sensor_types'] = list(report['sensor_types']) - report_path = os.path.join(self.output_dir, "metadata", "fusion_report.json") with open(report_path, 'w') as f: json.dump(report, f, indent=2) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index b6f4c384c5..80313c0481 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -7,9 +7,9 @@ import math import threading import json -import cv2 -import numpy as np from datetime import datetime +import gc +import psutil from carla_utils import setup_carla_path, import_carla_module from config_manager import ConfigManager @@ -20,12 +20,49 @@ from lidar_processor import LidarProcessor, MultiSensorFusion from multi_vehicle_manager import MultiVehicleManager from v2x_communication import V2XCommunication -from sensor_enhancer import SensorDataEnhancer, SensorCalibrator, DataQualityMonitor carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() +class PerformanceMonitor: + """性能监控器""" + + def __init__(self): + self.start_time = time.time() + self.memory_samples = [] + self.cpu_samples = [] + self.frame_times = [] + + def sample_memory(self): + """采样内存使用""" + process = psutil.Process(os.getpid()) + memory_mb = process.memory_info().rss / 1024 / 1024 + self.memory_samples.append(memory_mb) + return memory_mb + + def sample_cpu(self): + """采样CPU使用""" + cpu_percent = psutil.cpu_percent(interval=0.1) + self.cpu_samples.append(cpu_percent) + return cpu_percent + + def record_frame_time(self, frame_time): + """记录帧处理时间""" + self.frame_times.append(frame_time) + + def get_performance_summary(self): + """获取性能摘要""" + return { + 'total_runtime': time.time() - self.start_time, + 'average_memory_mb': sum(self.memory_samples) / len(self.memory_samples) if self.memory_samples else 0, + 'max_memory_mb': max(self.memory_samples) if self.memory_samples else 0, + 'average_cpu_percent': sum(self.cpu_samples) / len(self.cpu_samples) if self.cpu_samples else 0, + 'average_frame_time': sum(self.frame_times) / len(self.frame_times) if self.frame_times else 0, + 'frames_per_second': 1.0 / (sum(self.frame_times) / len(self.frame_times)) if self.frame_times else 0 + } + + class Log: @staticmethod def info(msg): @@ -75,11 +112,18 @@ def create_weather(weather_type, time_of_day): class ImageProcessor: - def __init__(self, output_dir): + def __init__(self, output_dir, config=None): self.output_dir = output_dir self.stitched_dir = os.path.join(output_dir, "stitched") os.makedirs(self.stitched_dir, exist_ok=True) + # 性能配置 + self.compress_images = config.get('compress_images', True) if config else True + self.compression_quality = config.get('compression_quality', 85) if config else 85 + self.enable_memory_cache = config.get('enable_memory_cache', True) if config else True + self.image_cache = {} + self.max_cache_size = config.get('max_cache_size', 50) if config else 50 + def stitch(self, image_paths, frame_num, view_type="vehicle"): try: from PIL import Image, ImageDraw @@ -87,15 +131,37 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): Log.warning("PIL未安装,跳过图像拼接") return False + # 检查缓存 + cache_key = f"{view_type}_{frame_num}" + if self.enable_memory_cache and cache_key in self.image_cache: + # 从缓存加载 + cached_image = self.image_cache[cache_key] + output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") + cached_image.save(output_path, "JPEG", quality=self.compression_quality) + return True + positions = [(10, 10), (660, 10), (10, 390), (660, 390)] canvas = Image.new('RGB', (640 * 2 + 20, 360 * 2 + 20), (40, 40, 40)) draw = ImageDraw.Draw(canvas) + images_loaded = 0 for idx, (cam_name, img_path) in enumerate(list(image_paths.items())[:4]): if img_path and os.path.exists(img_path): try: - img = Image.open(img_path).resize((640, 360)) + # 检查图像是否已经加载到内存 + if img_path in self.image_cache: + img = self.image_cache[img_path] + else: + img = Image.open(img_path).resize((640, 360)) + # 缓存图像 + if self.enable_memory_cache: + self.image_cache[img_path] = img + # 清理缓存如果太大 + if len(self.image_cache) > self.max_cache_size: + oldest_key = next(iter(self.image_cache)) + del self.image_cache[oldest_key] + images_loaded += 1 except: img = Image.new('RGB', (640, 360), (80, 80, 80)) else: @@ -105,8 +171,25 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): draw.text((positions[idx][0] + 5, positions[idx][1] + 5), cam_name, fill=(255, 255, 200)) + if images_loaded == 0: + return False + output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") - canvas.save(output_path, "JPEG", quality=90) + + # 压缩保存 + if self.compress_images: + canvas.save(output_path, "JPEG", quality=self.compression_quality) + else: + canvas.save(output_path, "PNG") + + # 缓存结果 + if self.enable_memory_cache: + self.image_cache[cache_key] = canvas.copy() + + # 清理内存 + del canvas + gc.collect() + return True @@ -121,6 +204,10 @@ def __init__(self, world, config): random.seed(seed) Log.info(f"随机种子: {seed}") + # 性能优化:批量生成设置 + self.batch_spawn = config.get('batch_spawn', True) + self.max_spawn_attempts = config.get('max_spawn_attempts', 5) + def spawn_ego_vehicle(self): blueprint_lib = self.world.get_blueprint_library() @@ -143,23 +230,82 @@ def spawn_ego_vehicle(self): return None spawn_point = random.choice(spawn_points) - try: - vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) - vehicle.set_autopilot(True) - vehicle.apply_control(carla.VehicleControl(throttle=0.2)) - Log.info(f"主车: {vehicle.type_id}") - return vehicle - except Exception as e: - Log.warning(f"主车生成失败: {e}") - return None + + # 尝试多次生成 + for attempt in range(self.max_spawn_attempts): + try: + vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + vehicle.set_autopilot(True) + vehicle.apply_control(carla.VehicleControl(throttle=0.2)) + Log.info(f"主车: {vehicle.type_id}") + return vehicle + except Exception as e: + if attempt == self.max_spawn_attempts - 1: + Log.warning(f"主车生成失败: {e}") + else: + # 尝试不同的生成点 + spawn_point = random.choice(spawn_points) + time.sleep(0.1) + + return None def spawn_traffic(self, center_location): - vehicles = self._spawn_vehicles() + if self.batch_spawn: + vehicles = self._spawn_vehicles_batch() + else: + vehicles = self._spawn_vehicles() + pedestrians = self._spawn_pedestrians(center_location) Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人") return vehicles + pedestrians + def _spawn_vehicles_batch(self): + """批量生成车辆(提高性能)""" + blueprint_lib = self.world.get_blueprint_library() + spawn_points = self.world.get_map().get_spawn_points() + + if not spawn_points: + return 0 + + num_vehicles = min(self.config['traffic']['background_vehicles'], 10) + spawned = 0 + + # 准备批处理 + batch_commands = [] + available_points = spawn_points.copy() + random.shuffle(available_points) + + for i in range(num_vehicles): + if i >= len(available_points): + break + + try: + vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + spawn_point = available_points[i] + + # 创建生成命令 + batch_commands.append((vehicle_bp, spawn_point)) + + except: + pass + + # 批量生成 + for vehicle_bp, spawn_point in batch_commands: + try: + vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + vehicle.set_autopilot(True) + self.vehicles.append(vehicle) + spawned += 1 + except: + pass + + # 避免过快的生成速度 + if spawned % 3 == 0: + time.sleep(0.05) + + return spawned + def _spawn_vehicles(self): blueprint_lib = self.world.get_blueprint_library() spawn_points = self.world.get_map().get_spawn_points() @@ -217,19 +363,30 @@ def _spawn_pedestrians(self, center_location): def cleanup(self): Log.info("清理交通...") + # 批量销毁 + actors_to_destroy = [] + for vehicle in self.vehicles: - try: - if vehicle.is_alive: - vehicle.destroy() - except: - pass + if vehicle.is_alive: + actors_to_destroy.append(vehicle) for pedestrian in self.pedestrians: - try: - if pedestrian.is_alive: - pedestrian.destroy() - except: - pass + if pedestrian.is_alive: + actors_to_destroy.append(pedestrian) + + # 批量销毁 + batch_size = 10 + for i in range(0, len(actors_to_destroy), batch_size): + batch = actors_to_destroy[i:i + batch_size] + for actor in batch: + try: + actor.destroy() + except: + pass + + # 避免过快的销毁速度 + if i > 0 and i % 30 == 0: + time.sleep(0.1) self.vehicles.clear() self.pedestrians.clear() @@ -244,34 +401,29 @@ def __init__(self, world, config, data_dir): self.frame_counter = 0 self.last_capture_time = 0 + self.last_performance_sample = 0 self.vehicle_buffer = {} self.infra_buffer = {} self.buffer_lock = threading.Lock() - self.image_processor = ImageProcessor(data_dir) + # 性能监控 + self.performance_monitor = PerformanceMonitor() + + # 性能优化配置 + self.image_processor = ImageProcessor(data_dir, config.get('image_processing', {})) self.lidar_processor = None self.fusion_manager = None - # 新增:数据增强组件 - self.enhancer = None - self.calibrator = None - self.quality_monitor = None - - if config['enhancement']['enabled']: - self.enhancer = SensorDataEnhancer(config) - self.calibrator = SensorCalibrator(config) - self.quality_monitor = DataQualityMonitor(data_dir) - - # 创建增强数据目录 - enhanced_dir = os.path.join(data_dir, config['enhancement'].get('enhanced_dir_name', 'enhanced')) - os.makedirs(enhanced_dir, exist_ok=True) + # 批处理设置 + self.batch_size = config.get('batch_size', 5) + self.enable_async_processing = config.get('enable_async_processing', True) if config['sensors'].get('lidar_sensors', 0) > 0: - self.lidar_processor = LidarProcessor(data_dir) + self.lidar_processor = LidarProcessor(data_dir, config.get('lidar_processing', {})) if config['output'].get('save_fusion', False): - self.fusion_manager = MultiSensorFusion(data_dir) + self.fusion_manager = MultiSensorFusion(data_dir, config.get('fusion', {})) def setup_cameras(self, vehicle, center_location, vehicle_id=0): vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) @@ -350,6 +502,8 @@ def setup_lidar(self, vehicle, vehicle_id=0): def lidar_callback(lidar_data): current_time = time.time() + frame_start_time = time.time() + if current_time - self.last_capture_time >= self.config['sensors']['capture_interval']: if self.lidar_processor: try: @@ -373,6 +527,10 @@ def lidar_callback(lidar_data): except Exception as e: print(f"LiDAR处理失败: {e}") + # 记录性能 + frame_time = time.time() - frame_start_time + self.performance_monitor.record_frame_time(frame_time) + lidar_sensor.listen(lidar_callback) self.sensors.append(lidar_sensor) @@ -424,116 +582,45 @@ def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): def callback(image): current_time = time.time() + frame_start_time = time.time() if current_time - self.last_capture_time >= capture_interval: self.frame_counter += 1 self.last_capture_time = current_time - # 原始图像保存路径 - original_filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") - - # 保存原始图像 - image.save_to_disk(original_filename, carla.ColorConverter.Raw) - - # 数据增强处理 - if self.enhancer and self.config['enhancement']['enabled']: - enhanced_image = self._enhance_sensor_data(image, name, sensor_type) - - # 保存增强后的图像 - if self.config['enhancement']['save_enhanced']: - enhanced_dir = os.path.join( - self.data_dir, - self.config['enhancement'].get('enhanced_dir_name', 'enhanced'), - sensor_type, - name - ) - os.makedirs(enhanced_dir, exist_ok=True) - - enhanced_filename = os.path.join( - enhanced_dir, - f"{name}_{self.frame_counter:06d}_enhanced.png" - ) - - # 转换为RGB格式 - img_array = cv2.cvtColor(enhanced_image, cv2.COLOR_RGB2BGR) - cv2.imwrite(enhanced_filename, img_array) - - # 生成增强元数据 - metadata = { - 'frame_id': self.frame_counter, - 'sensor_type': sensor_type, - 'sensor_name': name, - 'vehicle_id': vehicle_id, - 'enhancement_methods': self.enhancer.enhancement_methods, - 'original_path': original_filename, - 'enhanced_path': enhanced_filename, - 'timestamp': datetime.now().isoformat() - } - - # 保存元数据 - meta_filename = enhanced_filename.replace('.png', '_meta.json') - with open(meta_filename, 'w', encoding='utf-8') as f: - json.dump(metadata, f, indent=2, ensure_ascii=False) - - # 质量检查 - if self.quality_monitor and self.config['output']['run_quality_check']: - quality_result = self.quality_monitor.check_image_quality(original_filename) - self.quality_monitor.update_metrics('images', quality_result) - - if not quality_result.get('valid', False): - print(f"⚠ 图像质量问题: {original_filename} - {quality_result.get('error', '')}") + filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") + image.save_to_disk(filename, carla.ColorConverter.Raw) with self.buffer_lock: if sensor_type == 'vehicle': - self.vehicle_buffer[name] = original_filename + self.vehicle_buffer[name] = filename if len(self.vehicle_buffer) >= 4: self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, f'vehicle_{vehicle_id}') self.vehicle_buffer.clear() else: - self.infra_buffer[name] = original_filename + self.infra_buffer[name] = filename if len(self.infra_buffer) >= 4: self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') self.infra_buffer.clear() - return callback + # 定期采样性能 + if current_time - self.last_performance_sample >= 5.0: + memory_mb = self.performance_monitor.sample_memory() + cpu_percent = self.performance_monitor.sample_cpu() + if self.frame_counter % 10 == 0: + Log.debug(f"性能采样 - 内存: {memory_mb:.1f}MB, CPU: {cpu_percent:.1f}%") + self.last_performance_sample = current_time - def _enhance_sensor_data(self, carla_image, name: str, sensor_type: str) -> np.ndarray: - """增强传感器数据""" - # 将CARLA图像转换为numpy数组 - img_array = np.frombuffer(carla_image.raw_data, dtype=np.uint8) - img_array = img_array.reshape((carla_image.height, carla_image.width, 4)) - img_array = img_array[:, :, :3] # 去掉alpha通道 + # 记录帧处理时间 + frame_time = time.time() - frame_start_time + self.performance_monitor.record_frame_time(frame_time) - # 根据传感器类型应用增强 - if sensor_type == 'camera': - enhanced_image = self.enhancer.enhance_image(img_array, 'camera') - else: - enhanced_image = img_array # 其他传感器暂时不增强 - - return enhanced_image - - def generate_calibration_files(self, vehicle_locations: list, - camera_positions: list): - """生成传感器校准文件""" - if self.calibrator and self.config['enhancement']['calibration_generation']: - self.calibrator.generate_calibration_files( - self.data_dir, - vehicle_locations, - camera_positions - ) - - def generate_enhancement_report(self): - """生成增强报告""" - if self.enhancer: - return self.enhancer.generate_enhancement_report(self.data_dir) - return None + # 定期垃圾回收 + if self.frame_counter % 50 == 0: + gc.collect() - def generate_quality_report(self): - """生成质量报告""" - if self.quality_monitor: - return self.quality_monitor.generate_quality_report() - return None + return callback def get_frame_count(self): return self.frame_counter @@ -543,7 +630,8 @@ def generate_sensor_summary(self): 'total_sensors': len(self.sensors), 'frame_count': self.frame_counter, 'lidar_data': None, - 'fusion_data': None + 'fusion_data': None, + 'performance': self.performance_monitor.get_performance_summary() } if self.lidar_processor: @@ -556,14 +644,33 @@ def generate_sensor_summary(self): def cleanup(self): Log.info(f"清理 {len(self.sensors)} 个传感器...") - for sensor in self.sensors: - try: - sensor.stop() - sensor.destroy() - except: - pass + + # 刷新批处理数据 + if self.lidar_processor: + self.lidar_processor.flush_batch() + + # 批量销毁传感器 + batch_size = 5 + for i in range(0, len(self.sensors), batch_size): + batch = self.sensors[i:i + batch_size] + for sensor in batch: + try: + sensor.stop() + sensor.destroy() + except: + pass + + if i > 0 and i % 20 == 0: + time.sleep(0.05) + self.sensors.clear() + # 清理缓存 + if hasattr(self.image_processor, 'image_cache'): + self.image_processor.image_cache.clear() + + gc.collect() + class DataCollector: def __init__(self, config): @@ -584,6 +691,12 @@ def __init__(self, config): self.is_running = False self.collected_frames = 0 + # 性能监控 + self.performance_monitor = PerformanceMonitor() + + # 数据格式配置 + self.output_format = config.get('output_format', 'standard') # standard, v2xformer, kitti + def setup_directories(self): scenario = self.config['scenario'] timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") @@ -603,8 +716,8 @@ def setup_directories(self): "calibration", "cooperative", "v2x_messages", - "enhanced/vehicle", - "enhanced/infrastructure", + "v2xformer_format", # V2XFormer格式数据 + "kitti_format", # KITTI格式数据 "metadata" ] @@ -700,30 +813,6 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) - # 在场景设置完成后,如果有传感器管理器,生成校准文件 - if hasattr(self, 'sensor_managers') and self.sensor_managers: - # 获取车辆和相机位置信息 - vehicle_locations = [] - camera_positions = [] - - for vehicle in self.ego_vehicles: - location = vehicle.get_location() - vehicle_locations.append({ - 'id': vehicle.id, - 'position': [location.x, location.y, location.z], - 'rotation': [0, 0, 0] - }) - - # 简化:假设相机位置相对于车辆 - camera_positions.append({ - 'translation': [2.0, 0, 1.5], # 相机相对于车辆的位置 - 'rotation': [0, 0, 0] # 相机的旋转 - }) - - # 为每个传感器管理器生成校准文件 - for sensor_manager in self.sensor_managers.values(): - sensor_manager.generate_calibration_files(vehicle_locations, camera_positions) - time.sleep(3.0) return True @@ -754,6 +843,7 @@ def collect_data(self): last_update = time.time() last_v2x_update = time.time() last_perception_share = time.time() + last_performance_sample = time.time() try: while time.time() - self.start_time < duration and self.is_running: @@ -775,40 +865,148 @@ def collect_data(self): self._share_perception_data() last_perception_share = current_time - # 定期保存共享感知 - frame_count = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - if frame_count % 10 == 0 and self.multi_vehicle_manager: - self.multi_vehicle_manager.save_shared_perception(frame_count) + # 性能采样 + if current_time - last_performance_sample >= 10.0: + memory_mb = self.performance_monitor.sample_memory() + cpu_percent = self.performance_monitor.sample_cpu() + Log.debug(f"系统性能 - 内存: {memory_mb:.1f}MB, CPU: {cpu_percent:.1f}%") + last_performance_sample = current_time + + # 定期垃圾回收 + gc.collect() if current_time - last_update >= 5.0: total_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) progress = (elapsed / duration) * 100 - Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | 总帧数: {total_frames}") + # 计算预估剩余时间 + if total_frames > 0: + frames_per_second = total_frames / elapsed + remaining_frames = (duration - elapsed) * frames_per_second + eta_seconds = (duration - elapsed) + else: + eta_seconds = duration - elapsed + + Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | " + f"总帧数: {total_frames} | " + f"ETA: {eta_seconds:.0f}秒") last_update = current_time - time.sleep(0.05) + time.sleep(0.01) # 减少CPU占用 except KeyboardInterrupt: Log.info("数据收集被用户中断") + except Exception as e: + Log.error(f"数据收集错误: {e}") + traceback.print_exc() finally: self.is_running = False elapsed = time.time() - self.start_time self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") - # 生成增强报告 - if self.config['enhancement']['enabled']: - self._generate_enhancement_reports() + # 获取性能摘要 + performance_summary = self.performance_monitor.get_performance_summary() - # 生成质量报告 - if self.config['output']['run_quality_check']: - self._generate_quality_reports() + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") + Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") self._save_metadata() self._print_summary() + # 生成标准格式数据 + if self.output_format != 'standard': + self._convert_to_target_format() + + def _convert_to_target_format(self): + """转换为目标数据格式""" + Log.info(f"转换为 {self.output_format} 格式...") + + if self.output_format == 'v2xformer': + self._convert_to_v2xformer_format() + elif self.output_format == 'kitti': + self._convert_to_kitti_format() + + def _convert_to_v2xformer_format(self): + """转换为V2XFormer格式""" + try: + # 创建必要的目录结构 + v2x_dir = os.path.join(self.output_dir, "v2xformer_format") + + # 创建数据集结构 + splits = ['train', 'val', 'test'] + for split in splits: + split_dir = os.path.join(v2x_dir, split) + os.makedirs(split_dir, exist_ok=True) + + # 创建子目录 + for subdir in ['image', 'point_cloud', 'calib', 'label']: + os.makedirs(os.path.join(split_dir, subdir), exist_ok=True) + + # 生成数据集划分 + total_frames = self.collected_frames + train_ratio = 0.7 + val_ratio = 0.2 + test_ratio = 0.1 + + train_frames = int(total_frames * train_ratio) + val_frames = int(total_frames * val_ratio) + test_frames = total_frames - train_frames - val_frames + + # 生成划分文件 + splits_info = { + 'train': list(range(0, train_frames)), + 'val': list(range(train_frames, train_frames + val_frames)), + 'test': list(range(train_frames + val_frames, total_frames)) + } + + splits_file = os.path.join(v2x_dir, "splits.json") + with open(splits_file, 'w') as f: + json.dump(splits_info, f, indent=2) + + Log.info(f"V2XFormer格式转换完成: {v2x_dir}") + + except Exception as e: + Log.error(f"V2XFormer格式转换失败: {e}") + + def _convert_to_kitti_format(self): + """转换为KITTI格式""" + try: + kitti_dir = os.path.join(self.output_dir, "kitti_format") + + # 创建KITTI标准目录结构 + for subdir in ['training', 'testing']: + full_dir = os.path.join(kitti_dir, subdir) + os.makedirs(full_dir, exist_ok=True) + + for subsubdir in ['image_2', 'velodyne', 'calib', 'label_2']: + os.makedirs(os.path.join(full_dir, subsubdir), exist_ok=True) + + # 生成KITTI格式的校准文件 + self._generate_kitti_calibration(kitti_dir) + + Log.info(f"KITTI格式转换完成: {kitti_dir}") + + except Exception as e: + Log.error(f"KITTI格式转换失败: {e}") + + def _generate_kitti_calibration(self, kitti_dir): + """生成KITTI格式的校准文件""" + calib_template = """P0: 7.215377e+02 0.000000e+00 6.095593e+02 0.000000e+00 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 +P1: 7.215377e+02 0.000000e+00 6.095593e+02 -3.875744e+02 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 +P2: 7.215377e+02 0.000000e+00 6.095593e+02 4.485728e+01 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 +P3: 7.215377e+02 0.000000e+00 6.095593e+02 -3.341729e+02 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 +R0_rect: 9.999239e-01 9.837760e-03 -7.445048e-03 -9.869795e-03 9.999421e-01 -4.278459e-03 7.402527e-03 4.351614e-03 9.999631e-01 +Tr_velo_to_cam: 4.276802e-04 -9.999672e-01 -8.084491e-03 -1.198459e-02 -7.210626e-03 8.081198e-03 -9.999413e-01 -5.403984e-02 9.999738e-01 4.859485e-04 -7.206933e-03 -2.921968e-02 +Tr_imu_to_velo: 9.999976e-01 7.553071e-04 -2.035826e-03 -8.086759e-01 -7.854027e-04 9.998898e-01 -1.482298e-02 3.195559e-01 2.024406e-03 1.482454e-02 9.998881e-01 -7.997231e-01""" + + # 为每一帧生成校准文件 + for i in range(self.collected_frames): + calib_file = os.path.join(kitti_dir, "training", "calib", f"{i:06d}.txt") + with open(calib_file, 'w') as f: + f.write(calib_template) + def _update_v2x_communication(self): """更新V2X通信""" if not self.v2x_communication: @@ -889,20 +1087,6 @@ def _simulate_object_detection(self, vehicle): return detected_objects - def _generate_enhancement_reports(self): - """生成增强报告""" - Log.info("生成增强报告...") - for sensor_manager in self.sensor_managers.values(): - if hasattr(sensor_manager, 'enhancer'): - sensor_manager.generate_enhancement_report() - - def _generate_quality_reports(self): - """生成质量报告""" - Log.info("生成质量报告...") - for sensor_manager in self.sensor_managers.values(): - if hasattr(sensor_manager, 'quality_monitor'): - sensor_manager.quality_monitor.print_quality_summary() - def _save_metadata(self): metadata = { 'scenario': self.config['scenario'], @@ -910,32 +1094,20 @@ def _save_metadata(self): 'sensors': self.config['sensors'], 'v2x': self.config['v2x'], 'cooperative': self.config['cooperative'], - 'enhancement': self.config['enhancement'], + 'output_format': self.output_format, 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), 'total_frames': self.collected_frames, 'frame_rate': round(self.collected_frames / max(time.time() - self.start_time, 0.1), 2) - } + }, + 'performance': self.performance_monitor.get_performance_summary() } # 传感器摘要 sensor_summaries = {} for vehicle_id, sensor_manager in self.sensor_managers.items(): sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() - - # 添加增强报告 - if hasattr(sensor_manager, 'enhancer'): - enhancement_report = sensor_manager.generate_enhancement_report() - if enhancement_report: - sensor_summaries[vehicle_id]['enhancement_report'] = enhancement_report - - # 添加质量报告 - if hasattr(sensor_manager, 'quality_monitor'): - quality_report = sensor_manager.generate_quality_report() - if quality_report: - sensor_summaries[vehicle_id]['quality_report'] = quality_report - metadata['sensor_summaries'] = sensor_summaries # V2X通信状态 @@ -963,54 +1135,49 @@ def _print_summary(self): for raw_dir in raw_dirs: raw_path = os.path.join(self.output_dir, raw_dir) if os.path.exists(raw_path): - # 递归统计图像文件 + # 快速统计 for root, dirs, files in os.walk(raw_path): total_raw_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) print(f"原始图像: {total_raw_images} 张") - # 统计增强图像 - if self.config['enhancement']['enabled']: - enhanced_dir = os.path.join(self.output_dir, - self.config['enhancement'].get('enhanced_dir_name', 'enhanced')) - if os.path.exists(enhanced_dir): - total_enhanced_images = 0 - for root, dirs, files in os.walk(enhanced_dir): - total_enhanced_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) - - print(f"增强图像: {total_enhanced_images} 张") - # 统计LiDAR lidar_dir = os.path.join(self.output_dir, "lidar") if os.path.exists(lidar_dir): - bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] - npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] + import glob + bin_files = glob.glob(os.path.join(lidar_dir, "*.bin")) + npy_files = glob.glob(os.path.join(lidar_dir, "*.npy")) + batch_files = glob.glob(os.path.join(lidar_dir, "*batch*.json")) print(f"LiDAR数据: {len(bin_files)} .bin文件, {len(npy_files)} .npy文件") + print(f"批处理文件: {len(batch_files)} 个") # 统计协同数据 coop_dir = os.path.join(self.output_dir, "cooperative") if os.path.exists(coop_dir): - v2x_files = len([f for f in os.listdir(os.path.join(coop_dir, "v2x_messages")) if f.endswith('.json')]) + v2x_files = len( + [f for f in os.listdir(os.path.join(coop_dir, "v2x_messages")) if f.endswith(('.json', '.gz'))]) perception_files = len( [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") - # 校准文件 - calib_dir = os.path.join(self.output_dir, "calibration") - if os.path.exists(calib_dir): - calib_files = len([f for f in os.listdir(calib_dir) if f.endswith('.json')]) - print(f"校准文件: {calib_files} 个") - - # V2X统计 - if self.v2x_communication: - v2x_status = self.v2x_communication.get_network_status() - print(f"V2X通信: {v2x_status['stats']['messages_sent']} 发送, " - f"{v2x_status['stats']['messages_received']} 接收, " - f"{v2x_status['stats']['messages_dropped']} 丢包") - - # 车辆统计 - print(f"车辆总数: {len(self.ego_vehicles)} 主车 + " - f"{len(self.multi_vehicle_manager.cooperative_vehicles)} 协同车") + # 格式转换 + if self.output_format == 'v2xformer': + v2x_dir = os.path.join(self.output_dir, "v2xformer_format") + if os.path.exists(v2x_dir): + print(f"V2XFormer格式: 已生成") + + if self.output_format == 'kitti': + kitti_dir = os.path.join(self.output_dir, "kitti_format") + if os.path.exists(kitti_dir): + print(f"KITTI格式: 已生成") + + # 性能统计 + performance = self.performance_monitor.get_performance_summary() + print(f"\n性能统计:") + print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") + print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") + print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") + print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") print(f"\n输出目录: {self.output_dir}") print("=" * 60) @@ -1052,15 +1219,18 @@ def cleanup(self): except: pass + # 强制垃圾回收 + gc.collect() + Log.info("清理完成") def main(): - parser = argparse.ArgumentParser(description='CVIPS 数据增强采集系统 v11.0') + parser = argparse.ArgumentParser(description='CVIPS 性能优化数据收集系统 v12.0') # 基础参数 parser.add_argument('--config', type=str, help='配置文件路径') - parser.add_argument('--scenario', type=str, default='enhanced_data_collection', help='场景名称') + parser.add_argument('--scenario', type=str, default='performance_optimized', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='地图') parser.add_argument('--weather', type=str, default='clear', @@ -1078,12 +1248,21 @@ def main(): parser.add_argument('--capture-interval', type=float, default=2.0, help='捕捉间隔(秒)') parser.add_argument('--seed', type=int, help='随机种子') + # 性能参数 + parser.add_argument('--batch-size', type=int, default=5, help='批处理大小') + parser.add_argument('--enable-compression', action='store_true', help='启用数据压缩') + parser.add_argument('--enable-downsampling', action='store_true', help='启用LiDAR下采样') + + # 输出格式 + parser.add_argument('--output-format', type=str, default='standard', + choices=['standard', 'v2xformer', 'kitti'], help='输出数据格式') + # 传感器参数 parser.add_argument('--enable-lidar', action='store_true', help='启用LiDAR传感器') parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') parser.add_argument('--enable-v2x', action='store_true', help='启用V2X通信') parser.add_argument('--enable-cooperative', action='store_true', help='启用协同感知') - parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') + parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') # 添加这行 parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') # 功能参数 @@ -1097,9 +1276,15 @@ def main(): config = ConfigManager.load_config(args.config) config = ConfigManager.merge_args(config, args) + # 添加性能配置 + config['performance']['batch_size'] = args.batch_size + config['performance']['enable_compression'] = args.enable_compression + config['performance']['enable_downsampling'] = args.enable_downsampling + config['output']['output_format'] = args.output_format + # 显示配置 print("\n" + "=" * 60) - print("CVIPS 数据增强采集系统 v11.0") + print("CVIPS 性能优化数据收集系统 v12.0") print("=" * 60) print(f"场景: {config['scenario']['name']}") @@ -1108,6 +1293,7 @@ def main(): print(f"时长: {config['scenario']['duration']}秒") print(f"交通: {config['traffic']['background_vehicles']}背景车辆 + {config['traffic']['pedestrians']}行人") print(f"协同: {config['cooperative']['num_coop_vehicles']} 协同车辆") + print(f"输出格式: {config['output']['output_format']}") print(f"传感器:") print( @@ -1118,6 +1304,11 @@ def main(): print(f" 协同: {'启用' if config['output']['save_cooperative'] else '禁用'}") print(f" 增强: {'启用' if config['enhancement']['enabled'] else '禁用'}") + print(f"性能:") + print(f" 批处理大小: {config['performance']['batch_size']}") + print(f" 压缩: {'启用' if config['performance']['enable_compression'] else '禁用'}") + print(f" 下采样: {'启用' if config['performance']['enable_downsampling'] else '禁用'}") + collector = DataCollector(config) try: From ad2cd135c0862c3075d35558905dddbafcbf2178 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Fri, 19 Dec 2025 21:28:12 +0800 Subject: [PATCH 05/21] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BE=9D=E8=B5=96?= =?UTF-8?q?=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../__pycache__/carla_utils.cpython-37.pyc | Bin 0 -> 3004 bytes .../__pycache__/config_manager.cpython-37.pyc | Bin 0 -> 3022 bytes src/enhance_pedestrian_safety/requirements.txt | 12 +++++++----- 3 files changed, 7 insertions(+), 5 deletions(-) create mode 100644 src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc create mode 100644 src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc diff --git a/src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc b/src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c32495fc547e598c322eb9919c8930d0429ab39 GIT binary patch literal 3004 zcmai0>rWI{6rVdYyF2?}d1`B)+q7x2CV<+sX^5qz(niyUl1i+uYbWd80R~}qduK+4 z>>90FP(f^~*dXYxk(8PgY|@Ai!2TC)=A-T`%O}3{Q$O|GJIk^vv@@CeIQQIhe{=6S z=XXD@sPJ*{{Mp)~Ua#c1C$zKr@X+`OKAjeri*OiWz86IhtN94eY9S)9T8xNTz~UJ$ z;=(TMhT4riSc2Mv`Mq4&Ykml3e7jn{{JbS(&rR89=kn88d-7_iKD2asI``mWVeqzn zemZ|+Dt~U#{$Y6e?8wr>Ovsr~n47g1&-j+X1lJa)C4EHrg7EEvPyYi7gX=*Vz?DVC z7GG)!S%gK3jExAa6b)B)Rd*dZ_GI}kDa{?nDXx_}6iqu;-6@16_%|>1WnF3B@bq|6 zJoe+j2%i>G0=bwHaK#pGuY-naQ%zwV&FHG;H_@*+9E4q}G+%|^DBlV8|4ZX%l&-G) z*kJDA-2v~3#(0eM#u~Q{RG(;URrDi9B3TmEf+!I;`xMR4OTs{7B59O*zFkdg?bcG; zaxt?JZ+pMdozPm^_rQ^=x-sBq^7^d}fT1IdEH6>wCehWS3PFIjEi74lLbt?Z%;>g! z%JF1O!=|nf%Y#*-#rhP>6FaQ4QAw6N)m}xGEwLw|YL?j5n>ZX6BY}9LuP>p=R7oc; zup05hYP4@CM6fe{3& zl}xWH1@51v*f{J@3D>wuo+3>NDZUee6QluZX;p3nGu60)>R&?Ii-sptgM(Rg36Y`I zcG^|M3;_i4V9MnncG_i#o$=-}#I7~GpxwNN7<$?Um@C)CT$OS?k67zAYEQEr0DFrY z*sEUGUJW}v4%Zgzx?;VlSZ`)^X>YIx0`>*-ZSaA@%p&9}7OGCBvhUw5Ji2UOyY6JM z+@oy%)U5d$sQM0WZ+!1i$R3)sf4*Q3k2&#uan`q9nQFD|svU#-laGT#TC{OF~nTMt&|#|yJ_&c5azPUY@h z$dBE(=SOq*FXZl>bR2`hbao5WO`1zWq3sRNZY+$IyFzFun^*1!jiEIMXf{7%c6Ky8 zwIvkKnxB^M`3L`JuY=ip2XNi_jxC+Pyl78M18?Vt<{YnMj@tO-k$hnLih3h_{h zs2o=f%iX0IiguKx{IEOXr2WkQh zAB?$StPV;EG%0aOd=Lc$H%OeG1hbu&ya|>|G)8ZEbSD^%MWL}uWBqlM#Cn0mKqAuA zmx4Qu$Qk?*AK8bvG)M+sfiYJKmC~?~5wV*R2i#`_ETqv1w4Xb`Y5acZL%Q^s)v$y; zJ8z$zavX`>0nL{wii0~?W_)%K(xP+EU|KX+mCbZa<%cfW=Wm!bV1=b6X2QPpTjBSq zrVyzGao9!bpd$2lE&rarWP%u<5RxE-UbqO2>@e?)BE>lzc1-MqYE`CRJfgk?HhYz? zVTN7>1soFG8R*uE?502{A;6W$Bg;4umt|)G=9J9sHo-7+D|QY{yKKF+MWvn2Ld^n9 Q&?ycPR${LpZIPP(1<3*HuK)l5 literal 0 HcmV?d00001 diff --git a/src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc b/src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0263ba4de5ce941487d58a12590878822af3dc48 GIT binary patch literal 3022 zcma)8Uu+yl8K2qR+uQr+7{?7s+O)2OL=HmKQb5SEX#O~*pvEc?sp(?0+U(4oH@@55 z%*@(3>kdJkK&V#1U&LfKp0`PL)`pLU7C#z*Z4MJ z1~ab^X095p$>Xu+sV)hjR zybXMrIT>FDzQU>*?=S=QsO!e*IBJFMvwq~axk&ec-mR;z-n(<_-mUd}*MBzp)o=AaPQyy4-Yv|@#|KxOwMJZpw`tKfn9w$GRRyiVMjD6~>Wv&c(~olTSQ5t4l$L`$Ah$97kI- zuyzY0rD+4=ce%C{Ow{FN?yChZbWMd_?!_&S`91BhRQQ=XOLES(&{JCu67g~8-;k7m{LLVw4I^wP zwp^gF=e}Y;FMtmhzSIZ8s0D8&(m$T+D&6)bS3^I?}OALqK`nbeP>SY=k0ZY_wr ziQr(rIBHtjkpYi<5yrY)e7-JA9?4ipZO5rfQl+U_DILEk<4B-)=F)Ef-MsnU==GPU zr=IVWq4mW=HMjkyV+Z{pa5nTG)Px8srQ%RUig^^T# zr!$rGdVaT)9)=mam*k2@?|!)X(XXecnq%6CrM40XC2jM|p;R!66At0XBPN$az%4wh zwmPxTw1rCDiu7CD%YfQ6rZmygAlQ3>Vm6Y&&q|NZ9d^t`(~A4T(01oJ#v@S}ixyFv<& zqTX`Xjwd}`!*do|E1*iw0U;%WZg<-(IK!Y-3wax#Z4~&rHHnl~X&q39jzM>z zPttKZL8pwBL#KBa&Evav4A2 z)V{uPh$v&#$VO(tnL{g=Z_JQORj55!YmD?DsNVSG!_gn#+j#4vjT^Uf z=Z|i_IlB7$IY_BesCZZEY6uw*kpfoK77K&iYvMSpZd$Gri?AI=kUDnZKy#7zbP19v z<(Wfr@->*At(gTzVx1u-7=%t3D~BI6$?j-)z$WOD?Ed%(FpBgkqfp&DP~GVeZWE~P zN0o6g`%b)BUNtF+zT0~Q@3W2tHZuzu+-WF-I(-c4bO|bbQdD}IRkBLIN6YaXK|G%<3-*0brH_PISu#q^5qzMEZl|r$>%n-+rd<96;5>KGa!EC}j7Ehumn}nIO z<0xIrs#l&NXF(+KULq#O^#sH|#xutC-e}&n>b~dD0{9=3dG4RU^yx(+CXvGZOb@}| z%M4=RJ){L@W|$#n0E1Z1=2;nLisu2tyB*h-GRzVTFo^gJvuD7o5FKU6iI)Jkb6QBt z*^08b0g^Ic4rr-lm?J&_%qg&Hp``{|{t9>{r-ihZt*DBBfTRjo9ket6BM=#5>7($O zqwCj3fB1Ox`klLjVFcnqcpjA((^t*9ZXBWWNRLo$VAKaxo# z=mPOLl81pbYq^TgSgp$ozVww6nHpV>((e6>*WHJsonk0+wV6gE4-d;1ZMi3NbrmjE zxHVDqL)bn0Atj~_QLy(Jr(?!820Y4*m4gqa_>QtBooiOK<9YbM;(5C2dEJ<$9pvkt zcPaHdg{16xEDjKcTBO1NZrX*IiLawUuoj7vNX{VH3FeH;N)Lu1{)9?2vO_J1;`(&G qQXk9iAV>{N8}S7o+JUc3eE8eSM4zQiJ2Uwyzl8}cQ7;yG$NV4Z)na7; literal 0 HcmV?d00001 diff --git a/src/enhance_pedestrian_safety/requirements.txt b/src/enhance_pedestrian_safety/requirements.txt index 6e39997b52..be67a775df 100644 --- a/src/enhance_pedestrian_safety/requirements.txt +++ b/src/enhance_pedestrian_safety/requirements.txt @@ -1,5 +1,7 @@ -carla==0.9.14 -pygame==2.1.2 -numpy==1.21.5 -Pillow==9.2.0 -icecream==2.1.3 \ No newline at end of file +numpy>=1.21.0 +opencv-python>=4.5.0 +Pillow>=9.0.0 +psutil>=5.8.0 +argparse>=1.4.0 +dataclasses>=0.6 +pycocotools>=2.0.0 \ No newline at end of file From 819c6ccd11a97d4795db03c17ddf963b467f9dc5 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Fri, 19 Dec 2025 22:35:07 +0800 Subject: [PATCH 06/21] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BE=9D=E8=B5=96?= =?UTF-8?q?=E6=96=87=E4=BB=B6=20=E6=B8=85=E9=99=A4=E4=B8=B4=E6=97=B6?= =?UTF-8?q?=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../__pycache__/carla_utils.cpython-37.pyc | Bin 3004 -> 0 bytes .../__pycache__/config_manager.cpython-37.pyc | Bin 3022 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc delete mode 100644 src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc diff --git a/src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc b/src/enhance_pedestrian_safety/__pycache__/carla_utils.cpython-37.pyc deleted file mode 100644 index 1c32495fc547e598c322eb9919c8930d0429ab39..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3004 zcmai0>rWI{6rVdYyF2?}d1`B)+q7x2CV<+sX^5qz(niyUl1i+uYbWd80R~}qduK+4 z>>90FP(f^~*dXYxk(8PgY|@Ai!2TC)=A-T`%O}3{Q$O|GJIk^vv@@CeIQQIhe{=6S z=XXD@sPJ*{{Mp)~Ua#c1C$zKr@X+`OKAjeri*OiWz86IhtN94eY9S)9T8xNTz~UJ$ z;=(TMhT4riSc2Mv`Mq4&Ykml3e7jn{{JbS(&rR89=kn88d-7_iKD2asI``mWVeqzn zemZ|+Dt~U#{$Y6e?8wr>Ovsr~n47g1&-j+X1lJa)C4EHrg7EEvPyYi7gX=*Vz?DVC z7GG)!S%gK3jExAa6b)B)Rd*dZ_GI}kDa{?nDXx_}6iqu;-6@16_%|>1WnF3B@bq|6 zJoe+j2%i>G0=bwHaK#pGuY-naQ%zwV&FHG;H_@*+9E4q}G+%|^DBlV8|4ZX%l&-G) z*kJDA-2v~3#(0eM#u~Q{RG(;URrDi9B3TmEf+!I;`xMR4OTs{7B59O*zFkdg?bcG; zaxt?JZ+pMdozPm^_rQ^=x-sBq^7^d}fT1IdEH6>wCehWS3PFIjEi74lLbt?Z%;>g! z%JF1O!=|nf%Y#*-#rhP>6FaQ4QAw6N)m}xGEwLw|YL?j5n>ZX6BY}9LuP>p=R7oc; zup05hYP4@CM6fe{3& zl}xWH1@51v*f{J@3D>wuo+3>NDZUee6QluZX;p3nGu60)>R&?Ii-sptgM(Rg36Y`I zcG^|M3;_i4V9MnncG_i#o$=-}#I7~GpxwNN7<$?Um@C)CT$OS?k67zAYEQEr0DFrY z*sEUGUJW}v4%Zgzx?;VlSZ`)^X>YIx0`>*-ZSaA@%p&9}7OGCBvhUw5Ji2UOyY6JM z+@oy%)U5d$sQM0WZ+!1i$R3)sf4*Q3k2&#uan`q9nQFD|svU#-laGT#TC{OF~nTMt&|#|yJ_&c5azPUY@h z$dBE(=SOq*FXZl>bR2`hbao5WO`1zWq3sRNZY+$IyFzFun^*1!jiEIMXf{7%c6Ky8 zwIvkKnxB^M`3L`JuY=ip2XNi_jxC+Pyl78M18?Vt<{YnMj@tO-k$hnLih3h_{h zs2o=f%iX0IiguKx{IEOXr2WkQh zAB?$StPV;EG%0aOd=Lc$H%OeG1hbu&ya|>|G)8ZEbSD^%MWL}uWBqlM#Cn0mKqAuA zmx4Qu$Qk?*AK8bvG)M+sfiYJKmC~?~5wV*R2i#`_ETqv1w4Xb`Y5acZL%Q^s)v$y; zJ8z$zavX`>0nL{wii0~?W_)%K(xP+EU|KX+mCbZa<%cfW=Wm!bV1=b6X2QPpTjBSq zrVyzGao9!bpd$2lE&rarWP%u<5RxE-UbqO2>@e?)BE>lzc1-MqYE`CRJfgk?HhYz? zVTN7>1soFG8R*uE?502{A;6W$Bg;4umt|)G=9J9sHo-7+D|QY{yKKF+MWvn2Ld^n9 Q&?ycPR${LpZIPP(1<3*HuK)l5 diff --git a/src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc b/src/enhance_pedestrian_safety/__pycache__/config_manager.cpython-37.pyc deleted file mode 100644 index 0263ba4de5ce941487d58a12590878822af3dc48..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3022 zcma)8Uu+yl8K2qR+uQr+7{?7s+O)2OL=HmKQb5SEX#O~*pvEc?sp(?0+U(4oH@@55 z%*@(3>kdJkK&V#1U&LfKp0`PL)`pLU7C#z*Z4MJ z1~ab^X095p$>Xu+sV)hjR zybXMrIT>FDzQU>*?=S=QsO!e*IBJFMvwq~axk&ec-mR;z-n(<_-mUd}*MBzp)o=AaPQyy4-Yv|@#|KxOwMJZpw`tKfn9w$GRRyiVMjD6~>Wv&c(~olTSQ5t4l$L`$Ah$97kI- zuyzY0rD+4=ce%C{Ow{FN?yChZbWMd_?!_&S`91BhRQQ=XOLES(&{JCu67g~8-;k7m{LLVw4I^wP zwp^gF=e}Y;FMtmhzSIZ8s0D8&(m$T+D&6)bS3^I?}OALqK`nbeP>SY=k0ZY_wr ziQr(rIBHtjkpYi<5yrY)e7-JA9?4ipZO5rfQl+U_DILEk<4B-)=F)Ef-MsnU==GPU zr=IVWq4mW=HMjkyV+Z{pa5nTG)Px8srQ%RUig^^T# zr!$rGdVaT)9)=mam*k2@?|!)X(XXecnq%6CrM40XC2jM|p;R!66At0XBPN$az%4wh zwmPxTw1rCDiu7CD%YfQ6rZmygAlQ3>Vm6Y&&q|NZ9d^t`(~A4T(01oJ#v@S}ixyFv<& zqTX`Xjwd}`!*do|E1*iw0U;%WZg<-(IK!Y-3wax#Z4~&rHHnl~X&q39jzM>z zPttKZL8pwBL#KBa&Evav4A2 z)V{uPh$v&#$VO(tnL{g=Z_JQORj55!YmD?DsNVSG!_gn#+j#4vjT^Uf z=Z|i_IlB7$IY_BesCZZEY6uw*kpfoK77K&iYvMSpZd$Gri?AI=kUDnZKy#7zbP19v z<(Wfr@->*At(gTzVx1u-7=%t3D~BI6$?j-)z$WOD?Ed%(FpBgkqfp&DP~GVeZWE~P zN0o6g`%b)BUNtF+zT0~Q@3W2tHZuzu+-WF-I(-c4bO|bbQdD}IRkBLIN6YaXK|G%<3-*0brH_PISu#q^5qzMEZl|r$>%n-+rd<96;5>KGa!EC}j7Ehumn}nIO z<0xIrs#l&NXF(+KULq#O^#sH|#xutC-e}&n>b~dD0{9=3dG4RU^yx(+CXvGZOb@}| z%M4=RJ){L@W|$#n0E1Z1=2;nLisu2tyB*h-GRzVTFo^gJvuD7o5FKU6iI)Jkb6QBt z*^08b0g^Ic4rr-lm?J&_%qg&Hp``{|{t9>{r-ihZt*DBBfTRjo9ket6BM=#5>7($O zqwCj3fB1Ox`klLjVFcnqcpjA((^t*9ZXBWWNRLo$VAKaxo# z=mPOLl81pbYq^TgSgp$ozVww6nHpV>((e6>*WHJsonk0+wV6gE4-d;1ZMi3NbrmjE zxHVDqL)bn0Atj~_QLy(Jr(?!820Y4*m4gqa_>QtBooiOK<9YbM;(5C2dEJ<$9pvkt zcPaHdg{16xEDjKcTBO1NZrX*IiLawUuoj7vNX{VH3FeH;N)Lu1{)9?2vO_J1;`(&G qQXk9iAV>{N8}S7o+JUc3eE8eSM4zQiJ2Uwyzl8}cQ7;yG$NV4Z)na7; From e2774e71698527c7a2cd407a887f64026e6c75ba Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sat, 20 Dec 2025 10:08:32 +0800 Subject: [PATCH 07/21] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=20gzip=20=E5=AF=BC?= =?UTF-8?q?=E5=85=A5=E9=97=AE=E9=A2=98=E4=BF=AE=E5=A4=8D=E6=80=A7=E8=83=BD?= =?UTF-8?q?=E7=9B=91=E6=8E=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../lidar_processor.py | 99 ++- src/enhance_pedestrian_safety/main.py | 762 ++++++++++++++---- .../multi_vehicle_manager.py | 150 ++-- 3 files changed, 792 insertions(+), 219 deletions(-) diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index c9a960ac5f..da2590994e 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -7,6 +7,7 @@ from datetime import datetime import zlib import pickle +import gzip class LidarProcessor: @@ -216,34 +217,86 @@ def _save_as_v2xformer_format(self, points, frame_num): v2x_dir = os.path.join(self.output_dir, "v2xformer_format") os.makedirs(v2x_dir, exist_ok=True) - # 创建V2XFormer格式的数据结构 - v2x_data = { - 'frame_id': frame_num, - 'timestamp': datetime.now().timestamp(), - 'point_cloud': { - 'points': points.tolist(), - 'num_points': points.shape[0], - 'range': [np.min(points[:, 0]), np.max(points[:, 0]), - np.min(points[:, 1]), np.max(points[:, 1]), - np.min(points[:, 2]), np.max(points[:, 2])] - }, - 'metadata': { - 'sensor_type': 'lidar', - 'format_version': '1.0', - 'coordinate_system': 'carla_world' + try: + # 创建V2XFormer格式的数据结构 + v2x_data = { + 'frame_id': frame_num, + 'timestamp': datetime.now().timestamp(), + 'point_cloud': { + 'points': points.tolist(), + 'num_points': points.shape[0], + 'range': [float(points[:, 0].min()), float(points[:, 0].max()), + float(points[:, 1].min()), float(points[:, 1].max()), + float(points[:, 2].min()), float(points[:, 2].max())] + }, + 'metadata': { + 'sensor_type': 'lidar', + 'format_version': '1.0', + 'coordinate_system': 'carla_world', + 'frame_rate': 10.0 + } } - } - # 保存为压缩的JSON格式 - filename = f"{frame_num:06d}.pkl.gz" - filepath = os.path.join(v2x_dir, filename) + # 保存为压缩的JSON格式 + filename = f"{frame_num:06d}.pkl.gz" + filepath = os.path.join(v2x_dir, filename) + + # 使用pickle+gzip压缩保存 + with gzip.open(filepath, 'wb') as f: + pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) + + file_size = os.path.getsize(filepath) / 1024 # KB + print(f"保存V2XFormer格式: {filepath} ({file_size:.2f} KB)") + + return filepath + + except Exception as e: + # 如果保存失败,只打印警告,不抛出异常 + print(f"警告: 保存V2XFormer格式失败: {e}") + return None + + def process_lidar_data(self, lidar_data, frame_num): + with self.data_lock: + try: + self.frame_counter = frame_num + + points = self._carla_lidar_to_numpy(lidar_data) + + if points is None or points.shape[0] == 0: + print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") + return None - # 使用pickle+gzip压缩保存 - with gzip.open(filepath, 'wb') as f: - pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) + # 下采样以减少内存使用 + if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: + original_count = points.shape[0] + points = self._downsample_point_cloud(points) + print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") - return filepath + # 添加到批处理 + self.point_cloud_batch.append((frame_num, points)) + # 如果达到批处理大小,保存批处理数据 + if len(self.point_cloud_batch) >= self.batch_size: + self._save_batch() + + # 保存单个文件(向后兼容) + bin_path = self._save_as_bin(points, frame_num) + npy_path = self._save_as_npy(points, frame_num) + + # 生成V2XFormer兼容格式(如果失败则忽略) + try: + v2xformer_path = self._save_as_v2xformer_format(points, frame_num) + except Exception as e: + v2xformer_path = None + print(f"警告: V2XFormer格式保存失败: {e}") + + metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) + + return metadata + + except Exception as e: + print(f"处理LiDAR数据失败: {e}") + return None def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): metadata = { 'frame_id': self.frame_counter, diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 80313c0481..990a4d0db5 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -10,6 +10,7 @@ from datetime import datetime import gc import psutil +import numpy as np from carla_utils import setup_carla_path, import_carla_module from config_manager import ConfigManager @@ -33,19 +34,131 @@ def __init__(self): self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] + self.gpu_memory_samples = [] + self.disk_io_samples = [] + self.network_io_samples = [] + + # 初始化第一个样本,避免空列表 + self.sample_memory() + self.sample_cpu() def sample_memory(self): """采样内存使用""" - process = psutil.Process(os.getpid()) - memory_mb = process.memory_info().rss / 1024 / 1024 - self.memory_samples.append(memory_mb) - return memory_mb + try: + process = psutil.Process(os.getpid()) + memory_mb = process.memory_info().rss / 1024 / 1024 + self.memory_samples.append(memory_mb) + + # 采样系统内存 + system_memory = psutil.virtual_memory() + return { + 'process_mb': memory_mb, + 'system_total_mb': system_memory.total / 1024 / 1024, + 'system_used_percent': system_memory.percent, + 'system_available_mb': system_memory.available / 1024 / 1024 + } + except Exception as e: + # 如果采样失败,返回默认值 + memory_mb = 0 + self.memory_samples.append(memory_mb) + return { + 'process_mb': memory_mb, + 'system_total_mb': 0, + 'system_used_percent': 0, + 'system_available_mb': 0 + } def sample_cpu(self): """采样CPU使用""" - cpu_percent = psutil.cpu_percent(interval=0.1) - self.cpu_samples.append(cpu_percent) - return cpu_percent + try: + cpu_percent = psutil.cpu_percent(interval=0.1) + self.cpu_samples.append(cpu_percent) + + # 采样每个核心的CPU使用率 + cpu_per_core = psutil.cpu_percent(interval=0.1, percpu=True) + return { + 'total_percent': cpu_percent, + 'per_core': cpu_per_core, + 'count': psutil.cpu_count() + } + except Exception as e: + # 如果采样失败,返回默认值 + cpu_percent = 0 + self.cpu_samples.append(cpu_percent) + return { + 'total_percent': cpu_percent, + 'per_core': [0], + 'count': 1 + } + + def sample_gpu_memory(self): + """采样GPU内存(如果可用)""" + try: + # 尝试导入PyTorch或TensorFlow来获取GPU信息 + try: + import torch + if torch.cuda.is_available(): + allocated = torch.cuda.memory_allocated() / 1024 / 1024 + cached = torch.cuda.memory_reserved() / 1024 / 1024 + self.gpu_memory_samples.append(allocated) + return { + 'allocated_mb': allocated, + 'cached_mb': cached, + 'device_count': torch.cuda.device_count() + } + except ImportError: + pass + + try: + import tensorflow as tf + gpus = tf.config.list_physical_devices('GPU') + if gpus: + # TensorFlow的GPU内存监控比较复杂,这里简单返回 + self.gpu_memory_samples.append(0) + return { + 'gpu_count': len(gpus), + 'allocated_mb': 0 + } + except ImportError: + pass + except Exception as e: + pass + + return {'available': False} + + def sample_disk_io(self): + """采样磁盘IO""" + try: + disk_io = psutil.disk_io_counters() + read_mb = disk_io.read_bytes / 1024 / 1024 if disk_io else 0 + self.disk_io_samples.append(read_mb) + return { + 'read_mb': read_mb, + 'write_mb': disk_io.write_bytes / 1024 / 1024 if disk_io else 0, + 'read_count': disk_io.read_count if disk_io else 0, + 'write_count': disk_io.write_count if disk_io else 0 + } + except: + read_mb = 0 + self.disk_io_samples.append(read_mb) + return None + + def sample_network_io(self): + """采样网络IO""" + try: + net_io = psutil.net_io_counters() + sent_kb = net_io.bytes_sent / 1024 if net_io else 0 + self.network_io_samples.append(sent_kb) + return { + 'sent_kb': sent_kb, + 'recv_kb': net_io.bytes_recv / 1024 if net_io else 0, + 'packets_sent': net_io.packets_sent if net_io else 0, + 'packets_recv': net_io.packets_recv if net_io else 0 + } + except: + sent_kb = 0 + self.network_io_samples.append(sent_kb) + return None def record_frame_time(self, frame_time): """记录帧处理时间""" @@ -53,32 +166,97 @@ def record_frame_time(self, frame_time): def get_performance_summary(self): """获取性能摘要""" - return { + if not self.frame_times: + avg_frame_time = 0 + fps = 0 + else: + avg_frame_time = np.mean(self.frame_times) + fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0 + + summary = { 'total_runtime': time.time() - self.start_time, - 'average_memory_mb': sum(self.memory_samples) / len(self.memory_samples) if self.memory_samples else 0, + 'average_memory_mb': np.mean(self.memory_samples) if self.memory_samples else 0, 'max_memory_mb': max(self.memory_samples) if self.memory_samples else 0, - 'average_cpu_percent': sum(self.cpu_samples) / len(self.cpu_samples) if self.cpu_samples else 0, - 'average_frame_time': sum(self.frame_times) / len(self.frame_times) if self.frame_times else 0, - 'frames_per_second': 1.0 / (sum(self.frame_times) / len(self.frame_times)) if self.frame_times else 0 + 'min_memory_mb': min(self.memory_samples) if self.memory_samples else 0, + 'average_cpu_percent': np.mean(self.cpu_samples) if self.cpu_samples else 0, + 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, + 'average_frame_time': avg_frame_time, + 'frames_per_second': fps, + 'total_frames': len(self.frame_times), + 'frame_time_stats': { + 'p50': np.percentile(self.frame_times, 50) if self.frame_times else 0, + 'p95': np.percentile(self.frame_times, 95) if self.frame_times else 0, + 'p99': np.percentile(self.frame_times, 99) if self.frame_times else 0, + 'std': np.std(self.frame_times) if self.frame_times else 0 + } } + # 添加GPU信息 + if self.gpu_memory_samples: + summary['gpu_memory'] = { + 'average_mb': np.mean(self.gpu_memory_samples), + 'max_mb': max(self.gpu_memory_samples) + } + + # 添加磁盘IO信息 + if self.disk_io_samples: + summary['disk_io'] = { + 'total_read_mb': sum(self.disk_io_samples), + 'average_read_mb': np.mean(self.disk_io_samples) + } + + # 添加网络IO信息 + if self.network_io_samples: + summary['network_io'] = { + 'total_sent_kb': sum(self.network_io_samples), + 'average_sent_kb': np.mean(self.network_io_samples) + } + + return summary + + def get_realtime_metrics(self): + """获取实时性能指标""" + try: + return { + 'memory_mb': psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024, + 'cpu_percent': psutil.cpu_percent(interval=0.1), + 'frame_rate': 1.0 / self.frame_times[-1] if self.frame_times else 0, + 'active_threads': threading.active_count() + } + except: + return { + 'memory_mb': 0, + 'cpu_percent': 0, + 'frame_rate': 0, + 'active_threads': 0 + } + class Log: @staticmethod def info(msg): - print(f"[INFO] {msg}") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[INFO][{timestamp}] {msg}") @staticmethod def warning(msg): - print(f"[WARNING] {msg}") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[WARNING][{timestamp}] {msg}") @staticmethod def error(msg): - print(f"[ERROR] {msg}") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[ERROR][{timestamp}] {msg}") @staticmethod def debug(msg): - print(f"[DEBUG] {msg}") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[DEBUG][{timestamp}] {msg}") + + @staticmethod + def performance(msg): + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[PERF][{timestamp}] {msg}") class WeatherSystem: @@ -124,6 +302,14 @@ def __init__(self, output_dir, config=None): self.image_cache = {} self.max_cache_size = config.get('max_cache_size', 50) if config else 50 + # 性能统计 + self.stats = { + 'images_processed': 0, + 'cache_hits': 0, + 'cache_misses': 0, + 'total_processing_time': 0 + } + def stitch(self, image_paths, frame_num, view_type="vehicle"): try: from PIL import Image, ImageDraw @@ -131,15 +317,36 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): Log.warning("PIL未安装,跳过图像拼接") return False + start_time = time.time() + # 检查缓存 cache_key = f"{view_type}_{frame_num}" if self.enable_memory_cache and cache_key in self.image_cache: # 从缓存加载 cached_image = self.image_cache[cache_key] output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") - cached_image.save(output_path, "JPEG", quality=self.compression_quality) + + # 使用更快的保存方式 + try: + if self.compress_images: + cached_image.save(output_path, "JPEG", + quality=self.compression_quality, + optimize=True, + progressive=True) + else: + cached_image.save(output_path, "PNG", optimize=True) + except Exception as e: + Log.error(f"保存缓存图像失败: {e}") + return False + + self.stats['cache_hits'] += 1 + self.stats['images_processed'] += 1 + processing_time = time.time() - start_time + self.stats['total_processing_time'] += processing_time return True + self.stats['cache_misses'] += 1 + positions = [(10, 10), (660, 10), (10, 390), (660, 390)] canvas = Image.new('RGB', (640 * 2 + 20, 360 * 2 + 20), (40, 40, 40)) @@ -153,16 +360,22 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): if img_path in self.image_cache: img = self.image_cache[img_path] else: - img = Image.open(img_path).resize((640, 360)) + # 使用更快的图像加载方式 + img = Image.open(img_path) + # 预加载图像数据到内存 + img.load() + img = img.resize((640, 360), Image.Resampling.LANCZOS) + # 缓存图像 if self.enable_memory_cache: self.image_cache[img_path] = img # 清理缓存如果太大 if len(self.image_cache) > self.max_cache_size: - oldest_key = next(iter(self.image_cache)) - del self.image_cache[oldest_key] + # 使用LRU策略清理缓存 + self._cleanup_cache() images_loaded += 1 - except: + except Exception as e: + Log.warning(f"加载图像失败: {e}") img = Image.new('RGB', (640, 360), (80, 80, 80)) else: img = Image.new('RGB', (640, 360), (80, 80, 80)) @@ -176,11 +389,21 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") - # 压缩保存 - if self.compress_images: - canvas.save(output_path, "JPEG", quality=self.compression_quality) - else: - canvas.save(output_path, "PNG") + # 使用优化的保存参数 + try: + if self.compress_images: + # 使用更快的JPEG保存选项 + canvas.save(output_path, "JPEG", + quality=self.compression_quality, + optimize=True, + progressive=True, + subsampling='4:2:0') + else: + # PNG优化 + canvas.save(output_path, "PNG", optimize=True) + except Exception as e: + Log.error(f"保存图像失败: {e}") + return False # 缓存结果 if self.enable_memory_cache: @@ -190,8 +413,47 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): del canvas gc.collect() + self.stats['images_processed'] += 1 + processing_time = time.time() - start_time + self.stats['total_processing_time'] += processing_time + + # 记录性能日志(每50帧记录一次) + if self.stats['images_processed'] % 50 == 0: + avg_time = self.stats['total_processing_time'] / self.stats['images_processed'] + cache_hit_rate = self.stats['cache_hits'] / max(1, self.stats['cache_hits'] + self.stats['cache_misses']) + Log.performance(f"图像处理统计: 处理{self.stats['images_processed']}张, " + f"平均{avg_time:.3f}秒/张, 缓存命中率{cache_hit_rate:.1%}") + return True + def _cleanup_cache(self): + """清理图像缓存""" + if len(self.image_cache) > self.max_cache_size: + # 移除最旧的缓存项(简单实现) + keys_to_remove = list(self.image_cache.keys())[:len(self.image_cache) - self.max_cache_size] + for key in keys_to_remove: + del self.image_cache[key] + Log.debug(f"清理缓存: 移除了{len(keys_to_remove)}个缓存项") + + def get_stats(self): + """获取处理统计""" + total_operations = self.stats['cache_hits'] + self.stats['cache_misses'] + if total_operations > 0: + cache_hit_rate = self.stats['cache_hits'] / total_operations + else: + cache_hit_rate = 0 + + avg_time = 0 + if self.stats['images_processed'] > 0: + avg_time = self.stats['total_processing_time'] / self.stats['images_processed'] + + return { + **self.stats, + 'cache_hit_rate': cache_hit_rate, + 'average_processing_time': avg_time, + 'current_cache_size': len(self.image_cache) + } + class TrafficManager: def __init__(self, world, config): @@ -208,6 +470,14 @@ def __init__(self, world, config): self.batch_spawn = config.get('batch_spawn', True) self.max_spawn_attempts = config.get('max_spawn_attempts', 5) + # 性能统计 + self.spawn_stats = { + 'total_attempts': 0, + 'successful_spawns': 0, + 'failed_spawns': 0, + 'total_spawn_time': 0 + } + def spawn_ego_vehicle(self): blueprint_lib = self.world.get_blueprint_library() @@ -233,13 +503,21 @@ def spawn_ego_vehicle(self): # 尝试多次生成 for attempt in range(self.max_spawn_attempts): + self.spawn_stats['total_attempts'] += 1 try: + start_time = time.time() vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) vehicle.set_autopilot(True) vehicle.apply_control(carla.VehicleControl(throttle=0.2)) - Log.info(f"主车: {vehicle.type_id}") + + spawn_time = time.time() - start_time + self.spawn_stats['total_spawn_time'] += spawn_time + self.spawn_stats['successful_spawns'] += 1 + + Log.info(f"主车: {vehicle.type_id}, 生成时间: {spawn_time:.3f}秒") return vehicle except Exception as e: + self.spawn_stats['failed_spawns'] += 1 if attempt == self.max_spawn_attempts - 1: Log.warning(f"主车生成失败: {e}") else: @@ -250,6 +528,8 @@ def spawn_ego_vehicle(self): return None def spawn_traffic(self, center_location): + start_time = time.time() + if self.batch_spawn: vehicles = self._spawn_vehicles_batch() else: @@ -257,7 +537,14 @@ def spawn_traffic(self, center_location): pedestrians = self._spawn_pedestrians(center_location) - Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人") + total_time = time.time() - start_time + Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人, 用时: {total_time:.2f}秒") + + # 记录性能统计 + success_rate = self.spawn_stats['successful_spawns'] / max(1, self.spawn_stats['total_attempts']) + avg_spawn_time = self.spawn_stats['total_spawn_time'] / max(1, self.spawn_stats['successful_spawns']) + Log.performance(f"生成统计: 成功率{success_rate:.1%}, 平均生成时间{avg_spawn_time:.3f}秒") + return vehicles + pedestrians def _spawn_vehicles_batch(self): @@ -297,7 +584,12 @@ def _spawn_vehicles_batch(self): vehicle.set_autopilot(True) self.vehicles.append(vehicle) spawned += 1 + + self.spawn_stats['successful_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 except: + self.spawn_stats['failed_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 pass # 避免过快的生成速度 @@ -324,7 +616,12 @@ def _spawn_vehicles(self): vehicle.set_autopilot(True) self.vehicles.append(vehicle) spawned += 1 + + self.spawn_stats['successful_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 except: + self.spawn_stats['failed_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 pass return spawned @@ -355,7 +652,12 @@ def _spawn_pedestrians(self, center_location): pedestrian = self.world.spawn_actor(ped_bp, carla.Transform(location)) self.pedestrians.append(pedestrian) spawned += 1 + + self.spawn_stats['successful_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 except Exception as e: + self.spawn_stats['failed_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 Log.debug(f"行人生成失败: {e}") return spawned @@ -391,6 +693,14 @@ def cleanup(self): self.vehicles.clear() self.pedestrians.clear() + # 清理统计 + self.spawn_stats = { + 'total_attempts': 0, + 'successful_spawns': 0, + 'failed_spawns': 0, + 'total_spawn_time': 0 + } + class SensorManager: def __init__(self, world, config, data_dir): @@ -407,6 +717,9 @@ def __init__(self, world, config, data_dir): self.infra_buffer = {} self.buffer_lock = threading.Lock() + # 添加运行状态标志 + self.is_running = True + # 性能监控 self.performance_monitor = PerformanceMonitor() @@ -425,7 +738,17 @@ def __init__(self, world, config, data_dir): if config['output'].get('save_fusion', False): self.fusion_manager = MultiSensorFusion(data_dir, config.get('fusion', {})) + # 传感器统计 + self.sensor_stats = { + 'total_images': 0, + 'total_lidar_frames': 0, + 'image_capture_times': [], + 'lidar_processing_times': [], + 'frame_drop_count': 0 + } + def setup_cameras(self, vehicle, center_location, vehicle_id=0): + """设置摄像头 - 修复的方法""" vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) infra_cams = self._setup_infrastructure_cameras(center_location) @@ -501,44 +824,59 @@ def setup_lidar(self, vehicle, vehicle_id=0): lidar_sensor = self.world.spawn_actor(lidar_bp, lidar_transform, attach_to=vehicle) def lidar_callback(lidar_data): - current_time = time.time() - frame_start_time = time.time() + # 检查是否正在关闭 + if not self.is_running: + return - if current_time - self.last_capture_time >= self.config['sensors']['capture_interval']: - if self.lidar_processor: - try: - metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) - if metadata and self.fusion_manager: - vehicle_image_path = None - with self.buffer_lock: - if self.vehicle_buffer: - for cam_name, img_path in self.vehicle_buffer.items(): - if os.path.exists(img_path): - vehicle_image_path = img_path - break - - sensor_data = { - 'lidar': os.path.join(self.data_dir, "lidar", f"lidar_{self.frame_counter:06d}.bin") - } - if vehicle_image_path: - sensor_data['camera'] = vehicle_image_path - - self.fusion_manager.create_synchronization_file(self.frame_counter, sensor_data) - except Exception as e: - print(f"LiDAR处理失败: {e}") - - # 记录性能 - frame_time = time.time() - frame_start_time - self.performance_monitor.record_frame_time(frame_time) + try: + current_time = time.time() + frame_start_time = time.time() + + if current_time - self.last_capture_time >= self.config['sensors']['capture_interval']: + if self.lidar_processor: + try: + start_process = time.time() + metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) + process_time = time.time() - start_process + self.sensor_stats['lidar_processing_times'].append(process_time) + self.sensor_stats['total_lidar_frames'] += 1 + + if metadata and self.fusion_manager: + vehicle_image_path = None + with self.buffer_lock: + if self.vehicle_buffer: + for cam_name, img_path in self.vehicle_buffer.items(): + if os.path.exists(img_path): + vehicle_image_path = img_path + break + + sensor_data = { + 'lidar': os.path.join(self.data_dir, "lidar", + f"lidar_{self.frame_counter:06d}.bin") + } + if vehicle_image_path: + sensor_data['camera'] = vehicle_image_path + + self.fusion_manager.create_synchronization_file(self.frame_counter, sensor_data) + except Exception as e: + if self.is_running: + Log.error(f"LiDAR处理失败: {e}") + + # 记录性能 + frame_time = time.time() - frame_start_time + self.performance_monitor.record_frame_time(frame_time) + except Exception as e: + if self.is_running: + Log.error(f"LiDAR回调错误: {e}") lidar_sensor.listen(lidar_callback) self.sensors.append(lidar_sensor) - print("LiDAR传感器已安装") + Log.info("LiDAR传感器已安装") return 1 except Exception as e: - print(f"LiDAR安装失败: {e}") + Log.error(f"LiDAR安装失败: {e}") return 0 def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): @@ -581,44 +919,70 @@ def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): capture_interval = self.config['sensors']['capture_interval'] def callback(image): - current_time = time.time() - frame_start_time = time.time() - - if current_time - self.last_capture_time >= capture_interval: - self.frame_counter += 1 - self.last_capture_time = current_time - - filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") - image.save_to_disk(filename, carla.ColorConverter.Raw) - - with self.buffer_lock: - if sensor_type == 'vehicle': - self.vehicle_buffer[name] = filename - if len(self.vehicle_buffer) >= 4: - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, - f'vehicle_{vehicle_id}') - self.vehicle_buffer.clear() - else: - self.infra_buffer[name] = filename - if len(self.infra_buffer) >= 4: - self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') - self.infra_buffer.clear() - - # 定期采样性能 - if current_time - self.last_performance_sample >= 5.0: - memory_mb = self.performance_monitor.sample_memory() - cpu_percent = self.performance_monitor.sample_cpu() - if self.frame_counter % 10 == 0: - Log.debug(f"性能采样 - 内存: {memory_mb:.1f}MB, CPU: {cpu_percent:.1f}%") - self.last_performance_sample = current_time - - # 记录帧处理时间 - frame_time = time.time() - frame_start_time - self.performance_monitor.record_frame_time(frame_time) - - # 定期垃圾回收 - if self.frame_counter % 50 == 0: - gc.collect() + # 检查是否正在关闭 + if not self.is_running: + return + + try: + current_time = time.time() + frame_start_time = time.time() + + if current_time - self.last_capture_time >= capture_interval: + self.frame_counter += 1 + self.last_capture_time = current_time + + capture_start = time.time() + filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") + image.save_to_disk(filename, carla.ColorConverter.Raw) + capture_time = time.time() - capture_start + + self.sensor_stats['image_capture_times'].append(capture_time) + self.sensor_stats['total_images'] += 1 + + with self.buffer_lock: + if sensor_type == 'vehicle': + self.vehicle_buffer[name] = filename + if len(self.vehicle_buffer) >= 4: + self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, + f'vehicle_{vehicle_id}') + self.vehicle_buffer.clear() + else: + self.infra_buffer[name] = filename + if len(self.infra_buffer) >= 4: + self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') + self.infra_buffer.clear() + + # 定期采样性能 + if current_time - self.last_performance_sample >= 5.0: + memory_info = self.performance_monitor.sample_memory() + cpu_info = self.performance_monitor.sample_cpu() + gpu_info = self.performance_monitor.sample_gpu_memory() + + if self.frame_counter % 10 == 0: + Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " + f"CPU: {cpu_info['total_percent']:.1f}%, " + f"线程数: {threading.active_count()}") + + self.last_performance_sample = current_time + + # 记录帧处理时间 + frame_time = time.time() - frame_start_time + self.performance_monitor.record_frame_time(frame_time) + + # 定期垃圾回收 + if self.frame_counter % 50 == 0: + gc.collect() + + # 记录传感器统计 + if self.sensor_stats['total_images'] > 0: + avg_capture_time = np.mean(self.sensor_stats['image_capture_times'][-100:]) if len( + self.sensor_stats['image_capture_times']) > 0 else 0 + Log.performance(f"传感器统计: 图像{self.sensor_stats['total_images']}张, " + f"平均捕获时间{avg_capture_time:.3f}秒") + except Exception as e: + # 如果在关闭过程中发生错误,忽略它 + if self.is_running: + Log.error(f"传感器回调错误: {e}") return callback @@ -631,46 +995,87 @@ def generate_sensor_summary(self): 'frame_count': self.frame_counter, 'lidar_data': None, 'fusion_data': None, - 'performance': self.performance_monitor.get_performance_summary() + 'performance': self.performance_monitor.get_performance_summary(), + 'sensor_stats': self.sensor_stats } + # 计算统计信息 + if self.sensor_stats['image_capture_times']: + summary['sensor_stats']['avg_image_capture_time'] = np.mean(self.sensor_stats['image_capture_times']) + summary['sensor_stats']['max_image_capture_time'] = np.max(self.sensor_stats['image_capture_times']) + + if self.sensor_stats['lidar_processing_times']: + summary['sensor_stats']['avg_lidar_process_time'] = np.mean(self.sensor_stats['lidar_processing_times']) + summary['sensor_stats']['max_lidar_process_time'] = np.max(self.sensor_stats['lidar_processing_times']) + if self.lidar_processor: summary['lidar_data'] = self.lidar_processor.generate_lidar_summary() if self.fusion_manager: summary['fusion_data'] = self.fusion_manager.generate_fusion_report() + # 图像处理器统计 + summary['image_processor_stats'] = self.image_processor.get_stats() + return summary def cleanup(self): - Log.info(f"清理 {len(self.sensors)} 个传感器...") + """安全清理传感器""" + Log.info(f"安全清理 {len(self.sensors)} 个传感器...") + + # 设置运行状态为False,防止回调函数继续执行 + self.is_running = False + + # 等待一小段时间让回调函数结束 + time.sleep(0.1) # 刷新批处理数据 if self.lidar_processor: - self.lidar_processor.flush_batch() + try: + self.lidar_processor.flush_batch() + except Exception as e: + Log.warning(f"刷新LiDAR批处理数据失败: {e}") - # 批量销毁传感器 - batch_size = 5 - for i in range(0, len(self.sensors), batch_size): - batch = self.sensors[i:i + batch_size] - for sensor in batch: + # 批量销毁传感器(从后向前销毁,避免依赖问题) + if self.sensors: + Log.info(f"销毁 {len(self.sensors)} 个传感器...") + + # 首先停止所有传感器的监听 + for sensor in self.sensors: try: - sensor.stop() - sensor.destroy() - except: - pass + if sensor and sensor.is_alive: + sensor.stop() + except Exception as e: + Log.debug(f"停止传感器失败: {e}") - if i > 0 and i % 20 == 0: - time.sleep(0.05) + # 等待一小段时间让传感器完全停止 + time.sleep(0.05) + + # 然后销毁传感器 + for i, sensor in enumerate(reversed(self.sensors)): + try: + if sensor and sensor.is_alive: + sensor.destroy() + except Exception as e: + Log.debug(f"销毁传感器失败: {e}") + + # 分批销毁,避免一次性销毁太多 + if i % 5 == 0: + time.sleep(0.01) self.sensors.clear() # 清理缓存 if hasattr(self.image_processor, 'image_cache'): - self.image_processor.image_cache.clear() + try: + self.image_processor.image_cache.clear() + except: + pass gc.collect() + Log.info("传感器清理完成") + class DataCollector: def __init__(self, config): @@ -817,6 +1222,7 @@ def setup_scene(self): return True def setup_sensors(self): + """设置传感器 - 修复的方法""" # 为每个主车设置传感器 for i, vehicle in enumerate(self.ego_vehicles): sensor_manager = SensorManager(self.world, self.config, self.output_dir) @@ -844,6 +1250,7 @@ def collect_data(self): last_v2x_update = time.time() last_perception_share = time.time() last_performance_sample = time.time() + last_detailed_log = time.time() try: while time.time() - self.start_time < duration and self.is_running: @@ -867,9 +1274,30 @@ def collect_data(self): # 性能采样 if current_time - last_performance_sample >= 10.0: - memory_mb = self.performance_monitor.sample_memory() - cpu_percent = self.performance_monitor.sample_cpu() - Log.debug(f"系统性能 - 内存: {memory_mb:.1f}MB, CPU: {cpu_percent:.1f}%") + memory_info = self.performance_monitor.sample_memory() + cpu_info = self.performance_monitor.sample_cpu() + disk_info = self.performance_monitor.sample_disk_io() + network_info = self.performance_monitor.sample_network_io() + + # 详细性能日志(每分钟一次) + if current_time - last_detailed_log >= 60.0: + Log.performance(f"详细性能监控:") + Log.performance(f" 进程内存: {memory_info['process_mb']:.1f}MB") + Log.performance(f" 系统内存: {memory_info['system_used_percent']:.1f}%使用率") + Log.performance(f" CPU: {cpu_info['total_percent']:.1f}% ({cpu_info['count']}核心)") + if disk_info: + Log.performance( + f" 磁盘IO: 读{disk_info['read_mb']:.1f}MB, 写{disk_info['write_mb']:.1f}MB") + if network_info: + Log.performance( + f" 网络IO: 发{network_info['sent_kb']:.1f}KB, 收{network_info['recv_kb']:.1f}KB") + last_detailed_log = current_time + else: + # 简化性能日志 + Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " + f"CPU: {cpu_info['total_percent']:.1f}%, " + f"活跃线程: {threading.active_count()}") + last_performance_sample = current_time # 定期垃圾回收 @@ -911,6 +1339,7 @@ def collect_data(self): Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") + Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") self._save_metadata() self._print_summary() @@ -1175,9 +1604,15 @@ def _print_summary(self): performance = self.performance_monitor.get_performance_summary() print(f"\n性能统计:") print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") + print(f" 帧时统计:") + print(f" 平均: {performance['average_frame_time']:.3f}秒") + print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") + print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") + print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") + print(f" 总帧数: {performance['total_frames']}") print(f"\n输出目录: {self.output_dir}") print("=" * 60) @@ -1193,36 +1628,89 @@ def run_analysis(self): DataAnalyzer.analyze_dataset(self.output_dir) def cleanup(self): - Log.info("清理场景...") + """安全清理所有资源 - 修复的方法""" + Log.info("开始安全清理场景...") - # 清理传感器 - for sensor_manager in self.sensor_managers.values(): - sensor_manager.cleanup() + try: + # 1. 先停止数据收集 + self.is_running = False - # 清理交通 - if self.traffic_manager: - self.traffic_manager.cleanup() + # 2. 等待一小段时间让所有传感器回调结束 + time.sleep(0.2) - # 清理协同管理 - if self.multi_vehicle_manager: - self.multi_vehicle_manager.cleanup() + # 3. 清理传感器(这是最重要的,必须在清理车辆之前) + for sensor_manager in self.sensor_managers.values(): + try: + sensor_manager.cleanup() + except Exception as e: + Log.error(f"清理传感器管理器失败: {e}") - # 清理V2X通信 - if self.v2x_communication: - self.v2x_communication.stop() + self.sensor_managers.clear() - # 清理车辆 - for vehicle in self.ego_vehicles: - if vehicle and vehicle.is_alive: + # 4. 清理V2X通信 + if self.v2x_communication: try: - vehicle.destroy() - except: - pass + self.v2x_communication.stop() + except Exception as e: + Log.error(f"停止V2X通信失败: {e}") - # 强制垃圾回收 - gc.collect() + # 5. 清理协同管理 + if self.multi_vehicle_manager: + try: + self.multi_vehicle_manager.cleanup() + except Exception as e: + Log.error(f"清理协同管理器失败: {e}") + + # 6. 清理背景交通(必须在清理主车之前) + if self.traffic_manager: + try: + self.traffic_manager.cleanup() + except Exception as e: + Log.error(f"清理交通管理器失败: {e}") + + # 7. 最后清理主车(在传感器和交通清理完之后) + for vehicle in self.ego_vehicles: + try: + if vehicle and vehicle.is_alive: + vehicle.destroy() + except Exception as e: + Log.debug(f"销毁主车失败: {e}") + + self.ego_vehicles.clear() + + # 8. 强制垃圾回收 + gc.collect() - Log.info("清理完成") + # 9. 重置CARLA世界(可选,但可以帮助清理) + try: + if self.world: + # 重置天气到默认 + default_weather = carla.WeatherParameters() + self.world.set_weather(default_weather) + except Exception as e: + Log.debug(f"重置世界设置失败: {e}") + + # 10. 等待一段时间确保所有清理完成 + time.sleep(0.5) + + Log.info("清理完成") + + except Exception as e: + Log.error(f"清理过程中发生错误: {e}") + import traceback + traceback.print_exc() + + # 即使出错也要尝试强制清理 + try: + # 强制删除所有引用,让Python垃圾回收器工作 + del self.sensor_managers + del self.traffic_manager + del self.multi_vehicle_manager + del self.v2x_communication + del self.ego_vehicles + gc.collect() + except: + pass def main(): @@ -1262,7 +1750,7 @@ def main(): parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') parser.add_argument('--enable-v2x', action='store_true', help='启用V2X通信') parser.add_argument('--enable-cooperative', action='store_true', help='启用协同感知') - parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') # 添加这行 + parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') # 功能参数 diff --git a/src/enhance_pedestrian_safety/multi_vehicle_manager.py b/src/enhance_pedestrian_safety/multi_vehicle_manager.py index 0f4492829c..4ed8890d91 100644 --- a/src/enhance_pedestrian_safety/multi_vehicle_manager.py +++ b/src/enhance_pedestrian_safety/multi_vehicle_manager.py @@ -40,11 +40,16 @@ def __init__(self, world, config, output_dir): self.config = config self.output_dir = output_dir - # 创建协同数据目录 + # 创建协同数据目录 - 确保所有子目录都创建 self.coop_dir = os.path.join(output_dir, "cooperative") os.makedirs(self.coop_dir, exist_ok=True) - os.makedirs(os.path.join(self.coop_dir, "v2x_messages"), exist_ok=True) - os.makedirs(os.path.join(self.coop_dir, "shared_perception"), exist_ok=True) + + # 创建子目录 + v2x_messages_dir = os.path.join(self.coop_dir, "v2x_messages") + os.makedirs(v2x_messages_dir, exist_ok=True) + + shared_perception_dir = os.path.join(self.coop_dir, "shared_perception") + os.makedirs(shared_perception_dir, exist_ok=True) # 车辆管理 self.ego_vehicles = [] # 主车辆列表 @@ -190,7 +195,7 @@ def create_v2x_message(self, sender_id: int, message_type: str, data: Dict, def broadcast_message(self, message: V2XMessage): """广播消息给范围内的车辆""" if message.sender_id not in self.vehicle_states: - return + return [] sender_state = self.vehicle_states[message.sender_id] sender_pos = sender_state.position @@ -220,65 +225,77 @@ def broadcast_message(self, message: V2XMessage): 'signal_strength': 1.0 - (distance / self.communication_range) }) - self.stats['successful_transmissions'] += len(recipients) + if recipients: + self.stats['successful_transmissions'] += len(recipients) - # 保存消息 - self._save_v2x_message(message, recipients) + # 保存消息 + try: + self._save_v2x_message(message, recipients) + except Exception as e: + print(f"保存V2X消息失败: {e}") return recipients def share_perception_data(self, vehicle_id: int, detected_objects: List[Dict]): """共享感知数据""" if not detected_objects: - return - - # 创建感知消息 - perception_data = { - 'vehicle_id': vehicle_id, - 'timestamp': time.time(), - 'objects': detected_objects, - 'vehicle_state': asdict( - self.vehicle_states.get(vehicle_id, VehicleState(0, '', (0, 0, 0), (0, 0, 0), (0, 0, 0), 0, []))) - } + return None + + try: + # 创建感知消息 + perception_data = { + 'vehicle_id': vehicle_id, + 'timestamp': time.time(), + 'objects': detected_objects, + 'vehicle_state': asdict( + self.vehicle_states.get(vehicle_id, VehicleState(0, '', (0, 0, 0), (0, 0, 0), (0, 0, 0), 0, []))) + } - message = self.create_v2x_message( - vehicle_id, - 'perception', - perception_data, - priority=2 # 感知数据优先级较高 - ) + message = self.create_v2x_message( + vehicle_id, + 'perception', + perception_data, + priority=2 # 感知数据优先级较高 + ) - # 广播消息 - recipients = self.broadcast_message(message) + # 广播消息 + recipients = self.broadcast_message(message) - # 融合共享的感知数据 - if recipients: - self._fuse_shared_perception(vehicle_id, detected_objects, recipients) + # 融合共享的感知数据 + if recipients: + self._fuse_shared_perception(vehicle_id, detected_objects, recipients) - return message + return message + except Exception as e: + print(f"共享感知数据失败: {e}") + return None def share_traffic_warning(self, vehicle_id: int, warning_type: str, location: Tuple[float, float, float], severity: str = 'medium'): """共享交通警告""" - warning_data = { - 'warning_type': warning_type, # 'accident', 'congestion', 'hazard', 'construction' - 'location': location, - 'severity': severity, - 'timestamp': time.time(), - 'source_vehicle': vehicle_id - } + try: + warning_data = { + 'warning_type': warning_type, # 'accident', 'congestion', 'hazard', 'construction' + 'location': location, + 'severity': severity, + 'timestamp': time.time(), + 'source_vehicle': vehicle_id + } - message = self.create_v2x_message( - vehicle_id, - 'warning', - warning_data, - priority=3 # 警告消息优先级最高 - ) + message = self.create_v2x_message( + vehicle_id, + 'warning', + warning_data, + priority=3 # 警告消息优先级最高 + ) - self.broadcast_message(message) + self.broadcast_message(message) - return message + return message + except Exception as e: + print(f"共享交通警告失败: {e}") + return None def _fuse_shared_perception(self, source_id: int, objects: List[Dict], recipients: List[int]): """融合共享的感知数据""" @@ -376,26 +393,41 @@ def _save_v2x_message(self, message: V2XMessage, recipients: List[int]): 'transmission_time': time.time() } + # 确保目录存在 + v2x_messages_dir = os.path.join(self.coop_dir, "v2x_messages") + os.makedirs(v2x_messages_dir, exist_ok=True) + filename = f"v2x_{int(time.time() * 1000)}_{message.sender_id}_{message.message_type}.json" - filepath = os.path.join(self.coop_dir, "v2x_messages", filename) + filepath = os.path.join(v2x_messages_dir, filename) - with open(filepath, 'w', encoding='utf-8') as f: - json.dump(message_data, f, indent=2, ensure_ascii=False) + try: + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(message_data, f, indent=2, ensure_ascii=False) + except Exception as e: + print(f"写入V2X消息文件失败: {e}") + raise def save_shared_perception(self, frame_num: int): """保存共享感知数据""" - data = { - 'frame_id': frame_num, - 'timestamp': time.time(), - 'shared_objects': self.shared_objects, - 'active_vehicles': len(self.ego_vehicles + self.cooperative_vehicles), - 'stats': self.stats - } - - filepath = os.path.join(self.coop_dir, "shared_perception", f"frame_{frame_num:06d}.json") - - with open(filepath, 'w', encoding='utf-8') as f: - json.dump(data, f, indent=2, ensure_ascii=False) + try: + data = { + 'frame_id': frame_num, + 'timestamp': time.time(), + 'shared_objects': self.shared_objects, + 'active_vehicles': len(self.ego_vehicles + self.cooperative_vehicles), + 'stats': self.stats + } + + # 确保目录存在 + shared_perception_dir = os.path.join(self.coop_dir, "shared_perception") + os.makedirs(shared_perception_dir, exist_ok=True) + + filepath = os.path.join(shared_perception_dir, f"frame_{frame_num:06d}.json") + + with open(filepath, 'w', encoding='utf-8') as f: + json.dump(data, f, indent=2, ensure_ascii=False) + except Exception as e: + print(f"保存共享感知数据失败: {e}") def generate_summary(self): """生成协同摘要报告""" From 1446fb4d47c6e2eb0a61fd2e6ee194012d29779f Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sat, 20 Dec 2025 19:38:12 +0800 Subject: [PATCH 08/21] =?UTF-8?q?=E4=BC=98=E5=8C=96=E6=95=B0=E6=8D=AE?= =?UTF-8?q?=E6=94=B6=E9=9B=86=E5=99=A8=E5=92=8C=E4=BC=A0=E6=84=9F=E5=99=A8?= =?UTF-8?q?=E7=AE=A1=E7=90=86=E5=99=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 28 +- .../lidar_processor.py | 296 ++++++------ src/enhance_pedestrian_safety/main.py | 433 +++++++++++------- 3 files changed, 463 insertions(+), 294 deletions(-) diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 0ef2d0bff3..183cb3cab3 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -36,8 +36,11 @@ def load_config(config_file=None): 'range': 100, 'points_per_second': 56000, 'rotation_frequency': 10, - 'max_points_per_frame': 100000, - 'downsample_ratio': 0.5 + 'max_points_per_frame': 50000, # 优化点6:减少最大点数 + 'downsample_ratio': 0.3, # 优化点6:增加下采样比例 + 'memory_warning_threshold': 350, # 新增:内存警告阈值(MB) + 'max_batch_memory_mb': 50, # 新增:批次最大内存 + 'v2x_save_interval': 5 # 新增:V2X格式保存间隔 } }, 'v2x': { @@ -47,7 +50,8 @@ def load_config(config_file=None): 'latency_mean': 0.05, 'latency_std': 0.01, 'packet_loss_rate': 0.01, - 'message_types': ['bsm', 'spat', 'map', 'rsm'] + 'message_types': ['bsm', 'spat', 'map', 'rsm'], + 'update_interval': 2.0 # 优化点6:V2X更新间隔 }, 'cooperative': { 'num_coop_vehicles': 2, @@ -81,11 +85,16 @@ def load_config(config_file=None): 'batch_size': 10, 'enable_compression': True, 'enable_downsampling': True, - 'max_points_per_frame': 100000 + 'max_points_per_frame': 50000, # 与sensors配置保持一致 + 'memory_warning_threshold': 350, + 'max_batch_memory_mb': 50, + 'v2x_save_interval': 5 }, 'fusion': { 'fusion_cache_size': 100 - } + }, + 'sensor_cleanup_timeout': 0.5, # 新增:传感器清理超时 + 'frame_rate_limit': 5.0 # 新增:帧率限制 }, 'output': { 'data_dir': 'cvips_dataset', @@ -150,6 +159,9 @@ def merge_args(config, args): if hasattr(args, 'enable_v2x') and args.enable_v2x: config['v2x']['enabled'] = True + # 如果通过命令行启用V2X,使用更保守的更新间隔 + if 'update_interval' not in config['v2x']: + config['v2x']['update_interval'] = 2.0 if hasattr(args, 'enable_enhancement') and args.enable_enhancement: config['enhancement']['enabled'] = True @@ -157,6 +169,9 @@ def merge_args(config, args): if hasattr(args, 'enable_lidar') and args.enable_lidar: config['sensors']['lidar_sensors'] = 1 config['output']['save_lidar'] = True + # 优化:如果启用LiDAR,使用更保守的设置 + config['sensors']['lidar_config']['max_points_per_frame'] = 50000 + config['sensors']['lidar_config']['downsample_ratio'] = 0.3 if hasattr(args, 'enable_fusion') and args.enable_fusion: config['output']['save_fusion'] = True @@ -185,6 +200,9 @@ def merge_args(config, args): if hasattr(args, 'enable_downsampling') and args.enable_downsampling: config['performance']['enable_downsampling'] = True + # 如果启用下采样,使用更保守的设置 + config['sensors']['lidar_config']['downsample_ratio'] = 0.3 + config['performance']['lidar_processing']['max_points_per_frame'] = 50000 if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index da2590994e..654aa674b8 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -29,10 +29,15 @@ def __init__(self, output_dir, config=None): self.enable_compression = config.get('enable_compression', True) if config else True self.compression_level = config.get('compression_level', 3) if config else 3 - # 内存管理 - self.max_points_per_frame = config.get('max_points_per_frame', 100000) if config else 100000 + # 内存管理 - 优化点3:更保守的内存设置 + self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 # 减少到5万点 self.enable_downsampling = config.get('enable_downsampling', True) if config else True - self.downsample_ratio = config.get('downsample_ratio', 0.5) if config else 0.5 + self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 # 增加下采样比例 + + # 新增:内存监控和限制 + self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 # MB + self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 # 批次最大内存 + self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 # 每5帧保存一次V2X格式 self._init_calibration_files() @@ -70,34 +75,65 @@ def _init_calibration_files(self): def process_lidar_data(self, lidar_data, frame_num): with self.data_lock: - self.frame_counter = frame_num + try: + self.frame_counter = frame_num - points = self._carla_lidar_to_numpy(lidar_data) + points = self._carla_lidar_to_numpy(lidar_data) - if points is None or points.shape[0] == 0: - return None + if points is None or points.shape[0] == 0: + print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") + return None - # 下采样以减少内存使用 - if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: - points = self._downsample_point_cloud(points) + # 检查内存使用情况 + if self._check_memory_usage(): + print(f"警告: 内存使用过高,跳过LiDAR处理 (帧 {frame_num})") + return None - # 添加到批处理 - self.point_cloud_batch.append((frame_num, points)) + # 下采样以减少内存使用 + original_count = points.shape[0] + if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: + points = self._downsample_point_cloud(points) + print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") - # 如果达到批处理大小,保存批处理数据 - if len(self.point_cloud_batch) >= self.batch_size: - self._save_batch() + # 检查批次内存使用 + batch_memory_mb = self._estimate_batch_memory_mb() + if batch_memory_mb > self.max_batch_memory_mb: + print(f"批处理内存过高 ({batch_memory_mb:.1f}MB),强制保存当前批次") + self._save_batch() + + # 添加到批处理 + self.point_cloud_batch.append((frame_num, points)) + + # 如果达到批处理大小,保存批处理数据 + if len(self.point_cloud_batch) >= self.batch_size: + self._save_batch() + + # 保存单个文件(向后兼容) + bin_path = self._save_as_bin(points, frame_num) + npy_path = self._save_as_npy(points, frame_num) + + # 生成V2XFormer兼容格式 - 优化点:每v2x_save_interval帧保存一次 + v2xformer_path = None + if frame_num % self.v2x_save_interval == 0: + try: + v2xformer_path = self._save_as_v2xformer_format(points, frame_num) + except Exception as e: + print(f"警告: V2XFormer格式保存失败: {e}") + v2xformer_path = None - # 保存单个文件(向后兼容) - bin_path = self._save_as_bin(points, frame_num) - npy_path = self._save_as_npy(points, frame_num) + metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) - # 生成V2XFormer兼容格式 - v2xformer_path = self._save_as_v2xformer_format(points, frame_num) + # 定期清理内存 + if frame_num % 20 == 0: + gc.collect() - metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) + return metadata - return metadata + except Exception as e: + print(f"处理LiDAR数据失败: {e}") + # 强制清理内存 + gc.collect() + return None def _carla_lidar_to_numpy(self, lidar_data): """高效转换LiDAR数据""" @@ -146,6 +182,33 @@ def _downsample_point_cloud(self, points): return downsampled + def _estimate_batch_memory_mb(self): + """估计批处理内存使用""" + if not self.point_cloud_batch: + return 0 + + total_points = 0 + for _, points in self.point_cloud_batch: + total_points += points.shape[0] + + # 每个点3个float32 (12字节),加上一些额外开销 + memory_bytes = total_points * 12 * 1.2 # 20%额外开销 + return memory_bytes / (1024 * 1024) + + def _check_memory_usage(self): + """检查内存使用情况""" + try: + import psutil + process = psutil.Process() + memory_mb = process.memory_info().rss / (1024 * 1024) + + if memory_mb > self.memory_warning_threshold: + print(f"警告: 进程内存使用过高: {memory_mb:.1f}MB") + return True + return False + except: + return False + def _save_batch(self): """批量保存点云数据(提高效率)""" if not self.point_cloud_batch: @@ -153,6 +216,7 @@ def _save_batch(self): batch_data = [] for frame_num, points in self.point_cloud_batch: + # 只保存点的坐标,不保存完整对象 batch_data.append({ 'frame_num': frame_num, 'points': points.tolist(), @@ -167,15 +231,28 @@ def _save_batch(self): # 压缩保存 if self.enable_compression: - compressed_data = zlib.compress( - json.dumps(batch_data).encode('utf-8'), - level=self.compression_level - ) - with open(batch_path, 'wb') as f: - f.write(compressed_data) + try: + json_str = json.dumps(batch_data) + compressed_data = zlib.compress( + json_str.encode('utf-8'), + level=self.compression_level + ) + with open(batch_path, 'wb') as f: + f.write(compressed_data) + except Exception as e: + print(f"压缩保存批处理数据失败: {e}") + # 尝试非压缩保存 + try: + with open(batch_path, 'w') as f: + json.dump(batch_data, f) + except Exception as e2: + print(f"非压缩保存批处理数据失败: {e2}") else: - with open(batch_path, 'w') as f: - json.dump(batch_data, f) + try: + with open(batch_path, 'w') as f: + json.dump(batch_data, f) + except Exception as e: + print(f"保存批处理数据失败: {e}") # 清理批处理缓存 self.point_cloud_batch.clear() @@ -192,7 +269,11 @@ def _save_as_bin(self, points, frame_num): points_with_intensity[:, :3] = points points_with_intensity[:, 3] = 1.0 # 强度值 - points_with_intensity.tofile(bin_path) + try: + points_with_intensity.tofile(bin_path) + except Exception as e: + print(f"保存BIN文件失败: {e}") + return None return bin_path @@ -200,20 +281,29 @@ def _save_as_npy(self, points, frame_num): """保存为numpy格式""" npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") - # 使用内存映射减少内存使用 - memmap_array = np.lib.format.open_memmap( - npy_path, - mode='w+', - dtype=np.float32, - shape=points.shape - ) - memmap_array[:] = points[:] - memmap_array.flush() + try: + # 使用内存映射减少内存使用 + memmap_array = np.lib.format.open_memmap( + npy_path, + mode='w+', + dtype=np.float32, + shape=points.shape + ) + memmap_array[:] = points[:] + memmap_array.flush() + except Exception as e: + print(f"保存NPY文件失败: {e}") + # 备选保存方式 + try: + np.save(npy_path, points) + except Exception as e2: + print(f"备选保存NPY文件失败: {e2}") + return None return npy_path def _save_as_v2xformer_format(self, points, frame_num): - """保存为V2XFormer兼容格式""" + """保存为V2XFormer兼容格式 - 优化点:减少保存频率""" v2x_dir = os.path.join(self.output_dir, "v2xformer_format") os.makedirs(v2x_dir, exist_ok=True) @@ -251,61 +341,18 @@ def _save_as_v2xformer_format(self, points, frame_num): return filepath except Exception as e: - # 如果保存失败,只打印警告,不抛出异常 print(f"警告: 保存V2XFormer格式失败: {e}") return None - def process_lidar_data(self, lidar_data, frame_num): - with self.data_lock: - try: - self.frame_counter = frame_num - - points = self._carla_lidar_to_numpy(lidar_data) - - if points is None or points.shape[0] == 0: - print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") - return None - - # 下采样以减少内存使用 - if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: - original_count = points.shape[0] - points = self._downsample_point_cloud(points) - print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") - - # 添加到批处理 - self.point_cloud_batch.append((frame_num, points)) - - # 如果达到批处理大小,保存批处理数据 - if len(self.point_cloud_batch) >= self.batch_size: - self._save_batch() - - # 保存单个文件(向后兼容) - bin_path = self._save_as_bin(points, frame_num) - npy_path = self._save_as_npy(points, frame_num) - - # 生成V2XFormer兼容格式(如果失败则忽略) - try: - v2xformer_path = self._save_as_v2xformer_format(points, frame_num) - except Exception as e: - v2xformer_path = None - print(f"警告: V2XFormer格式保存失败: {e}") - - metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) - - return metadata - - except Exception as e: - print(f"处理LiDAR数据失败: {e}") - return None def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): metadata = { 'frame_id': self.frame_counter, 'timestamp': datetime.now().isoformat(), 'point_count': int(points.shape[0]), 'file_paths': { - 'bin': os.path.basename(bin_path), - 'npy': os.path.basename(npy_path), - 'v2xformer': os.path.basename(v2xformer_path) + 'bin': os.path.basename(bin_path) if bin_path else None, + 'npy': os.path.basename(npy_path) if npy_path else None, + 'v2xformer': os.path.basename(v2xformer_path) if v2xformer_path else None }, 'statistics': { 'x_range': [float(points[:, 0].min()), float(points[:, 0].max())], @@ -318,13 +365,17 @@ def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): 'downsampled': self.enable_downsampling and points.shape[0] > self.max_points_per_frame, 'downsample_ratio': self.downsample_ratio if self.enable_downsampling else 1.0, 'compression_enabled': self.enable_compression, - 'compression_level': self.compression_level + 'compression_level': self.compression_level, + 'v2x_saved': v2xformer_path is not None } } meta_path = os.path.join(self.lidar_dir, f"lidar_meta_{self.frame_counter:06d}.json") - with open(meta_path, 'w') as f: - json.dump(metadata, f, indent=2) + try: + with open(meta_path, 'w') as f: + json.dump(metadata, f, indent=2) + except Exception as e: + print(f"保存LiDAR元数据失败: {e}") return metadata @@ -349,18 +400,21 @@ def generate_lidar_summary(self): total_size = 0 # 采样统计,避免读取所有文件 - sample_files = bin_files[:10] if len(bin_files) > 10 else bin_files + sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files # 减少采样数量 for bin_file in sample_files: if os.path.exists(bin_file): - file_size = os.path.getsize(bin_file) - total_size += file_size - # 估算点数 - points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 - total_points += points_in_file + try: + file_size = os.path.getsize(bin_file) + total_size += file_size + # 估算点数 + points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 + total_points += points_in_file + except: + continue # 根据采样估算总数 - if sample_files: - avg_points_per_file = total_points / len(sample_files) + if sample_files and len(bin_files) > 0: + avg_points_per_file = total_points / max(len(sample_files), 1) total_points_estimated = avg_points_per_file * len(bin_files) else: total_points_estimated = 0 @@ -382,8 +436,11 @@ def generate_lidar_summary(self): } summary_path = os.path.join(self.output_dir, "metadata", "lidar_summary.json") - with open(summary_path, 'w') as f: - json.dump(summary, f, indent=2) + try: + with open(summary_path, 'w') as f: + json.dump(summary, f, indent=2) + except Exception as e: + print(f"保存LiDAR摘要失败: {e}") return summary @@ -398,7 +455,7 @@ def __init__(self, output_dir, config=None): self.calibration_data = {} self.fusion_cache = {} # 融合缓存 - self.cache_size = config.get('fusion_cache_size', 100) if config else 100 + self.cache_size = config.get('fusion_cache_size', 50) if config else 50 # 减少缓存大小 self._load_calibration() @@ -413,32 +470,15 @@ def _load_calibration(self): if file.endswith('.json'): calibration_files.append(os.path.join(root, file)) - # 并行读取校准文件 - import concurrent.futures - with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor: - future_to_file = { - executor.submit(self._load_calibration_file, file): file - for file in calibration_files - } - - for future in concurrent.futures.as_completed(future_to_file): - file = future_to_file[future] - try: - sensor_name, data = future.result() - if sensor_name and data: - self.calibration_data[sensor_name] = data - except Exception as e: - print(f"加载校准文件 {file} 失败: {e}") - - def _load_calibration_file(self, filepath): - """加载单个校准文件""" - try: - with open(filepath, 'r') as f: - data = json.load(f) - sensor_name = os.path.basename(filepath).replace('.json', '') - return sensor_name, data - except: - return None, None + # 限制同时读取的文件数量 + for file in calibration_files[:10]: # 最多读取10个文件 + try: + with open(file, 'r') as f: + data = json.load(f) + sensor_name = os.path.basename(file).replace('.json', '') + self.calibration_data[sensor_name] = data + except Exception as e: + print(f"加载校准文件 {file} 失败: {e}") def create_synchronization_file(self, frame_num, sensor_data): """创建同步文件(优化版)""" @@ -521,7 +561,7 @@ def generate_fusion_report(self): # 解析文件名获取帧范围(避免读取所有文件) frame_ids = [] - for sync_file in sync_files: + for sync_file in sync_files[:20]: # 只检查前20个文件 try: # 从文件名提取帧号 filename = os.path.basename(sync_file) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 990a4d0db5..872899a477 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -250,12 +250,12 @@ def error(msg): @staticmethod def debug(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") print(f"[DEBUG][{timestamp}] {msg}") @staticmethod def performance(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") print(f"[PERF][{timestamp}] {msg}") @@ -663,43 +663,34 @@ def _spawn_pedestrians(self, center_location): return spawned def cleanup(self): - Log.info("清理交通...") - - # 批量销毁 - actors_to_destroy = [] + """安全清理所有资源""" + Log.info("开始清理交通管理器...") - for vehicle in self.vehicles: - if vehicle.is_alive: - actors_to_destroy.append(vehicle) + try: + # 清理行人 + for pedestrian in self.pedestrians: + try: + if pedestrian and pedestrian.is_alive: + pedestrian.destroy() + except: + pass - for pedestrian in self.pedestrians: - if pedestrian.is_alive: - actors_to_destroy.append(pedestrian) + self.pedestrians.clear() - # 批量销毁 - batch_size = 10 - for i in range(0, len(actors_to_destroy), batch_size): - batch = actors_to_destroy[i:i + batch_size] - for actor in batch: + # 清理背景车辆 + for vehicle in self.vehicles: try: - actor.destroy() + if vehicle and vehicle.is_alive: + vehicle.destroy() except: pass - # 避免过快的销毁速度 - if i > 0 and i % 30 == 0: - time.sleep(0.1) + self.vehicles.clear() - self.vehicles.clear() - self.pedestrians.clear() + Log.info("交通管理器清理完成") - # 清理统计 - self.spawn_stats = { - 'total_attempts': 0, - 'successful_spawns': 0, - 'failed_spawns': 0, - 'total_spawn_time': 0 - } + except Exception as e: + Log.error(f"清理交通管理器失败: {e}") class SensorManager: @@ -713,6 +704,13 @@ def __init__(self, world, config, data_dir): self.last_capture_time = 0 self.last_performance_sample = 0 + # 新增:帧率控制相关变量 + self.target_fps = config['performance'].get('frame_rate_limit', 5.0) + self.min_frame_interval = 1.0 / self.target_fps if self.target_fps > 0 else 0.1 + self.last_frame_time = 0 + self.frame_skip_count = 0 + self.max_frame_skip = 2 + self.vehicle_buffer = {} self.infra_buffer = {} self.buffer_lock = threading.Lock() @@ -729,14 +727,14 @@ def __init__(self, world, config, data_dir): self.fusion_manager = None # 批处理设置 - self.batch_size = config.get('batch_size', 5) + self.batch_size = config['performance'].get('batch_size', 5) self.enable_async_processing = config.get('enable_async_processing', True) if config['sensors'].get('lidar_sensors', 0) > 0: - self.lidar_processor = LidarProcessor(data_dir, config.get('lidar_processing', {})) + self.lidar_processor = LidarProcessor(data_dir, config['performance'].get('lidar_processing', {})) if config['output'].get('save_fusion', False): - self.fusion_manager = MultiSensorFusion(data_dir, config.get('fusion', {})) + self.fusion_manager = MultiSensorFusion(data_dir, config['performance'].get('fusion', {})) # 传感器统计 self.sensor_stats = { @@ -927,9 +925,24 @@ def callback(image): current_time = time.time() frame_start_time = time.time() + # 优化点2:添加帧率控制逻辑 + # 检查是否达到最小帧间隔 + time_since_last_frame = current_time - self.last_frame_time + if time_since_last_frame < self.min_frame_interval: + # 如果帧间隔太小,跳过此帧 + self.frame_skip_count += 1 + if self.frame_skip_count > self.max_frame_skip: + # 如果连续跳过多帧,强制处理一帧 + self.frame_skip_count = 0 + else: + return # 跳过此帧 + else: + self.frame_skip_count = 0 + if current_time - self.last_capture_time >= capture_interval: self.frame_counter += 1 self.last_capture_time = current_time + self.last_frame_time = current_time # 记录帧处理时间 capture_start = time.time() filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") @@ -943,13 +956,34 @@ def callback(image): if sensor_type == 'vehicle': self.vehicle_buffer[name] = filename if len(self.vehicle_buffer) >= 4: - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, - f'vehicle_{vehicle_id}') + # 使用线程池异步处理图像拼接,避免阻塞 + if self.enable_async_processing: + import concurrent.futures + with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: + future = executor.submit( + self.image_processor.stitch, + self.vehicle_buffer.copy(), + self.frame_counter, + f'vehicle_{vehicle_id}' + ) + else: + self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, + f'vehicle_{vehicle_id}') self.vehicle_buffer.clear() else: self.infra_buffer[name] = filename if len(self.infra_buffer) >= 4: - self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') + if self.enable_async_processing: + import concurrent.futures + with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: + future = executor.submit( + self.image_processor.stitch, + self.infra_buffer.copy(), + self.frame_counter, + 'infrastructure' + ) + else: + self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') self.infra_buffer.clear() # 定期采样性能 @@ -1023,55 +1057,55 @@ def cleanup(self): """安全清理传感器""" Log.info(f"安全清理 {len(self.sensors)} 个传感器...") - # 设置运行状态为False,防止回调函数继续执行 + # 1. 首先设置运行状态为False,防止回调函数继续执行 self.is_running = False - # 等待一小段时间让回调函数结束 - time.sleep(0.1) + # 2. 停止所有传感器的监听 + Log.info("停止所有传感器监听...") + for sensor in self.sensors: + try: + if hasattr(sensor, 'stop'): + sensor.stop() + time.sleep(0.001) # 短暂延迟 + except: + pass + + # 3. 等待一小段时间让所有传感器回调结束 + time.sleep(0.2) - # 刷新批处理数据 + # 4. 刷新批处理数据 if self.lidar_processor: try: self.lidar_processor.flush_batch() - except Exception as e: - Log.warning(f"刷新LiDAR批处理数据失败: {e}") - - # 批量销毁传感器(从后向前销毁,避免依赖问题) - if self.sensors: - Log.info(f"销毁 {len(self.sensors)} 个传感器...") - - # 首先停止所有传感器的监听 - for sensor in self.sensors: - try: - if sensor and sensor.is_alive: - sensor.stop() - except Exception as e: - Log.debug(f"停止传感器失败: {e}") - - # 等待一小段时间让传感器完全停止 - time.sleep(0.05) - - # 然后销毁传感器 - for i, sensor in enumerate(reversed(self.sensors)): - try: - if sensor and sensor.is_alive: - sensor.destroy() - except Exception as e: - Log.debug(f"销毁传感器失败: {e}") + except: + pass - # 分批销毁,避免一次性销毁太多 - if i % 5 == 0: - time.sleep(0.01) + # 5. 销毁传感器 + Log.info(f"销毁 {len(self.sensors)} 个传感器...") + for i, sensor in enumerate(self.sensors): + try: + if hasattr(sensor, 'destroy'): + sensor.destroy() + except: + pass + # 分批销毁,避免一次性销毁太多 + if i % 5 == 0: + time.sleep(0.01) self.sensors.clear() - # 清理缓存 + # 6. 清理缓存和内存 if hasattr(self.image_processor, 'image_cache'): try: self.image_processor.image_cache.clear() except: pass + # 7. 清理数据结构 + self.vehicle_buffer.clear() + self.infra_buffer.clear() + + # 8. 强制垃圾回收 gc.collect() Log.info("传感器清理完成") @@ -1251,23 +1285,58 @@ def collect_data(self): last_perception_share = time.time() last_performance_sample = time.time() last_detailed_log = time.time() + last_memory_check = time.time() + + # 内存监控变量 + memory_warning_issued = False + forced_cleanup_count = 0 try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time + # 内存检查 - 优化点4:定期检查内存使用 + if current_time - last_memory_check >= 2.0: # 更频繁的内存检查 + try: + import psutil + process = psutil.Process() + memory_mb = process.memory_info().rss / (1024 * 1024) + + if memory_mb > 350 and not memory_warning_issued: + Log.warning(f"内存使用较高: {memory_mb:.1f}MB,将减少数据处理") + memory_warning_issued = True + + # 如果内存过高,跳过一些非关键操作 + if self.v2x_communication: + Log.debug("内存警告:暂停部分V2X消息处理") + + elif memory_mb > 400: # 如果内存超过400MB,提前结束 + Log.error(f"内存使用过高: {memory_mb:.1f}MB,提前结束数据收集") + break + + elif memory_mb < 300: + memory_warning_issued = False + forced_cleanup_count = 0 + + except Exception as e: + Log.debug(f"内存检查失败: {e}") + + last_memory_check = current_time + # 更新车辆状态 if self.multi_vehicle_manager: self.multi_vehicle_manager.update_vehicle_states() - # V2X通信更新 - if self.v2x_communication and current_time - last_v2x_update >= 0.1: + # V2X通信更新 - 使用配置中的更新间隔 + v2x_interval = self.config['v2x'].get('update_interval', 2.0) + if self.v2x_communication and current_time - last_v2x_update >= v2x_interval: self._update_v2x_communication() last_v2x_update = current_time - # 共享感知数据 - if (self.config['cooperative'].get('enable_shared_perception', True) and + # 共享感知数据 - 仅在内存允许时进行 + if (not memory_warning_issued and + self.config['cooperative'].get('enable_shared_perception', True) and current_time - last_perception_share >= 2.0): self._share_perception_data() last_perception_share = current_time @@ -1348,6 +1417,133 @@ def collect_data(self): if self.output_format != 'standard': self._convert_to_target_format() + def _force_memory_cleanup(self): + """强制内存清理""" + Log.info("执行强制内存清理...") + + # 清理图像处理器缓存 + for sensor_manager in self.sensor_managers.values(): + if hasattr(sensor_manager, 'image_processor'): + if hasattr(sensor_manager.image_processor, 'image_cache'): + try: + old_size = len(sensor_manager.image_processor.image_cache) + sensor_manager.image_processor.image_cache.clear() + Log.debug(f"清理图像缓存: 释放了{old_size}个缓存项") + except: + pass + + # 清理LiDAR批处理 + for sensor_manager in self.sensor_managers.values(): + if hasattr(sensor_manager, 'lidar_processor'): + try: + sensor_manager.lidar_processor.flush_batch() + Log.debug("刷新LiDAR批处理数据") + except: + pass + + # 强制垃圾回收 + gc.collect() + + Log.info("强制内存清理完成") + + def cleanup(self): + """安全清理所有资源 - 完全重写的版本""" + Log.info("开始安全清理场景...") + + cleanup_start = time.time() + + try: + # 1. 设置运行状态为False + self.is_running = False + + # 2. 等待一小段时间让循环结束 + time.sleep(0.2) + + # 3. 停止V2X通信 + if self.v2x_communication: + try: + Log.info("停止V2X通信...") + self.v2x_communication.stop() + except: + pass + + # 4. 清理传感器(最重要,必须先于车辆) + Log.info(f"清理 {len(self.sensor_managers)} 个传感器管理器...") + for vehicle_id, sensor_manager in self.sensor_managers.items(): + try: + sensor_manager.cleanup() + except: + pass + + self.sensor_managers.clear() + time.sleep(0.1) # 等待传感器清理完成 + + # 5. 清理多车辆管理器 + if self.multi_vehicle_manager: + try: + Log.info("清理多车辆管理器...") + self.multi_vehicle_manager.cleanup() + except: + pass + + # 6. 清理背景交通 + if self.traffic_manager: + try: + Log.info("清理交通管理器...") + self.traffic_manager.cleanup() + except: + pass + + # 7. 清理主车(最后清理) + Log.info(f"清理 {len(self.ego_vehicles)} 个主车...") + for vehicle in self.ego_vehicles: + try: + if hasattr(vehicle, 'destroy'): + vehicle.destroy() + except: + pass + time.sleep(0.01) # 短暂延迟 + + self.ego_vehicles.clear() + + # 8. 重置世界设置 + try: + if self.world: + default_weather = carla.WeatherParameters() + self.world.set_weather(default_weather) + except: + pass + + # 9. 强制垃圾回收 + gc.collect() + + # 10. 等待确保清理完成 + time.sleep(0.3) + + # 11. 释放引用 + self.traffic_manager = None + self.multi_vehicle_manager = None + self.v2x_communication = None + self.scene_center = None + + # 最后一次强制垃圾回收 + gc.collect() + + Log.info(f"清理完成,总用时: {time.time() - cleanup_start:.2f}秒") + + except Exception as e: + Log.error(f"清理过程中发生错误: {e}") + # 紧急清理:强制释放所有引用 + try: + self.sensor_managers.clear() + self.ego_vehicles.clear() + self.traffic_manager = None + self.multi_vehicle_manager = None + self.v2x_communication = None + gc.collect() + except: + pass + def _convert_to_target_format(self): """转换为目标数据格式""" Log.info(f"转换为 {self.output_format} 格式...") @@ -1443,7 +1639,7 @@ def _update_v2x_communication(self): # 为每辆车发送基本安全消息 for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: - if not vehicle.is_alive: + if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue try: @@ -1478,7 +1674,7 @@ def _share_perception_data(self): # 模拟车辆感知数据(简化处理,实际应从传感器获取) for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: - if not vehicle.is_alive: + if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue # 模拟检测到的物体 @@ -1493,7 +1689,7 @@ def _simulate_object_detection(self, vehicle): # 获取车辆周围的其他车辆 for other_vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: - if other_vehicle.id == vehicle.id or not other_vehicle.is_alive: + if other_vehicle.id == vehicle.id or not hasattr(other_vehicle, 'is_alive') or not other_vehicle.is_alive: continue try: @@ -1627,91 +1823,6 @@ def run_analysis(self): Log.info("运行数据分析...") DataAnalyzer.analyze_dataset(self.output_dir) - def cleanup(self): - """安全清理所有资源 - 修复的方法""" - Log.info("开始安全清理场景...") - - try: - # 1. 先停止数据收集 - self.is_running = False - - # 2. 等待一小段时间让所有传感器回调结束 - time.sleep(0.2) - - # 3. 清理传感器(这是最重要的,必须在清理车辆之前) - for sensor_manager in self.sensor_managers.values(): - try: - sensor_manager.cleanup() - except Exception as e: - Log.error(f"清理传感器管理器失败: {e}") - - self.sensor_managers.clear() - - # 4. 清理V2X通信 - if self.v2x_communication: - try: - self.v2x_communication.stop() - except Exception as e: - Log.error(f"停止V2X通信失败: {e}") - - # 5. 清理协同管理 - if self.multi_vehicle_manager: - try: - self.multi_vehicle_manager.cleanup() - except Exception as e: - Log.error(f"清理协同管理器失败: {e}") - - # 6. 清理背景交通(必须在清理主车之前) - if self.traffic_manager: - try: - self.traffic_manager.cleanup() - except Exception as e: - Log.error(f"清理交通管理器失败: {e}") - - # 7. 最后清理主车(在传感器和交通清理完之后) - for vehicle in self.ego_vehicles: - try: - if vehicle and vehicle.is_alive: - vehicle.destroy() - except Exception as e: - Log.debug(f"销毁主车失败: {e}") - - self.ego_vehicles.clear() - - # 8. 强制垃圾回收 - gc.collect() - - # 9. 重置CARLA世界(可选,但可以帮助清理) - try: - if self.world: - # 重置天气到默认 - default_weather = carla.WeatherParameters() - self.world.set_weather(default_weather) - except Exception as e: - Log.debug(f"重置世界设置失败: {e}") - - # 10. 等待一段时间确保所有清理完成 - time.sleep(0.5) - - Log.info("清理完成") - - except Exception as e: - Log.error(f"清理过程中发生错误: {e}") - import traceback - traceback.print_exc() - - # 即使出错也要尝试强制清理 - try: - # 强制删除所有引用,让Python垃圾回收器工作 - del self.sensor_managers - del self.traffic_manager - del self.multi_vehicle_manager - del self.v2x_communication - del self.ego_vehicles - gc.collect() - except: - pass - def main(): parser = argparse.ArgumentParser(description='CVIPS 性能优化数据收集系统 v12.0') From 6023f24ff279145fae1a49495a148f38326a1186 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 09:04:16 +0800 Subject: [PATCH 09/21] =?UTF-8?q?=E4=BC=98=E5=8C=96=20data=5Fanalyzer.py?= =?UTF-8?q?=20-=20=E6=B7=BB=E5=8A=A0=E6=9B=B4=E8=AF=A6=E7=BB=86=E7=9A=84?= =?UTF-8?q?=E5=88=86=E6=9E=90=E5=92=8C=E7=BC=93=E5=AD=98=E6=9C=BA=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../data_analyzer.py | 950 ++++++++++++++---- 1 file changed, 757 insertions(+), 193 deletions(-) diff --git a/src/enhance_pedestrian_safety/data_analyzer.py b/src/enhance_pedestrian_safety/data_analyzer.py index 069d6d2ec7..14690041fb 100644 --- a/src/enhance_pedestrian_safety/data_analyzer.py +++ b/src/enhance_pedestrian_safety/data_analyzer.py @@ -2,16 +2,83 @@ import json import numpy as np from collections import defaultdict +import hashlib +import pickle +import time class DataAnalyzer: - """数据分析器 - 生成数据集统计信息""" + """数据分析器 - 生成数据集统计信息(优化版)""" + + # 添加缓存机制 + _cache_dir = ".analysis_cache" + _cache_enabled = True + + @staticmethod + def _get_cache_key(data_dir): + """生成缓存键""" + # 使用目录结构和文件修改时间生成哈希 + file_times = [] + for root, dirs, files in os.walk(data_dir): + for file in files: + file_path = os.path.join(root, file) + try: + file_times.append(str(os.path.getmtime(file_path))) + except: + pass + + content = data_dir + "".join(sorted(file_times)) + return hashlib.md5(content.encode()).hexdigest() + + @staticmethod + def _load_from_cache(cache_key): + """从缓存加载""" + if not DataAnalyzer._cache_enabled: + return None + + cache_file = os.path.join(DataAnalyzer._cache_dir, f"{cache_key}.pkl") + if os.path.exists(cache_file): + try: + with open(cache_file, 'rb') as f: + cached_time, analysis = pickle.load(f) + # 缓存有效期1小时 + if time.time() - cached_time < 3600: + print( + f"使用缓存分析结果 (缓存时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(cached_time))})") + return analysis + except: + pass + return None + + @staticmethod + def _save_to_cache(cache_key, analysis): + """保存到缓存""" + if not DataAnalyzer._cache_enabled: + return + + os.makedirs(DataAnalyzer._cache_dir, exist_ok=True) + cache_file = os.path.join(DataAnalyzer._cache_dir, f"{cache_key}.pkl") + try: + with open(cache_file, 'wb') as f: + pickle.dump((time.time(), analysis), f) + except: + pass @staticmethod - def analyze_dataset(data_dir): - """分析数据集并生成详细报告""" + def analyze_dataset(data_dir, force_refresh=False): + """分析数据集并生成详细报告(带缓存)""" print(f"分析数据集: {data_dir}") + # 检查缓存 + cache_key = DataAnalyzer._get_cache_key(data_dir) + if not force_refresh: + cached = DataAnalyzer._load_from_cache(cache_key) + if cached: + return cached + + analysis_start = time.time() + + # 并行执行分析任务 analysis = { 'basic_stats': DataAnalyzer._get_basic_stats(data_dir), 'file_distribution': DataAnalyzer._analyze_file_distribution(data_dir), @@ -24,9 +91,19 @@ def analyze_dataset(data_dir): # 生成评分 analysis['overall_score'] = DataAnalyzer._calculate_overall_score(analysis) + # 添加分析元数据 + analysis['metadata'] = { + 'analysis_time': time.strftime('%Y-%m-%d %H:%M:%S'), + 'analysis_duration': round(time.time() - analysis_start, 2), + 'cache_key': cache_key + } + # 保存分析结果 DataAnalyzer._save_analysis_report(data_dir, analysis) + # 保存到缓存 + DataAnalyzer._save_to_cache(cache_key, analysis) + # 打印摘要 DataAnalyzer._print_analysis_summary(analysis) @@ -34,115 +111,271 @@ def analyze_dataset(data_dir): @staticmethod def _get_basic_stats(data_dir): - """获取基本统计信息""" + """获取基本统计信息(优化版)""" stats = { - 'total_size_mb': DataAnalyzer._get_directory_size(data_dir), + 'total_size_mb': 0, 'file_count': 0, 'directory_count': 0, - 'data_types': defaultdict(int) + 'data_types': defaultdict(int), + 'largest_files': [], + 'oldest_newest_files': {} } + file_sizes = [] + file_times = [] + for root, dirs, files in os.walk(data_dir): stats['directory_count'] += len(dirs) stats['file_count'] += len(files) for file in files: - ext = os.path.splitext(file)[1].lower() - if ext in ['.png', '.jpg', '.jpeg']: - stats['data_types']['images'] += 1 - elif ext == '.json': - stats['data_types']['json'] += 1 - elif ext == '.txt': - stats['data_types']['text'] += 1 - elif ext == '.bin': - stats['data_types']['binary'] += 1 - else: - stats['data_types']['other'] += 1 + file_path = os.path.join(root, file) + try: + # 文件大小 + file_size = os.path.getsize(file_path) + stats['total_size_mb'] += file_size + + # 文件修改时间 + mtime = os.path.getmtime(file_path) + file_times.append((file_path, mtime)) + + # 记录大文件 + if file_size > 10 * 1024 * 1024: # 10MB以上 + file_sizes.append((file_path, file_size)) + + # 文件类型统计 + ext = os.path.splitext(file)[1].lower() + if ext in ['.png', '.jpg', '.jpeg', '.bmp', '.tiff']: + stats['data_types']['images'] += 1 + elif ext == '.json': + stats['data_types']['json'] += 1 + elif ext in ['.txt', '.csv', '.log']: + stats['data_types']['text'] += 1 + elif ext in ['.bin', '.pcd']: + stats['data_types']['binary'] += 1 + elif ext in ['.pkl', '.pickle']: + stats['data_types']['pickle'] += 1 + elif ext == '.gz': + stats['data_types']['compressed'] += 1 + else: + stats['data_types']['other'] += 1 + + except Exception as e: + print(f"处理文件 {file_path} 失败: {e}") + + # 转换为MB + stats['total_size_mb'] = round(stats['total_size_mb'] / (1024 * 1024), 2) + + # 找出最大的5个文件 + file_sizes.sort(key=lambda x: x[1], reverse=True) + stats['largest_files'] = [ + {'path': os.path.relpath(path, data_dir), 'size_mb': round(size / (1024 * 1024), 2)} + for path, size in file_sizes[:5] + ] + + # 找出最旧和最新的文件 + if file_times: + file_times.sort(key=lambda x: x[1]) + oldest = file_times[0] + newest = file_times[-1] + stats['oldest_newest_files'] = { + 'oldest': { + 'path': os.path.relpath(oldest[0], data_dir), + 'time': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(oldest[1])) + }, + 'newest': { + 'path': os.path.relpath(newest[0], data_dir), + 'time': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(newest[1])) + } + } return stats @staticmethod - def _get_directory_size(path): - """计算目录大小""" - total = 0 - for dirpath, dirnames, filenames in os.walk(path): - for f in filenames: - fp = os.path.join(dirpath, f) - if os.path.exists(fp): - total += os.path.getsize(fp) - return round(total / (1024 * 1024), 2) + def _analyze_file_distribution(data_dir): + """分析文件分布(优化版)""" + distribution = {} + + # 快速扫描目录结构 + if os.path.exists(data_dir): + # 使用os.scandir提高效率 + with os.scandir(data_dir) as entries: + for entry in entries: + if entry.is_dir(): + dir_name = entry.name + if dir_name == "raw": + distribution.update(DataAnalyzer._analyze_raw_data(data_dir)) + elif dir_name == "stitched": + stitched_dir = os.path.join(data_dir, "stitched") + if os.path.exists(stitched_dir): + stitched_images = [f for f in os.listdir(stitched_dir) + if f.lower().endswith(('.jpg', '.jpeg', '.png'))] + distribution['stitched'] = { + 'total': len(stitched_images), + 'formats': defaultdict(int) + } + for img in stitched_images: + ext = os.path.splitext(img)[1].lower() + distribution['stitched']['formats'][ext] += 1 + elif dir_name == "annotations": + annotations_dir = os.path.join(data_dir, "annotations") + if os.path.exists(annotations_dir): + json_files = [f for f in os.listdir(annotations_dir) + if f.lower().endswith('.json')] + distribution['annotations'] = len(json_files) + elif dir_name == "lidar": + lidar_dir = os.path.join(data_dir, "lidar") + if os.path.exists(lidar_dir): + distribution['lidar'] = DataAnalyzer._analyze_lidar_data(lidar_dir) + elif dir_name == "fusion": + fusion_dir = os.path.join(data_dir, "fusion") + if os.path.exists(fusion_dir): + distribution['fusion'] = DataAnalyzer._analyze_fusion_data(fusion_dir) + + return distribution @staticmethod - def _analyze_file_distribution(data_dir): - """分析文件分布""" + def _analyze_raw_data(data_dir): + """分析原始数据""" distribution = {} + raw_path = os.path.join(data_dir, "raw") + + if not os.path.exists(raw_path): + return distribution # 分析原始图像 - raw_dirs = [] - raw_path = os.path.join(data_dir, "raw") - if os.path.exists(raw_path): - raw_dirs = [d for d in os.listdir(raw_path) if os.path.isdir(os.path.join(raw_path, d))] - - for raw_dir in raw_dirs: - path = os.path.join(data_dir, "raw", raw_dir) - camera_stats = {} - for camera_dir in os.listdir(path): - camera_path = os.path.join(path, camera_dir) - if os.path.isdir(camera_path): - images = [f for f in os.listdir(camera_path) - if f.endswith(('.png', '.jpg', '.jpeg'))] - camera_stats[camera_dir] = len(images) - distribution[f'raw_{raw_dir}'] = camera_stats - - # 分析拼接图像 - stitched_dir = os.path.join(data_dir, "stitched") - if os.path.exists(stitched_dir): - stitched_images = [f for f in os.listdir(stitched_dir) - if f.endswith(('.jpg', '.jpeg', '.png'))] - distribution['stitched'] = len(stitched_images) - - # 分析标注文件 - annotations_dir = os.path.join(data_dir, "annotations") - if os.path.exists(annotations_dir): - json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] - distribution['annotations'] = len(json_files) - - # 分析LiDAR数据 - lidar_dir = os.path.join(data_dir, "lidar") - if os.path.exists(lidar_dir): - bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] - npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] - distribution['lidar'] = {'bin': len(bin_files), 'npy': len(npy_files)} - - # 分析融合数据 - fusion_dir = os.path.join(data_dir, "fusion") - if os.path.exists(fusion_dir): - json_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] - distribution['fusion'] = len(json_files) + for raw_dir in os.listdir(raw_path): + full_path = os.path.join(raw_path, raw_dir) + if os.path.isdir(full_path): + camera_stats = {} + total_images = 0 + + for camera_dir in os.listdir(full_path): + camera_path = os.path.join(full_path, camera_dir) + if os.path.isdir(camera_path): + images = [f for f in os.listdir(camera_path) + if f.lower().endswith(('.png', '.jpg', '.jpeg'))] + camera_stats[camera_dir] = len(images) + total_images += len(images) + + distribution[f'raw_{raw_dir}'] = { + 'cameras': camera_stats, + 'total_images': total_images, + 'camera_count': len(camera_stats) + } return distribution + @staticmethod + def _analyze_lidar_data(lidar_dir): + """分析LiDAR数据""" + lidar_stats = { + 'bin': 0, + 'npy': 0, + 'json': 0, + 'batch': 0, + 'pcd': 0, + 'total_size_mb': 0 + } + + total_size = 0 + for root, dirs, files in os.walk(lidar_dir): + for file in files: + file_path = os.path.join(root, file) + ext = os.path.splitext(file)[1].lower() + + try: + file_size = os.path.getsize(file_path) + total_size += file_size + + if ext == '.bin': + lidar_stats['bin'] += 1 + elif ext == '.npy': + lidar_stats['npy'] += 1 + elif ext == '.json': + lidar_stats['json'] += 1 + elif 'batch' in file: + lidar_stats['batch'] += 1 + elif ext == '.pcd': + lidar_stats['pcd'] += 1 + except: + pass + + lidar_stats['total_size_mb'] = round(total_size / (1024 * 1024), 2) + return lidar_stats + + @staticmethod + def _analyze_fusion_data(fusion_dir): + """分析融合数据""" + fusion_stats = { + 'sync_files': 0, + 'calibration_files': 0, + 'total_size_mb': 0, + 'formats': defaultdict(int) + } + + total_size = 0 + for root, dirs, files in os.walk(fusion_dir): + for file in files: + file_path = os.path.join(root, file) + ext = os.path.splitext(file)[1].lower() + + try: + file_size = os.path.getsize(file_path) + total_size += file_size + fusion_stats['formats'][ext] += 1 + + if 'sync' in file: + fusion_stats['sync_files'] += 1 + elif 'calib' in file or 'intrinsic' in file or 'extrinsic' in file: + fusion_stats['calibration_files'] += 1 + except: + pass + + fusion_stats['total_size_mb'] = round(total_size / (1024 * 1024), 2) + return fusion_stats + @staticmethod def _analyze_objects(data_dir): - """分析物体统计""" + """分析物体统计(优化版)""" annotations_dir = os.path.join(data_dir, "annotations") if not os.path.exists(annotations_dir): - return {'total_objects': 0, 'by_class': {}, 'by_frame': {}, 'class_distribution': {}} + return { + 'total_objects': 0, + 'by_class': {}, + 'by_frame': {}, + 'class_distribution': {}, + 'object_density': 0, + 'frames_with_objects': 0 + } object_stats = { 'total_objects': 0, 'by_class': defaultdict(int), 'by_frame': defaultdict(int), - 'class_distribution': {} + 'class_distribution': {}, + 'object_density': 0, + 'frames_with_objects': 0, + 'objects_per_frame_stats': {}, + 'class_combinations': set() } json_files = [f for f in os.listdir(annotations_dir) - if f.endswith('.json') and f.startswith('frame_')] + if f.lower().endswith('.json') and f.startswith('frame_')] - for json_file in json_files: + if not json_files: + return object_stats + + # 采样分析,避免处理所有文件 + sample_size = min(50, len(json_files)) + sample_files = random.sample(json_files, sample_size) if len(json_files) > 50 else json_files + + objects_per_frame = [] + + for json_file in sample_files: try: - with open(os.path.join(annotations_dir, json_file), 'r') as f: + with open(os.path.join(annotations_dir, json_file), 'r', encoding='utf-8') as f: data = json.load(f) frame_id = data.get('frame_id', 0) @@ -150,49 +383,131 @@ def _analyze_objects(data_dir): object_stats['by_frame'][frame_id] = len(objects) object_stats['total_objects'] += len(objects) + objects_per_frame.append(len(objects)) + + if objects: + object_stats['frames_with_objects'] += 1 + # 统计类别和组合 + frame_classes = set() for obj in objects: obj_class = obj.get('class', 'unknown') object_stats['by_class'][obj_class] += 1 + frame_classes.add(obj_class) + + if frame_classes: + object_stats['class_combinations'].add(tuple(sorted(frame_classes))) except Exception as e: print(f"分析标注文件 {json_file} 失败: {e}") + # 估算总数 + if sample_files: + avg_objects_per_file = object_stats['total_objects'] / len(sample_files) + object_stats['total_objects'] = int(avg_objects_per_file * len(json_files)) + object_stats['frames_with_objects'] = int( + (object_stats['frames_with_objects'] / len(sample_files)) * len(json_files)) + # 计算类分布百分比 if object_stats['total_objects'] > 0: + total = sum(object_stats['by_class'].values()) for obj_class, count in object_stats['by_class'].items(): object_stats['class_distribution'][obj_class] = round( - count / object_stats['total_objects'] * 100, 2) + count / total * 100, 2 + ) + + # 计算物体密度统计 + if objects_per_frame: + object_stats['objects_per_frame_stats'] = { + 'min': min(objects_per_frame), + 'max': max(objects_per_frame), + 'mean': round(np.mean(objects_per_frame), 2), + 'median': round(np.median(objects_per_frame), 2), + 'std': round(np.std(objects_per_frame), 2) + } + object_stats['object_density'] = round(np.mean(objects_per_frame), 2) + + # 转换组合为可序列化的列表 + object_stats['class_combinations'] = [ + list(combo) for combo in object_stats['class_combinations'] + ] return object_stats @staticmethod def _analyze_temporal(data_dir): - """分析时间分布""" + """分析时间分布(增强版)""" temporal_stats = { 'frame_intervals': [], 'total_duration': 0, - 'frame_rate': 0 + 'frame_rate': 0, + 'temporal_coverage': 0, + 'frame_consistency': 100, + 'time_range': {} } metadata_file = os.path.join(data_dir, "metadata", "collection_info.json") if os.path.exists(metadata_file): try: - with open(metadata_file, 'r') as f: + with open(metadata_file, 'r', encoding='utf-8') as f: metadata = json.load(f) collection_stats = metadata.get('collection_stats', {}) temporal_stats['total_duration'] = collection_stats.get('duration_seconds', 0) - temporal_stats['frame_rate'] = collection_stats.get('average_fps', 0) + temporal_stats['frame_rate'] = collection_stats.get('frame_rate', 0) + + # 计算时间覆盖 + if 'performance' in metadata: + perf = metadata['performance'] + if 'total_runtime' in perf and temporal_stats['total_duration'] > 0: + temporal_stats['temporal_coverage'] = round( + min(100, temporal_stats['total_duration'] / perf['total_runtime'] * 100), 1 + ) + + # 获取时间范围 + if 'collection' in metadata: + coll = metadata['collection'] + temporal_stats['time_range'] = { + 'start_time': coll.get('start_time', 'unknown'), + 'end_time': coll.get('end_time', 'unknown'), + 'duration_hours': round(coll.get('duration', 0) / 3600, 2) + } except Exception as e: print(f"分析元数据失败: {e}") + # 从文件时间推断时间范围 + try: + all_files = [] + for root, dirs, files in os.walk(data_dir): + for file in files: + if file.endswith(('.png', '.jpg', '.jpeg', '.json', '.bin')): + file_path = os.path.join(root, file) + try: + mtime = os.path.getmtime(file_path) + all_files.append((file_path, mtime)) + except: + pass + + if all_files: + all_files.sort(key=lambda x: x[1]) + oldest = all_files[0][1] + newest = all_files[-1][1] + + if not temporal_stats['time_range']: + temporal_stats['time_range'] = { + 'start_time': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(oldest)), + 'end_time': time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(newest)), + 'duration_hours': round((newest - oldest) / 3600, 2) + } + except Exception as e: + print(f"分析文件时间失败: {e}") + return temporal_stats @staticmethod def _analyze_cooperative_data(data_dir): - """分析协同数据""" + """分析协同数据(增强版)""" coop_dir = os.path.join(data_dir, "cooperative") if not os.path.exists(coop_dir): @@ -200,95 +515,196 @@ def _analyze_cooperative_data(data_dir): 'v2x_messages': 0, 'shared_perception': 0, 'vehicles_count': 0, - 'communication_stats': {} + 'communication_stats': {}, + 'cooperation_level': 'none', + 'data_quality': {} + } + + analysis = { + 'v2x_messages': 0, + 'shared_perception_frames': 0, + 'total_vehicles': 0, + 'ego_vehicles': 0, + 'cooperative_vehicles': 0, + 'v2x_stats': { + 'total_messages': 0, + 'message_types': defaultdict(int), + 'average_message_size': 0, + 'message_frequency': 0 + }, + 'shared_objects_count': 0, + 'communication_range': 0, + 'collaborative_detections': 0, + 'cooperation_level': 'low', + 'data_quality': { + 'message_completeness': 0, + 'perception_consistency': 0, + 'temporal_alignment': 0 } + } # V2X消息统计 v2x_dir = os.path.join(coop_dir, "v2x_messages") v2x_files = [] if os.path.exists(v2x_dir): - v2x_files = [f for f in os.listdir(v2x_dir) if f.endswith('.json')] + v2x_files = [f for f in os.listdir(v2x_dir) if f.lower().endswith('.json')] + analysis['v2x_messages'] = len(v2x_files) # 共享感知统计 perception_dir = os.path.join(coop_dir, "shared_perception") perception_files = [] if os.path.exists(perception_dir): - perception_files = [f for f in os.listdir(perception_dir) if f.endswith('.json')] + perception_files = [f for f in os.listdir(perception_dir) if f.lower().endswith('.json')] + analysis['shared_perception_frames'] = len(perception_files) # 读取协同摘要 coop_summary = {} summary_file = os.path.join(coop_dir, "cooperative_summary.json") if os.path.exists(summary_file): try: - with open(summary_file, 'r') as f: + with open(summary_file, 'r', encoding='utf-8') as f: coop_summary = json.load(f) except: pass # 分析V2X消息内容 - v2x_stats = { - 'total_messages': len(v2x_files), - 'message_types': defaultdict(int), - 'average_message_size': 0 - } - if v2x_files: total_size = 0 - for v2x_file in v2x_files[:min(10, len(v2x_files))]: # 抽样分析 + valid_messages = 0 + sample_size = min(20, len(v2x_files)) + + for v2x_file in v2x_files[:sample_size]: try: - with open(os.path.join(v2x_dir, v2x_file), 'r') as f: + with open(os.path.join(v2x_dir, v2x_file), 'r', encoding='utf-8') as f: data = json.load(f) - message_type = data.get('message', {}).get('message_type', 'unknown') - v2x_stats['message_types'][message_type] += 1 + + message = data.get('message', {}) + message_type = message.get('message_type', 'unknown') + analysis['v2x_stats']['message_types'][message_type] += 1 file_size = os.path.getsize(os.path.join(v2x_dir, v2x_file)) total_size += file_size + valid_messages += 1 + + # 检查消息完整性 + required_fields = ['sender_id', 'message_type', 'timestamp'] + completeness = sum(1 for field in required_fields if field in message) / len(required_fields) + analysis['data_quality']['message_completeness'] += completeness + except: pass - v2x_stats['average_message_size'] = round(total_size / max(len(v2x_files), 1), 2) + if valid_messages > 0: + analysis['v2x_stats']['average_message_size'] = round(total_size / valid_messages, 2) + analysis['data_quality']['message_completeness'] = round( + analysis['data_quality']['message_completeness'] / valid_messages * 100, 1 + ) - analysis = { - 'v2x_messages': len(v2x_files), - 'shared_perception_frames': len(perception_files), + # 分析共享感知数据 + if perception_files: + consistent_frames = 0 + sample_size = min(10, len(perception_files)) + + for perception_file in perception_files[:sample_size]: + try: + with open(os.path.join(perception_dir, perception_file), 'r', encoding='utf-8') as f: + data = json.load(f) + + # 检查数据一致性 + if 'shared_objects' in data and 'timestamp' in data and 'frame_id' in data: + consistent_frames += 1 + except: + pass + + if sample_size > 0: + analysis['data_quality']['perception_consistency'] = round( + consistent_frames / sample_size * 100, 1 + ) + + # 从摘要中获取数据 + analysis.update({ 'total_vehicles': coop_summary.get('total_vehicles', 0), 'ego_vehicles': coop_summary.get('ego_vehicles', 0), 'cooperative_vehicles': coop_summary.get('cooperative_vehicles', 0), - 'v2x_stats': v2x_stats, 'shared_objects_count': coop_summary.get('shared_objects_count', 0), 'communication_range': coop_summary.get('communication_range', 0), 'collaborative_detections': coop_summary.get('v2x_stats', {}).get('collaborative_detections', 0) - } + }) + + # 计算合作水平 + cooperation_score = 0 + if analysis['v2x_messages'] > 50 and analysis['shared_perception_frames'] > 20: + cooperation_score = 90 + analysis['cooperation_level'] = 'high' + elif analysis['v2x_messages'] > 10 and analysis['shared_perception_frames'] > 5: + cooperation_score = 60 + analysis['cooperation_level'] = 'medium' + elif analysis['v2x_messages'] > 0 or analysis['shared_perception_frames'] > 0: + cooperation_score = 30 + analysis['cooperation_level'] = 'low' + + analysis['cooperation_score'] = cooperation_score return analysis @staticmethod def _calculate_quality_metrics(data_dir): - """计算质量指标""" + """计算质量指标(增强版)""" quality_metrics = { 'completeness_score': 0, 'consistency_score': 0, 'diversity_score': 0, 'cooperative_score': 0, - 'issues_found': [] + 'temporal_score': 0, + 'structural_score': 0, + 'issues_found': [], + 'recommendations': [] } - # 检查完整性 - required_dirs = ["raw/vehicle", "raw/infrastructure", "stitched", "metadata", "cooperative"] - missing_dirs = [] + # 1. 检查完整性 + required_dirs = [ + "raw/vehicle", + "raw/infrastructure", + "stitched", + "metadata", + "cooperative" + ] + + optional_dirs = [ + "lidar", + "fusion", + "annotations", + "calibration" + ] + + missing_required = [] + missing_optional = [] for dir_path in required_dirs: full_path = os.path.join(data_dir, dir_path) if not os.path.exists(full_path): - missing_dirs.append(dir_path) + missing_required.append(dir_path) + + for dir_path in optional_dirs: + full_path = os.path.join(data_dir, dir_path) + if not os.path.exists(full_path): + missing_optional.append(dir_path) - if missing_dirs: - quality_metrics['issues_found'].append(f"缺失目录: {missing_dirs}") - quality_metrics['completeness_score'] = 100 - (len(missing_dirs) * 20) + if missing_required: + quality_metrics['issues_found'].append(f"缺失必要目录: {missing_required}") + quality_metrics['completeness_score'] = 100 - (len(missing_required) * 20) else: quality_metrics['completeness_score'] = 100 - # 检查一致性(图像数量) + # 2. 结构评分 + structure_score = 100 + if missing_optional: + structure_score -= len(missing_optional) * 5 + quality_metrics['recommendations'].append(f"建议添加可选目录: {missing_optional[:3]}") + + quality_metrics['structural_score'] = max(0, structure_score) + + # 3. 检查一致性(图像数量) raw_vehicle = os.path.join(data_dir, "raw", "vehicle") if os.path.exists(raw_vehicle): camera_counts = [] @@ -296,167 +712,315 @@ def _calculate_quality_metrics(data_dir): camera_path = os.path.join(raw_vehicle, camera_dir) if os.path.isdir(camera_path): images = [f for f in os.listdir(camera_path) - if f.endswith('.png')] + if f.lower().endswith(('.png', '.jpg', '.jpeg'))] camera_counts.append(len(images)) if camera_counts: max_diff = max(camera_counts) - min(camera_counts) if camera_counts else 0 - if max_diff > 5: - quality_metrics['issues_found'].append(f"摄像头图像数量不一致: 差异{max_diff}") - quality_metrics['consistency_score'] = 70 + if max_diff > 10: + quality_metrics['issues_found'].append(f"摄像头图像数量严重不一致: 最大差异{max_diff}张") + quality_metrics['consistency_score'] = 60 + elif max_diff > 5: + quality_metrics['issues_found'].append(f"摄像头图像数量不一致: 差异{max_diff}张") + quality_metrics['consistency_score'] = 75 else: quality_metrics['consistency_score'] = 95 + else: + quality_metrics['consistency_score'] = 70 + quality_metrics['issues_found'].append("车辆摄像头无图像数据") + else: + quality_metrics['consistency_score'] = 50 - # 多样性评分(基于物体类别) + # 4. 多样性评分(基于物体类别) object_stats = DataAnalyzer._analyze_objects(data_dir) num_classes = len(object_stats.get('by_class', {})) + class_distribution = object_stats.get('class_distribution', {}) - if num_classes >= 5: - quality_metrics['diversity_score'] = 90 + if num_classes >= 8: + quality_metrics['diversity_score'] = 95 + elif num_classes >= 5: + quality_metrics['diversity_score'] = 80 elif num_classes >= 3: - quality_metrics['diversity_score'] = 70 - else: - quality_metrics['diversity_score'] = 50 + quality_metrics['diversity_score'] = 65 quality_metrics['issues_found'].append(f"物体类别较少: {num_classes}类") + else: + quality_metrics['diversity_score'] = 40 + quality_metrics['issues_found'].append(f"物体类别过少: {num_classes}类") - # 协同评分 + # 检查类别分布是否均衡 + if class_distribution: + values = list(class_distribution.values()) + if max(values) > 70: # 某个类别占比超过70% + quality_metrics['diversity_score'] *= 0.8 # 降低分数 + quality_metrics['recommendations'].append("数据集类别分布不均衡,建议收集更多样化的场景") + + # 5. 协同评分 cooperative_data = DataAnalyzer._analyze_cooperative_data(data_dir) - if cooperative_data['v2x_messages'] > 10 and cooperative_data['shared_perception_frames'] > 5: - quality_metrics['cooperative_score'] = 90 - elif cooperative_data['v2x_messages'] > 0 or cooperative_data['shared_perception_frames'] > 0: - quality_metrics['cooperative_score'] = 60 + quality_metrics['cooperative_score'] = cooperative_data.get('cooperation_score', 0) + + if quality_metrics['cooperative_score'] < 50: + quality_metrics['issues_found'].append("协同数据较少或质量不高") + quality_metrics['recommendations'].append("增加V2X消息和共享感知数据的生成") + + # 6. 时间评分 + temporal_data = DataAnalyzer._analyze_temporal(data_dir) + frame_rate = temporal_data.get('frame_rate', 0) + duration = temporal_data.get('total_duration', 0) + + if frame_rate >= 5.0: + quality_metrics['temporal_score'] = 95 + elif frame_rate >= 2.0: + quality_metrics['temporal_score'] = 80 + elif frame_rate >= 1.0: + quality_metrics['temporal_score'] = 60 else: - quality_metrics['cooperative_score'] = 30 - quality_metrics['issues_found'].append("协同数据较少") + quality_metrics['temporal_score'] = 30 + quality_metrics['issues_found'].append(f"帧率较低: {frame_rate:.2f} FPS") + + if duration < 30: + quality_metrics['temporal_score'] *= 0.8 # 时长不足,降低分数 + quality_metrics['recommendations'].append("建议增加数据收集时长以获得更完整的时间序列") + + # 限制分数在0-100之间 + for key in ['completeness_score', 'consistency_score', 'diversity_score', + 'cooperative_score', 'temporal_score', 'structural_score']: + quality_metrics[key] = max(0, min(100, quality_metrics[key])) return quality_metrics @staticmethod def _calculate_overall_score(analysis): - """计算总体评分""" + """计算总体评分(增强版)""" weights = { - 'completeness': 0.25, - 'consistency': 0.20, - 'diversity': 0.15, - 'cooperative': 0.20, - 'temporal': 0.20 + 'completeness': 0.20, # 完整性 + 'consistency': 0.15, # 一致性 + 'demporal': 0.15, # 时间性 + 'structural': 0.10, # 结构性 + 'diversity': 0.15, # 多样性 + 'cooperative': 0.15, # 协同性 + 'quality_bonus': 0.10 # 质量加成 } quality = analysis['quality_metrics'] - score = ( + # 基础分数 + base_score = ( quality['completeness_score'] * weights['completeness'] + quality['consistency_score'] * weights['consistency'] + + quality['temporal_score'] * weights['temporal'] + + quality['structural_score'] * weights['structural'] + quality['diversity_score'] * weights['diversity'] + quality['cooperative_score'] * weights['cooperative'] ) - # 时间因素 - temporal = analysis['temporal_analysis'] - if temporal['frame_rate'] >= 2.0: - score += 20 * weights['temporal'] - elif temporal['frame_rate'] >= 1.0: - score += 15 * weights['temporal'] - else: - score += 5 * weights['temporal'] + # 质量加成(基于问题数量) + issues_count = len(quality.get('issues_found', [])) + quality_bonus = max(0, 100 - issues_count * 5) * weights['quality_bonus'] + + total_score = base_score + quality_bonus - return round(min(score, 100), 1) + # 额外加成(如果数据集特别优秀) + if (quality['completeness_score'] >= 95 and + quality['consistency_score'] >= 90 and + quality['diversity_score'] >= 85): + total_score += 5 + + return round(min(total_score, 100), 1) @staticmethod def _save_analysis_report(data_dir, analysis): - """保存分析报告""" - report_file = os.path.join(data_dir, "metadata", "dataset_analysis.json") + """保存分析报告(优化版)""" + metadata_dir = os.path.join(data_dir, "metadata") + os.makedirs(metadata_dir, exist_ok=True) + + report_file = os.path.join(metadata_dir, "dataset_analysis.json") + # 保存完整报告 with open(report_file, 'w', encoding='utf-8') as f: json.dump(analysis, f, indent=2, ensure_ascii=False) + # 保存摘要报告(轻量版) + summary = { + 'overall_score': analysis['overall_score'], + 'quality_metrics': analysis['quality_metrics'], + 'basic_stats': { + 'total_size_mb': analysis['basic_stats']['total_size_mb'], + 'file_count': analysis['basic_stats']['file_count'], + 'directory_count': analysis['basic_stats']['directory_count'] + }, + 'object_statistics': { + 'total_objects': analysis['object_statistics']['total_objects'], + 'num_classes': len(analysis['object_statistics']['by_class']) + }, + 'analysis_metadata': analysis.get('metadata', {}) + } + + summary_file = os.path.join(metadata_dir, "dataset_summary.json") + with open(summary_file, 'w', encoding='utf-8') as f: + json.dump(summary, f, indent=2, ensure_ascii=False) + print(f"数据集分析报告保存: {report_file}") + print(f"数据集摘要保存: {summary_file}") @staticmethod def _print_analysis_summary(analysis): - """打印分析摘要""" - print("\n" + "=" * 60) + """打印分析摘要(增强版)""" + print("\n" + "=" * 70) print("数据集分析摘要") - print("=" * 60) + print("=" * 70) + # 基本统计 basic = analysis['basic_stats'] - print(f"\n基本统计:") + print(f"\n📊 基本统计:") print(f" 总大小: {basic['total_size_mb']} MB") - print(f" 文件数: {basic['file_count']}") + print(f" 文件数: {basic['file_count']:,}") print(f" 目录数: {basic['directory_count']}") - - print(f" 数据类型:") + print(f" 数据类型分布:") for data_type, count in basic['data_types'].items(): - print(f" {data_type}: {count}") + print(f" {data_type}: {count:,}") + if basic['largest_files']: + print(f" 最大的文件:") + for file_info in basic['largest_files'][:3]: + print(f" {file_info['path']}: {file_info['size_mb']} MB") + + # 文件分布 distribution = analysis['file_distribution'] - print(f"\n文件分布:") + print(f"\n📁 文件分布:") for key, value in distribution.items(): if isinstance(value, dict): - print(f" {key}:") - for subkey, subvalue in value.items(): - if isinstance(subvalue, dict): - for subsubkey, subsubvalue in subvalue.items(): - print(f" {subsubkey}: {subsubvalue}") - else: - print(f" {subkey}: {subvalue}") + if 'total' in value: + print(f" {key}: {value['total']:,}") + if 'formats' in value: + for fmt, count in value['formats'].items(): + print(f" {fmt}: {count:,}") + else: + print(f" {key}:") + for subkey, subvalue in value.items(): + print(f" {subkey}: {subvalue:,}") else: - print(f" {key}: {value}") + print(f" {key}: {value:,}") + # 物体统计 objects = analysis['object_statistics'] - print(f"\n物体统计:") - print(f" 总物体数: {objects['total_objects']}") + print(f"\n🎯 物体统计:") + print(f" 总物体数: {objects['total_objects']:,}") + print(f" 有物体的帧数: {objects['frames_with_objects']:,}") + print(f" 平均每帧物体数: {objects['object_density']:.2f}") + if objects['by_class']: print(f" 类别分布:") - for obj_class, count in objects['by_class'].items(): + for obj_class, count in sorted(objects['by_class'].items(), key=lambda x: x[1], reverse=True)[:5]: percentage = objects['class_distribution'].get(obj_class, 0) - print(f" {obj_class}: {count} ({percentage}%)") + print(f" {obj_class}: {count:,} ({percentage}%)") + + if objects['objects_per_frame_stats']: + stats = objects['objects_per_frame_stats'] + print(f" 每帧物体数统计:") + print(f" 最小: {stats['min']}, 最大: {stats['max']}, 平均: {stats['mean']}, 中位数: {stats['median']}") # 协同数据分析 cooperative = analysis['cooperative_data'] - print(f"\n协同数据分析:") - print(f" V2X消息: {cooperative['v2x_messages']}") - print(f" 共享感知帧: {cooperative['shared_perception_frames']}") + print(f"\n🤝 协同数据分析:") + print(f" 合作水平: {cooperative['cooperation_level'].upper()}") + print(f" V2X消息: {cooperative['v2x_messages']:,}") + print(f" 共享感知帧: {cooperative['shared_perception_frames']:,}") print(f" 车辆总数: {cooperative['total_vehicles']}") - print(f" 主车: {cooperative['ego_vehicles']}") - print(f" 协同车: {cooperative['cooperative_vehicles']}") - print(f" 共享对象数: {cooperative['shared_objects_count']}") - print(f" 协作检测数: {cooperative['collaborative_detections']}") + print(f" ├ 主车: {cooperative['ego_vehicles']}") + print(f" └ 协同车: {cooperative['cooperative_vehicles']}") + print(f" 共享对象数: {cooperative['shared_objects_count']:,}") + print(f" 协作检测数: {cooperative['collaborative_detections']:,}") if cooperative['v2x_stats']['message_types']: print(f" V2X消息类型:") for msg_type, count in cooperative['v2x_stats']['message_types'].items(): print(f" {msg_type}: {count}") + # 时间分析 temporal = analysis['temporal_analysis'] - print(f"\n时间分析:") - print(f" 总时长: {temporal['total_duration']:.1f}秒") + print(f"\n⏰ 时间分析:") + print(f" 总时长: {temporal['total_duration']:.1f}秒 ({temporal['total_duration'] / 60:.1f}分钟)") print(f" 平均帧率: {temporal['frame_rate']:.2f} FPS") + print(f" 时间覆盖率: {temporal['temporal_coverage']}%") + + if temporal['time_range']: + tr = temporal['time_range'] + print(f" 时间范围: {tr.get('start_time', 'N/A')} 到 {tr.get('end_time', 'N/A')}") + if 'duration_hours' in tr: + print(f" 持续时间: {tr['duration_hours']:.1f}小时") + # 质量指标 quality = analysis['quality_metrics'] - print(f"\n质量指标:") - print(f" 完整性: {quality['completeness_score']}/100") - print(f" 一致性: {quality['consistency_score']}/100") - print(f" 多样性: {quality['diversity_score']}/100") - print(f" 协同性: {quality['cooperative_score']}/100") + print(f"\n📈 质量指标:") + metrics = [ + ('完整性', quality['completeness_score']), + ('一致性', quality['consistency_score']), + ('结构性', quality['structural_score']), + ('时间性', quality['temporal_score']), + ('多样性', quality['diversity_score']), + ('协同性', quality['cooperative_score']) + ] + + for name, score in metrics: + bar = "█" * int(score / 5) + print(f" {name:8s}: {score:3.0f}/100 {bar}") if quality['issues_found']: - print(f" 发现的问题 ({len(quality['issues_found'])}):") - for issue in quality['issues_found'][:3]: - print(f" - {issue}") - if len(quality['issues_found']) > 3: - print(f" ... 还有 {len(quality['issues_found']) - 3} 个问题") + print(f"\n⚠️ 发现的问题 ({len(quality['issues_found'])}):") + for i, issue in enumerate(quality['issues_found'][:5], 1): + print(f" {i}. {issue}") + if len(quality['issues_found']) > 5: + print(f" ... 还有 {len(quality['issues_found']) - 5} 个问题") - print(f"\n总体评分: {analysis['overall_score']}/100") + if quality['recommendations']: + print(f"\n💡 改进建议:") + for i, rec in enumerate(quality['recommendations'][:3], 1): + print(f" {i}. {rec}") + + print(f"\n⭐ 总体评分: {analysis['overall_score']}/100") overall_score = analysis['overall_score'] if overall_score >= 90: - print("✓ 数据集质量优秀") - elif overall_score >= 75: - print("✓ 数据集质量良好") + print("🎉 数据集质量优秀 - 可直接用于模型训练") + elif overall_score >= 80: + print("👍 数据集质量良好 - 建议进行少量数据增强") + elif overall_score >= 70: + print("⚠️ 数据集质量一般 - 建议进行数据清洗和增强") elif overall_score >= 60: - print("⚠ 数据集质量一般") + print("🔧 数据集质量需要改进 - 建议补充缺失数据") else: - print("✗ 数据集质量需要改进") + print("🚨 数据集质量较差 - 需要大规模改进") + + # 分析元数据 + if 'metadata' in analysis: + meta = analysis['metadata'] + print(f"\n📝 分析信息:") + print(f" 分析时间: {meta.get('analysis_time', 'N/A')}") + print(f" 分析耗时: {meta.get('analysis_duration', 0):.1f}秒") - print("=" * 60) \ No newline at end of file + print("=" * 70) + + @staticmethod + def generate_comparison_report(data_dirs, output_file=None): + """生成多个数据集的比较报告""" + comparisons = {} + + for data_dir in data_dirs: + if os.path.exists(data_dir): + analysis = DataAnalyzer.analyze_dataset(data_dir) + comparisons[os.path.basename(data_dir)] = { + 'overall_score': analysis['overall_score'], + 'basic_stats': analysis['basic_stats'], + 'quality_metrics': analysis['quality_metrics'], + 'object_statistics': { + 'total_objects': analysis['object_statistics']['total_objects'], + 'num_classes': len(analysis['object_statistics']['by_class']) + } + } + + if output_file: + with open(output_file, 'w', encoding='utf-8') as f: + json.dump(comparisons, f, indent=2, ensure_ascii=False) + print(f"比较报告保存到: {output_file}") + + return comparisons \ No newline at end of file From 711cf9576378c976840e3439da7a64b3682c29d8 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 09:56:03 +0800 Subject: [PATCH 10/21] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E9=85=8D=E7=BD=AE?= =?UTF-8?q?=E9=AA=8C=E8=AF=81=E5=92=8C=E5=8A=A8=E6=80=81=E8=B0=83=E6=95=B4?= =?UTF-8?q?=EF=BC=8C=E6=B7=BB=E5=8A=A0=E6=89=B9=E9=87=8F=E5=A4=84=E7=90=86?= =?UTF-8?q?=E5=92=8C=E6=80=A7=E8=83=BD=E4=BC=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 652 +++++++- .../sensor_enhancer.py | 1326 +++++++++-------- 2 files changed, 1286 insertions(+), 692 deletions(-) diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 183cb3cab3..1f64c72ef9 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -1,20 +1,298 @@ import json import os import argparse +import copy +from typing import Dict, Any, Optional, List, Tuple + +# 尝试导入yaml,如果不存在则跳过 +try: + import yaml + + YAML_AVAILABLE = True +except ImportError: + YAML_AVAILABLE = False + print("警告: PyYAML未安装,将使用JSON格式") + + +class ConfigValidator: + """配置验证器""" + + @staticmethod + def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: + """验证配置的有效性""" + errors = [] + + # 验证必填字段 + required_sections = ['scenario', 'sensors', 'output'] + for section in required_sections: + if section not in config: + errors.append(f"缺失必要配置节: {section}") + + # 验证场景配置 + if 'scenario' in config: + scenario = config['scenario'] + if 'duration' in scenario and scenario['duration'] <= 0: + errors.append("场景时长必须大于0") + if 'town' not in scenario: + errors.append("场景配置中缺失地图名称") + + # 验证传感器配置 + if 'sensors' in config: + sensors = config['sensors'] + if 'capture_interval' in sensors and sensors['capture_interval'] <= 0: + errors.append("采集间隔必须大于0") + if 'image_size' in sensors: + if len(sensors['image_size']) != 2: + errors.append("图像尺寸必须为[宽度, 高度]格式") + elif any(dim <= 0 for dim in sensors['image_size']): + errors.append("图像尺寸必须大于0") + + # 验证性能配置 + if 'performance' in config: + perf = config['performance'] + if 'batch_size' in perf and perf['batch_size'] <= 0: + errors.append("批处理大小必须大于0") + + return len(errors) == 0, errors + + @staticmethod + def suggest_optimizations(config: Dict[str, Any]) -> List[str]: + """根据配置提供优化建议""" + suggestions = [] + + # 内存使用建议 + if config.get('sensors', {}).get('lidar_sensors', 0) > 0: + lidar_config = config['sensors'].get('lidar_config', {}) + max_points = lidar_config.get('max_points_per_frame', 50000) + if max_points > 50000: + suggestions.append(f"LiDAR最大点数({max_points})较高,建议降低到50000以下以减少内存使用") + + # 性能建议 + capture_interval = config['sensors'].get('capture_interval', 2.0) + if capture_interval < 1.0: + suggestions.append(f"采集间隔({capture_interval}s)较短,可能导致高负载,建议增加到1.0s以上") + + # 输出建议 + output = config.get('output', {}) + enabled_outputs = [k for k, v in output.items() if isinstance(v, bool) and v] + if len(enabled_outputs) > 5: + suggestions.append(f"启用的输出类型过多({len(enabled_outputs)}),可能影响性能,建议只启用必要的输出") + + return suggestions + + +class ConfigOptimizer: + """配置优化器""" + + @staticmethod + def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: + """为内存使用优化配置""" + optimized = copy.deepcopy(config) + + # 调整LiDAR设置 + if optimized['sensors'].get('lidar_sensors', 0) > 0: + lidar_config = optimized['sensors'].setdefault('lidar_config', {}) + lidar_config.update({ + 'max_points_per_frame': 30000, + 'downsample_ratio': 0.4, + 'memory_warning_threshold': 200, + 'max_batch_memory_mb': 30 + }) + + # 调整性能设置 + perf = optimized.setdefault('performance', {}) + perf.update({ + 'batch_size': 3, + 'enable_compression': True, + 'compression_level': 4, + 'enable_memory_cache': True, + 'max_cache_size': 30, + 'frame_rate_limit': 3.0 + }) + + # 调整图像处理 + perf['image_processing'] = { + 'compress_images': True, + 'compression_quality': 80, + 'resize_images': False + } + + return optimized + + @staticmethod + def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: + """为数据质量优化配置""" + optimized = copy.deepcopy(config) + + # 调整传感器设置 + sensors = optimized['sensors'] + sensors.update({ + 'image_size': [1920, 1080], + 'capture_interval': 1.0, + 'lidar_sensors': 1, + 'lidar_config': { + 'channels': 64, + 'range': 150.0, + 'points_per_second': 120000, + 'max_points_per_frame': 100000, + 'downsample_ratio': 0.1 + } + }) + + # 调整输出设置 + output = optimized['output'] + output.update({ + 'save_annotations': True, + 'save_fusion': True, + 'save_cooperative': True, + 'save_enhanced': True, + 'run_quality_check': True + }) + + # 调整增强设置 + enhanced = optimized.setdefault('enhancement', {}) + enhanced.update({ + 'enabled': True, + 'enable_random': True, + 'quality_check': True, + 'methods': ['normalize', 'contrast', 'sharpness', 'noise'] + }) + + return optimized + + @staticmethod + def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: + """为处理速度优化配置""" + optimized = copy.deepcopy(config) + + # 调整传感器设置 + sensors = optimized['sensors'] + sensors.update({ + 'image_size': [640, 480], + 'capture_interval': 3.0, + 'lidar_sensors': 0, # 禁用LiDAR + 'radar_sensors': 0 # 禁用雷达 + }) + + # 调整性能设置 + perf = optimized.setdefault('performance', {}) + perf.update({ + 'batch_size': 10, + 'enable_compression': True, + 'compression_level': 1, # 快速压缩 + 'enable_downsampling': True, + 'enable_async_processing': True, + 'max_cache_size': 20, + 'frame_rate_limit': 10.0 + }) + + # 简化输出 + output = optimized['output'] + output.update({ + 'save_raw': True, + 'save_stitched': False, # 不拼接图像 + 'save_annotations': False, + 'save_lidar': False, + 'save_fusion': False, + 'save_cooperative': False + }) + + return optimized class ConfigManager: + """配置管理器(增强版)""" + + # 预定义配置模板 + PRESET_CONFIGS = { + 'balanced': { + 'description': '平衡配置 - 兼顾性能和质量', + 'optimization': 'memory' + }, + 'high_quality': { + 'description': '高质量配置 - 优先数据质量', + 'optimization': 'quality' + }, + 'fast_collection': { + 'description': '快速采集配置 - 优先处理速度', + 'optimization': 'speed' + }, + 'v2x_focused': { + 'description': 'V2X重点配置 - 优化协同数据采集', + 'optimization': 'custom', + 'settings': { + 'v2x': {'enabled': True, 'update_interval': 1.0}, + 'cooperative': {'num_coop_vehicles': 3, 'enable_shared_perception': True}, + 'output': {'save_cooperative': True, 'save_v2x_messages': True} + } + }, + 'lidar_focused': { + 'description': 'LiDAR重点配置 - 优化点云数据采集', + 'optimization': 'custom', + 'settings': { + 'sensors': {'lidar_sensors': 2, 'lidar_config': {'channels': 64, 'range': 200}}, + 'output': {'save_lidar': True, 'save_fusion': True} + } + } + } + + @staticmethod + def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) -> Dict[str, Any]: + """ + 加载配置 + + Args: + config_file: 配置文件路径 + preset: 预设配置名称 + + Returns: + 配置字典 + """ + # 基础配置 + config = ConfigManager._get_default_config() + + # 应用预设配置 + if preset: + config = ConfigManager._apply_preset(config, preset) + + # 加载用户配置文件 + if config_file: + if os.path.exists(config_file): + config = ConfigManager._load_config_file(config_file, config) + else: + print(f"警告: 配置文件不存在: {config_file}") + + # 验证配置 + is_valid, errors = ConfigValidator.validate_config(config) + if not is_valid: + print("配置验证错误:") + for error in errors: + print(f" - {error}") + raise ValueError("配置验证失败") + + # 提供优化建议 + suggestions = ConfigValidator.suggest_optimizations(config) + if suggestions: + print("配置优化建议:") + for suggestion in suggestions: + print(f" ⚡ {suggestion}") + + return config @staticmethod - def load_config(config_file=None): - config = { + def _get_default_config() -> Dict[str, Any]: + """获取默认配置(增强版)""" + return { 'scenario': { 'name': 'multi_sensor_scene', + 'description': '多传感器协同数据采集场景', 'town': 'Town10HD', 'weather': 'clear', 'time_of_day': 'noon', 'duration': 60, - 'seed': 42 + 'seed': 42, + 'timeout': 300, # 超时时间(秒) + 'retry_attempts': 3 # 重试次数 }, 'traffic': { 'ego_vehicles': 1, @@ -22,25 +300,49 @@ def load_config(config_file=None): 'pedestrians': 6, 'traffic_lights': True, 'batch_spawn': True, - 'max_spawn_attempts': 5 + 'max_spawn_attempts': 5, + 'vehicle_types': [ + 'vehicle.tesla.model3', + 'vehicle.audi.tt', + 'vehicle.nissan.patrol', + 'vehicle.bmw.grandtourer' + ], + 'pedestrian_types': [ + 'walker.pedestrian.0001', + 'walker.pedestrian.0002' + ] }, 'sensors': { 'vehicle_cameras': 4, 'infrastructure_cameras': 4, 'lidar_sensors': 1, 'radar_sensors': 0, + 'gps_sensors': 0, + 'imu_sensors': 0, 'image_size': [1280, 720], 'capture_interval': 2.0, + 'sensor_placement': 'default', 'lidar_config': { 'channels': 32, - 'range': 100, + 'range': 100.0, 'points_per_second': 56000, - 'rotation_frequency': 10, - 'max_points_per_frame': 50000, # 优化点6:减少最大点数 - 'downsample_ratio': 0.3, # 优化点6:增加下采样比例 - 'memory_warning_threshold': 350, # 新增:内存警告阈值(MB) - 'max_batch_memory_mb': 50, # 新增:批次最大内存 - 'v2x_save_interval': 5 # 新增:V2X格式保存间隔 + 'rotation_frequency': 10.0, + 'horizontal_fov': 360.0, + 'vertical_fov': 30.0, + 'upper_fov': 10.0, + 'lower_fov': -20.0, + 'max_points_per_frame': 50000, + 'downsample_ratio': 0.3, + 'memory_warning_threshold': 300, + 'max_batch_memory_mb': 50, + 'v2x_save_interval': 5, + 'compression_format': 'bin' # bin, npy, pcd + }, + 'camera_config': { + 'fov': 90.0, + 'post_processing': 'default', + 'exposure_mode': 'auto', + 'motion_blur': 0.0 } }, 'v2x': { @@ -50,8 +352,11 @@ def load_config(config_file=None): 'latency_mean': 0.05, 'latency_std': 0.01, 'packet_loss_rate': 0.01, - 'message_types': ['bsm', 'spat', 'map', 'rsm'], - 'update_interval': 2.0 # 优化点6:V2X更新间隔 + 'message_types': ['bsm', 'spat', 'map', 'rsm', 'perception', 'warning'], + 'update_interval': 2.0, + 'security_enabled': False, + 'encryption_level': 'none', + 'qos_policy': 'best_effort' }, 'cooperative': { 'num_coop_vehicles': 2, @@ -59,7 +364,10 @@ def load_config(config_file=None): 'enable_traffic_warnings': True, 'enable_maneuver_coordination': False, 'data_fusion_interval': 1.0, - 'max_shared_objects': 50 + 'max_shared_objects': 50, + 'object_matching_threshold': 5.0, + 'data_retention_time': 10.0, + 'consensus_method': 'simple' }, 'enhancement': { 'enabled': True, @@ -68,7 +376,10 @@ def load_config(config_file=None): 'save_original': True, 'save_enhanced': True, 'calibration_generation': True, - 'enhanced_dir_name': 'enhanced' + 'enhanced_dir_name': 'enhanced', + 'methods': ['normalize', 'contrast', 'brightness'], + 'weather_effects': True, + 'augmentation_level': 'medium' }, 'performance': { 'batch_size': 5, @@ -77,27 +388,41 @@ def load_config(config_file=None): 'enable_downsampling': True, 'enable_memory_cache': True, 'max_cache_size': 50, + 'enable_async_processing': True, + 'max_workers': 2, 'image_processing': { 'compress_images': True, - 'compression_quality': 85 + 'compression_quality': 85, + 'resize_images': False, + 'resize_dimensions': [640, 480], + 'format': 'jpg' # jpg, png }, 'lidar_processing': { 'batch_size': 10, 'enable_compression': True, 'enable_downsampling': True, - 'max_points_per_frame': 50000, # 与sensors配置保持一致 + 'max_points_per_frame': 50000, 'memory_warning_threshold': 350, 'max_batch_memory_mb': 50, - 'v2x_save_interval': 5 + 'v2x_save_interval': 5, + 'compression_method': 'zlib' # zlib, lz4, none }, 'fusion': { - 'fusion_cache_size': 100 + 'fusion_cache_size': 100, + 'enable_cache': True, + 'compression_enabled': True }, - 'sensor_cleanup_timeout': 0.5, # 新增:传感器清理超时 - 'frame_rate_limit': 5.0 # 新增:帧率限制 + 'sensor_cleanup_timeout': 0.5, + 'frame_rate_limit': 5.0, + 'memory_management': { + 'gc_interval': 50, + 'max_memory_mb': 500, + 'early_stop_threshold': 400 + } }, 'output': { 'data_dir': 'cvips_dataset', + 'output_format': 'standard', # standard, v2xformer, kitti, coco 'save_raw': True, 'save_stitched': True, 'save_annotations': False, @@ -109,102 +434,285 @@ def load_config(config_file=None): 'validate_data': True, 'run_analysis': False, 'run_quality_check': True, - 'output_format': 'standard' + 'generate_summary': True, + 'compression_enabled': True, + 'file_naming': 'sequential', # sequential, timestamp + 'backup_original': False + }, + 'monitoring': { + 'enable_logging': True, + 'log_level': 'INFO', # DEBUG, INFO, WARNING, ERROR + 'log_file': 'cvips.log', + 'enable_performance_monitor': True, + 'performance_log_interval': 10.0, + 'enable_progress_bar': True, + 'enable_real_time_stats': True, + 'stats_update_interval': 5.0 + }, + 'debug': { + 'enable_debug_mode': False, + 'save_debug_data': False, + 'debug_dir': 'debug', + 'print_config': False, + 'validate_sensors': True, + 'test_mode': False + }, + 'metadata': { + 'version': '1.0.0', + 'author': 'CVIPS System', + 'description': '多传感器协同数据采集配置', + 'created': '', + 'modified': '' } } - if config_file and os.path.exists(config_file): - try: - with open(config_file, 'r') as f: - user_config = json.load(f) - ConfigManager._deep_update(config, user_config) - except: - pass + @staticmethod + def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: + """应用预设配置""" + if preset_name not in ConfigManager.PRESET_CONFIGS: + print(f"警告: 未知的预设配置: {preset_name}") + return config + + preset = ConfigManager.PRESET_CONFIGS[preset_name] + print(f"应用预设配置: {preset_name} - {preset['description']}") + + # 根据优化类型应用配置 + optimization = preset.get('optimization', 'balanced') + if optimization == 'memory': + config = ConfigOptimizer.optimize_for_memory(config) + elif optimization == 'quality': + config = ConfigOptimizer.optimize_for_quality(config) + elif optimization == 'speed': + config = ConfigOptimizer.optimize_for_speed(config) + elif optimization == 'custom' and 'settings' in preset: + config = ConfigManager._deep_update(config, preset['settings']) return config @staticmethod - def _deep_update(original, update): + def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str, Any]: + """加载配置文件""" + try: + with open(config_file, 'r', encoding='utf-8') as f: + if (config_file.endswith('.yaml') or config_file.endswith('.yml')) and YAML_AVAILABLE: + user_config = yaml.safe_load(f) + else: + user_config = json.load(f) + + print(f"加载配置文件: {config_file}") + return ConfigManager._deep_update(base_config, user_config) + + except Exception as e: + print(f"配置文件加载错误: {e}") + return base_config + + @staticmethod + def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]: + """深度更新字典""" for key, value in update.items(): if key in original and isinstance(original[key], dict) and isinstance(value, dict): ConfigManager._deep_update(original[key], value) else: original[key] = value + return original @staticmethod - def merge_args(config, args): - if args.scenario: + def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]: + """合并命令行参数到配置""" + # 场景参数 + if hasattr(args, 'scenario') and args.scenario: config['scenario']['name'] = args.scenario - if args.town: + if hasattr(args, 'town') and args.town: config['scenario']['town'] = args.town - if args.weather: + if hasattr(args, 'weather') and args.weather: config['scenario']['weather'] = args.weather - if args.time_of_day: + if hasattr(args, 'time_of_day') and args.time_of_day: config['scenario']['time_of_day'] = args.time_of_day - if args.duration: + if hasattr(args, 'duration') and args.duration: config['scenario']['duration'] = args.duration - if args.seed: + if hasattr(args, 'seed') and args.seed: config['scenario']['seed'] = args.seed - if args.num_vehicles: + # 交通参数 + if hasattr(args, 'num_vehicles') and args.num_vehicles: config['traffic']['background_vehicles'] = args.num_vehicles - if args.num_pedestrians: + if hasattr(args, 'num_pedestrians') and args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians + # 协同参数 if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles + # 传感器参数 if hasattr(args, 'capture_interval') and args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval - if hasattr(args, 'enable_v2x') and args.enable_v2x: - config['v2x']['enabled'] = True - # 如果通过命令行启用V2X,使用更保守的更新间隔 - if 'update_interval' not in config['v2x']: - config['v2x']['update_interval'] = 2.0 + # V2X参数 + if hasattr(args, 'enable_v2x'): + config['v2x']['enabled'] = args.enable_v2x - if hasattr(args, 'enable_enhancement') and args.enable_enhancement: - config['enhancement']['enabled'] = True + # 增强参数 + if hasattr(args, 'enable_enhancement'): + config['enhancement']['enabled'] = args.enable_enhancement - if hasattr(args, 'enable_lidar') and args.enable_lidar: - config['sensors']['lidar_sensors'] = 1 - config['output']['save_lidar'] = True - # 优化:如果启用LiDAR,使用更保守的设置 - config['sensors']['lidar_config']['max_points_per_frame'] = 50000 - config['sensors']['lidar_config']['downsample_ratio'] = 0.3 + # LiDAR参数 + if hasattr(args, 'enable_lidar'): + config['sensors']['lidar_sensors'] = 1 if args.enable_lidar else 0 + config['output']['save_lidar'] = args.enable_lidar - if hasattr(args, 'enable_fusion') and args.enable_fusion: - config['output']['save_fusion'] = True + # 融合参数 + if hasattr(args, 'enable_fusion'): + config['output']['save_fusion'] = args.enable_fusion - if hasattr(args, 'enable_cooperative') and args.enable_cooperative: - config['output']['save_cooperative'] = True + # 协同参数 + if hasattr(args, 'enable_cooperative'): + config['output']['save_cooperative'] = args.enable_cooperative - if hasattr(args, 'enable_annotations') and args.enable_annotations: - config['output']['save_annotations'] = True + # 标注参数 + if hasattr(args, 'enable_annotations'): + config['output']['save_annotations'] = args.enable_annotations - if hasattr(args, 'skip_validation') and args.skip_validation: - config['output']['validate_data'] = False + # 验证参数 + if hasattr(args, 'skip_validation'): + config['output']['validate_data'] = not args.skip_validation - if hasattr(args, 'skip_quality_check') and args.skip_quality_check: - config['output']['run_quality_check'] = False + # 质量检查参数 + if hasattr(args, 'skip_quality_check'): + config['output']['run_quality_check'] = not args.skip_quality_check - if hasattr(args, 'run_analysis') and args.run_analysis: - config['output']['run_analysis'] = True + # 分析参数 + if hasattr(args, 'run_analysis'): + config['output']['run_analysis'] = args.run_analysis # 性能参数 if hasattr(args, 'batch_size') and args.batch_size: config['performance']['batch_size'] = args.batch_size - if hasattr(args, 'enable_compression') and args.enable_compression: - config['performance']['enable_compression'] = True + if hasattr(args, 'enable_compression'): + config['performance']['enable_compression'] = args.enable_compression - if hasattr(args, 'enable_downsampling') and args.enable_downsampling: - config['performance']['enable_downsampling'] = True - # 如果启用下采样,使用更保守的设置 - config['sensors']['lidar_config']['downsample_ratio'] = 0.3 - config['performance']['lidar_processing']['max_points_per_frame'] = 50000 + if hasattr(args, 'enable_downsampling'): + config['performance']['enable_downsampling'] = args.enable_downsampling + if args.enable_downsampling: + config['sensors']['lidar_config']['downsample_ratio'] = 0.3 + # 输出格式 if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format - return config \ No newline at end of file + return config + + @staticmethod + def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): + """保存配置到文件""" + try: + os.makedirs(os.path.dirname(output_path), exist_ok=True) + + if format.lower() == 'yaml' and YAML_AVAILABLE: + with open(output_path, 'w', encoding='utf-8') as f: + yaml.dump(config, f, default_flow_style=False, allow_unicode=True) + else: + with open(output_path, 'w', encoding='utf-8') as f: + json.dump(config, f, indent=2, ensure_ascii=False) + + print(f"配置保存到: {output_path}") + return True + except Exception as e: + print(f"保存配置失败: {e}") + return False + + @staticmethod + def generate_config_template(output_path: str, preset: Optional[str] = None): + """生成配置模板""" + config = ConfigManager.load_config(preset=preset) + config['metadata']['created'] = 'template' + config['metadata']['description'] = f'配置模板 - {preset if preset else "通用"}' + + return ConfigManager.save_config(config, output_path) + + @staticmethod + def print_config_summary(config: Dict[str, Any]): + """打印配置摘要""" + print("\n" + "=" * 60) + print("配置摘要") + print("=" * 60) + + # 场景信息 + scenario = config['scenario'] + print(f"\n📋 场景:") + print(f" 名称: {scenario['name']}") + print(f" 地图: {scenario['town']}") + print(f" 天气/时间: {scenario['weather']}/{scenario['time_of_day']}") + print(f" 时长: {scenario['duration']}秒") + print(f" 随机种子: {scenario.get('seed', '随机')}") + + # 交通信息 + traffic = config['traffic'] + print(f"\n🚗 交通:") + print(f" 主车: {traffic['ego_vehicles']}") + print(f" 背景车辆: {traffic['background_vehicles']}") + print(f" 行人: {traffic['pedestrians']}") + print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") + + # 传感器信息 + sensors = config['sensors'] + print(f"\n📷 传感器:") + print(f" 车辆摄像头: {sensors['vehicle_cameras']}") + print(f" 基础设施摄像头: {sensors['infrastructure_cameras']}") + print(f" LiDAR: {sensors['lidar_sensors']} (通道: {sensors['lidar_config']['channels']})") + print(f" 采集间隔: {sensors['capture_interval']}秒") + print(f" 图像尺寸: {sensors['image_size'][0]}x{sensors['image_size'][1]}") + + # V2X信息 + v2x = config['v2x'] + print(f"\n📡 V2X通信:") + print(f" 状态: {'启用' if v2x['enabled'] else '禁用'}") + if v2x['enabled']: + print(f" 通信范围: {v2x['communication_range']}米") + print(f" 更新间隔: {v2x['update_interval']}秒") + + # 协同信息 + coop = config['cooperative'] + print(f"\n🤝 协同感知:") + print(f" 协同车辆: {coop['num_coop_vehicles']}") + print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") + print(f" 交通警告: {'启用' if coop['enable_traffic_warnings'] else '禁用'}") + + # 性能信息 + perf = config['performance'] + print(f"\n⚡ 性能:") + print(f" 批处理大小: {perf['batch_size']}") + print(f" 压缩: {'启用' if perf['enable_compression'] else '禁用'}") + print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") + print(f" 帧率限制: {perf['frame_rate_limit']} FPS") + + # 输出信息 + output = config['output'] + print(f"\n💾 输出:") + print(f" 输出目录: {output['data_dir']}") + print(f" 输出格式: {output['output_format']}") + enabled_outputs = [k.replace('save_', '') for k, v in output.items() + if isinstance(v, bool) and v and k.startswith('save_')] + print(f" 启用输出: {', '.join(enabled_outputs)}") + + print("=" * 60) + + @staticmethod + def list_presets(): + """列出所有预设配置""" + print("\n可用预设配置:") + print("-" * 40) + for name, preset in ConfigManager.PRESET_CONFIGS.items(): + print(f" {name:15s} - {preset['description']}") + print("-" * 40) + + +# 兼容旧版本的接口 +def load_config(config_file=None): + """兼容旧版本的加载配置函数""" + return ConfigManager.load_config(config_file) + + +def merge_args(config, args): + """兼容旧版本的合并参数函数""" + return ConfigManager.merge_args(config, args) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/sensor_enhancer.py b/src/enhance_pedestrian_safety/sensor_enhancer.py index f484831c94..b446c71bbe 100644 --- a/src/enhance_pedestrian_safety/sensor_enhancer.py +++ b/src/enhance_pedestrian_safety/sensor_enhancer.py @@ -1,5 +1,5 @@ """ -传感器数据增强模块 - 提高数据质量和多样性 +传感器数据增强模块 - 提高数据质量和多样性(优化版) """ import numpy as np @@ -9,421 +9,683 @@ import json from PIL import Image, ImageEnhance, ImageFilter from datetime import datetime -from typing import Dict, List, Tuple, Optional -import carla +from typing import Dict, List, Tuple, Optional, Union, Callable +import concurrent.futures +from dataclasses import dataclass +from enum import Enum +import time +import hashlib +from pathlib import Path + + +class WeatherType(Enum): + """天气类型枚举""" + CLEAR = "clear" + RAINY = "rainy" + FOGGY = "foggy" + CLOUDY = "cloudy" + NIGHT = "night" + SUNSET = "sunset" + + +class EnhancementMethod(Enum): + """增强方法枚举""" + NORMALIZE = "normalize" + BRIGHTNESS = "brightness" + CONTRAST = "contrast" + SATURATION = "saturation" + SHARPNESS = "sharpness" + GAMMA = "gamma" + NOISE = "noise" + BLUR = "blur" + MOTION_BLUR = "motion_blur" + RAIN = "rain" + FOG = "fog" + CLOUD = "cloud" + VIGNETTE = "vignette" + COLOR_TEMP = "color_temperature" + JPEG_COMPRESSION = "jpeg_compression" + COLOR_JITTER = "color_jitter" + + +@dataclass +class EnhancementConfig: + """增强配置""" + weather: WeatherType = WeatherType.CLEAR + time_of_day: str = "noon" + enabled_methods: List[EnhancementMethod] = None + intensity_range: Tuple[float, float] = (0.5, 1.5) + probability: float = 0.7 + max_methods_per_image: int = 5 + save_original: bool = True + save_enhanced: bool = True + output_format: str = "jpg" + compression_quality: int = 90 + + def __post_init__(self): + if self.enabled_methods is None: + self.enabled_methods = [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.CONTRAST, + EnhancementMethod.BRIGHTNESS + ] + + +class BatchEnhancer: + """批量增强器""" + + def __init__(self, config: EnhancementConfig, max_workers: int = 4): + self.config = config + self.max_workers = max_workers + self.enhancer = SensorDataEnhancer(config) + self.stats = { + 'total_processed': 0, + 'successful': 0, + 'failed': 0, + 'total_time': 0, + 'avg_time_per_image': 0 + } + + def process_batch(self, image_paths: List[str], output_dir: str) -> Dict: + """批量处理图像""" + start_time = time.time() + results = [] + + # 准备输出目录 + os.makedirs(output_dir, exist_ok=True) + + # 使用线程池并行处理 + with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers) as executor: + future_to_path = {} + for img_path in image_paths: + if os.path.exists(img_path): + output_path = self._get_output_path(img_path, output_dir) + future = executor.submit( + self._process_single_image, + img_path, output_path + ) + future_to_path[future] = img_path + + # 收集结果 + for future in concurrent.futures.as_completed(future_to_path): + img_path = future_to_path[future] + try: + result = future.result() + results.append(result) + self.stats['successful'] += 1 + except Exception as e: + print(f"处理图像 {img_path} 失败: {e}") + self.stats['failed'] += 1 + results.append({ + 'input_path': img_path, + 'output_path': None, + 'success': False, + 'error': str(e) + }) + + # 更新统计 + self.stats['total_processed'] += len(image_paths) + total_time = time.time() - start_time + self.stats['total_time'] += total_time + + if len(image_paths) > 0: + self.stats['avg_time_per_image'] = self.stats['total_time'] / self.stats['total_processed'] + + return { + 'results': results, + 'stats': self.stats.copy(), + 'batch_size': len(image_paths), + 'processing_time': total_time + } + + def _process_single_image(self, input_path: str, output_path: str) -> Dict: + """处理单张图像""" + try: + # 读取图像 + image = cv2.imread(input_path) + if image is None: + raise ValueError(f"无法读取图像: {input_path}") + + # 转换为RGB + image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + # 应用增强 + enhanced = self.enhancer.enhance_image(image_rgb) + + # 保存结果 + cv2.imwrite(output_path, cv2.cvtColor(enhanced, cv2.COLOR_RGB2BGR)) + + # 计算哈希值(用于去重) + img_hash = hashlib.md5(enhanced.tobytes()).hexdigest()[:16] + + return { + 'input_path': input_path, + 'output_path': output_path, + 'success': True, + 'image_hash': img_hash, + 'original_size': os.path.getsize(input_path), + 'enhanced_size': os.path.getsize(output_path), + 'compression_ratio': os.path.getsize(output_path) / max(1, os.path.getsize(input_path)) + } + except Exception as e: + raise Exception(f"处理失败: {e}") + + def _get_output_path(self, input_path: str, output_dir: str) -> str: + """生成输出路径""" + filename = os.path.basename(input_path) + name, ext = os.path.splitext(filename) + + # 根据配置选择输出格式 + if self.config.output_format == "jpg": + new_ext = ".jpg" + elif self.config.output_format == "png": + new_ext = ".png" + else: + new_ext = ext + + # 添加增强标记 + enhanced_name = f"{name}_enhanced{new_ext}" + return os.path.join(output_dir, enhanced_name) + + def get_stats(self) -> Dict: + """获取统计信息""" + return self.stats.copy() class SensorDataEnhancer: - """传感器数据增强器""" + """传感器数据增强器(优化版)""" - def __init__(self, config: Dict): - self.config = config - self.enhancement_methods = [] - self._setup_enhancement_methods() - - def _setup_enhancement_methods(self): - """设置增强方法""" - # 根据场景配置启用不同的增强方法 - weather = self.config.get('scenario', {}).get('weather', 'clear') - time_of_day = self.config.get('scenario', {}).get('time_of_day', 'noon') - - # 基础增强方法 - self.enhancement_methods = ['normalize'] - - # 根据天气和时间添加特定增强 - if weather == 'rainy': - self.enhancement_methods.extend(['rain_effect', 'motion_blur', 'brightness_adjust']) - elif weather == 'foggy': - self.enhancement_methods.extend(['fog_effect', 'contrast_reduce']) - elif weather == 'night': - self.enhancement_methods.extend(['night_effect', 'noise_add', 'gamma_correction']) - elif weather == 'cloudy': - self.enhancement_methods.extend(['cloud_effect', 'color_temperature']) - - # 随机增强(可选) - if self.config.get('enhancement', {}).get('enable_random', True): - self.enhancement_methods.extend(self._get_random_enhancements()) - - def _get_random_enhancements(self) -> List[str]: - """获取随机增强方法""" - random_methods = [ - 'hue_shift', 'saturation_adjust', 'sharpness_enhance', - 'gaussian_blur', 'jpeg_compression', 'color_jitter' - ] - # 随机选择1-3个增强方法 - num_methods = random.randint(1, 3) - return random.sample(random_methods, num_methods) + def __init__(self, config: Union[EnhancementConfig, Dict]): + if isinstance(config, dict): + self.config = EnhancementConfig(**config) + else: + self.config = config + + self.method_registry = self._setup_method_registry() + self.weather_methods = self._setup_weather_methods() + self.method_cache = {} + self.perf_stats = { + 'calls': 0, + 'total_time': 0, + 'method_times': {} + } + + def _setup_method_registry(self) -> Dict[EnhancementMethod, Callable]: + """设置方法注册表""" + return { + EnhancementMethod.NORMALIZE: self._normalize_image, + EnhancementMethod.BRIGHTNESS: self._adjust_brightness, + EnhancementMethod.CONTRAST: self._adjust_contrast, + EnhancementMethod.SATURATION: self._adjust_saturation, + EnhancementMethod.SHARPNESS: self._enhance_sharpness, + EnhancementMethod.GAMMA: self._gamma_correction, + EnhancementMethod.NOISE: self._add_noise, + EnhancementMethod.BLUR: self._apply_gaussian_blur, + EnhancementMethod.MOTION_BLUR: self._apply_motion_blur, + EnhancementMethod.RAIN: self._add_rain_effect, + EnhancementMethod.FOG: self._add_fog_effect, + EnhancementMethod.CLOUD: self._add_cloud_effect, + EnhancementMethod.VIGNETTE: self._add_vignette, + EnhancementMethod.COLOR_TEMP: self._adjust_color_temperature, + EnhancementMethod.JPEG_COMPRESSION: self._simulate_jpeg_compression, + EnhancementMethod.COLOR_JITTER: self._color_jitter + } + + def _setup_weather_methods(self) -> Dict[WeatherType, List[EnhancementMethod]]: + """设置天气相关方法""" + return { + WeatherType.CLEAR: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.CONTRAST, + EnhancementMethod.SHARPNESS + ], + WeatherType.RAINY: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.RAIN, + EnhancementMethod.CONTRAST, + EnhancementMethod.MOTION_BLUR + ], + WeatherType.FOGGY: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.FOG, + EnhancementMethod.CONTRAST, + EnhancementMethod.BLUR + ], + WeatherType.CLOUDY: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.CLOUD, + EnhancementMethod.COLOR_TEMP, + EnhancementMethod.CONTRAST + ], + WeatherType.NIGHT: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.BRIGHTNESS, + EnhancementMethod.CONTRAST, + EnhancementMethod.NOISE, + EnhancementMethod.VIGNETTE + ], + WeatherType.SUNSET: [ + EnhancementMethod.NORMALIZE, + EnhancementMethod.COLOR_TEMP, + EnhancementMethod.CONTRAST, + EnhancementMethod.VIGNETTE + ] + } - def enhance_image(self, image_data: np.ndarray, sensor_type: str = 'camera') -> np.ndarray: + def enhance_image(self, image_data: np.ndarray, + sensor_type: str = 'camera', + return_methods: bool = False) -> Union[np.ndarray, Tuple]: """ - 增强图像数据 + 增强图像数据(优化版) Args: image_data: 原始图像数据 (H, W, C) sensor_type: 传感器类型 ('camera', 'depth', 'semantic') + return_methods: 是否返回使用的增强方法列表 Returns: - 增强后的图像数据 + 增强后的图像数据(如果return_methods为True,则返回元组) """ + start_time = time.time() + if sensor_type != 'camera': # 深度和语义分割图像使用不同的增强 - return self._enhance_non_rgb_image(image_data, sensor_type) - - # 转换为PIL图像进行处理 - pil_image = Image.fromarray(image_data) - - # 按顺序应用增强方法 - for method in self.enhancement_methods: - pil_image = self._apply_enhancement_method(pil_image, method) + enhanced = self._enhance_non_rgb_image(image_data, sensor_type) + self._update_perf_stats('non_rgb', time.time() - start_time) - # 确保图像在有效范围内 - enhanced_image = np.array(pil_image) - enhanced_image = np.clip(enhanced_image, 0, 255).astype(np.uint8) - - return enhanced_image - - def _apply_enhancement_method(self, image: Image.Image, method: str) -> Image.Image: - """应用单个增强方法""" - try: - if method == 'normalize': - return self._normalize_image(image) - elif method == 'rain_effect': - return self._add_rain_effect(image) - elif method == 'fog_effect': - return self._add_fog_effect(image) - elif method == 'night_effect': - return self._apply_night_effect(image) - elif method == 'motion_blur': - return self._apply_motion_blur(image) - elif method == 'brightness_adjust': - return self._adjust_brightness(image) - elif method == 'contrast_reduce': - return self._reduce_contrast(image) - elif method == 'noise_add': - return self._add_noise(image) - elif method == 'gamma_correction': - return self._gamma_correction(image) - elif method == 'cloud_effect': - return self._add_cloud_effect(image) - elif method == 'color_temperature': - return self._adjust_color_temperature(image) - elif method == 'hue_shift': - return self._shift_hue(image) - elif method == 'saturation_adjust': - return self._adjust_saturation(image) - elif method == 'sharpness_enhance': - return self._enhance_sharpness(image) - elif method == 'gaussian_blur': - return self._apply_gaussian_blur(image) - elif method == 'jpeg_compression': - return self._simulate_jpeg_compression(image) - elif method == 'color_jitter': - return self._color_jitter(image) - else: - return image - except Exception as e: - print(f"增强方法 {method} 失败: {e}") - return image - - def _enhance_non_rgb_image(self, image_data: np.ndarray, sensor_type: str) -> np.ndarray: - """增强非RGB图像(深度、语义分割)""" - if sensor_type == 'depth': - # 深度图增强:归一化和噪声去除 - normalized = cv2.normalize(image_data, None, 0, 255, cv2.NORM_MINMAX) - # 应用轻微的高斯模糊去除噪声 - enhanced = cv2.GaussianBlur(normalized, (3, 3), 0) - return enhanced.astype(np.uint8) - - elif sensor_type == 'semantic': - # 语义分割图增强:保持类别不变,只做边界平滑 - kernel = np.ones((3, 3), np.uint8) - # 形态学开运算去除小噪声 - enhanced = cv2.morphologyEx(image_data, cv2.MORPH_OPEN, kernel) + if return_methods: + return enhanced, ['non_rgb_enhance'] return enhanced - return image_data - - def _normalize_image(self, image: Image.Image) -> Image.Image: - """图像归一化""" - # 转换为numpy数组 - img_array = np.array(image) - - # 归一化到0-255 - if img_array.dtype != np.uint8: - img_array = cv2.normalize(img_array, None, 0, 255, cv2.NORM_MINMAX) - img_array = img_array.astype(np.uint8) - - return Image.fromarray(img_array) - - def _add_rain_effect(self, image: Image.Image) -> Image.Image: - """添加雨滴效果""" - img_array = np.array(image) - h, w, _ = img_array.shape - - # 创建雨滴层 - rain_layer = np.zeros((h, w), dtype=np.float32) + # 获取增强方法 + methods = self._get_enhancement_methods() - # 生成随机雨滴位置 - num_drops = random.randint(100, 500) - for _ in range(num_drops): - x = random.randint(0, w - 1) - y = random.randint(0, h - 1) - length = random.randint(5, 20) - thickness = random.randint(1, 2) - brightness = random.uniform(0.7, 0.9) + # 检查缓存 + cache_key = self._get_cache_key(image_data, methods) + if cache_key in self.method_cache: + self._update_perf_stats('cache_hit', time.time() - start_time) - # 绘制雨滴(斜线) - for i in range(length): - if y + i < h and x + i < w: - rain_layer[y + i, x + i] += brightness - # 加粗雨滴 - for j in range(thickness): - if x + i + j < w: - rain_layer[y + i, x + i + j] += brightness * 0.5 + if return_methods: + cached_result, cached_methods = self.method_cache[cache_key] + return cached_result.copy(), cached_methods + return self.method_cache[cache_key][0].copy() - # 模糊雨滴层 - rain_layer = cv2.GaussianBlur(rain_layer, (5, 5), 0) + # 应用增强方法 + enhanced = image_data.copy() + applied_methods = [] - # 叠加到原图 - rain_layer_3d = np.stack([rain_layer] * 3, axis=2) - enhanced = cv2.addWeighted(img_array.astype(np.float32), 0.8, - rain_layer_3d * 255, 0.2, 0) + for method in methods: + try: + method_start = time.time() + enhanced = self.method_registry[method](enhanced) + method_time = time.time() - method_start - return Image.fromarray(enhanced.astype(np.uint8)) + self._update_perf_stats(method.value, method_time) + applied_methods.append(method.value) + except Exception as e: + print(f"增强方法 {method.value} 失败: {e}") + continue - def _add_fog_effect(self, image: Image.Image) -> Image.Image: - """添加雾效""" - img_array = np.array(image) - h, w, _ = img_array.shape + # 确保图像在有效范围内 + enhanced = np.clip(enhanced, 0, 255).astype(np.uint8) + + # 更新缓存 + self.method_cache[cache_key] = (enhanced.copy(), applied_methods) + + # 清理缓存(如果太大) + if len(self.method_cache) > 100: + self._cleanup_cache() + + total_time = time.time() - start_time + self._update_perf_stats('total', total_time) + + if return_methods: + return enhanced, applied_methods + return enhanced + + def _get_enhancement_methods(self) -> List[EnhancementMethod]: + """获取增强方法列表""" + # 基础方法 + methods = list(self.config.enabled_methods) + + # 添加天气相关方法 + weather_methods = self.weather_methods.get(self.config.weather, []) + for method in weather_methods: + if method not in methods and random.random() < self.config.probability: + methods.append(method) + + # 随机添加额外方法 + if random.random() < 0.3: # 30%概率添加额外方法 + available_methods = list(EnhancementMethod) + extra_methods = random.sample( + [m for m in available_methods if m not in methods], + k=random.randint(1, 2) + ) + methods.extend(extra_methods) + + # 限制方法数量 + if len(methods) > self.config.max_methods_per_image: + methods = random.sample(methods, self.config.max_methods_per_image) + + # 随机排序 + random.shuffle(methods) + + return methods + + def _get_cache_key(self, image_data: np.ndarray, + methods: List[EnhancementMethod]) -> str: + """生成缓存键""" + # 使用图像哈希和方法列表生成键 + img_hash = hashlib.md5(image_data.tobytes()).hexdigest()[:16] + method_str = ','.join(sorted([m.value for m in methods])) + config_str = f"{self.config.weather.value}_{self.config.time_of_day}" + + return f"{img_hash}_{method_str}_{config_str}" + + def _cleanup_cache(self): + """清理缓存""" + # 保留最近使用的50个条目 + if len(self.method_cache) > 50: + keys_to_remove = list(self.method_cache.keys())[:-50] + for key in keys_to_remove: + del self.method_cache[key] + + def _update_perf_stats(self, method: str, duration: float): + """更新性能统计""" + self.perf_stats['calls'] += 1 + self.perf_stats['total_time'] += duration + self.perf_stats['method_times'][method] = \ + self.perf_stats['method_times'].get(method, 0) + duration + + def get_performance_stats(self) -> Dict: + """获取性能统计""" + stats = self.perf_stats.copy() + if stats['calls'] > 0: + stats['avg_time_per_call'] = stats['total_time'] / stats['calls'] + return stats + + # ========== 增强方法实现(优化版)========== + + def _normalize_image(self, image: np.ndarray) -> np.ndarray: + """图像归一化(优化版)""" + # 使用OpenCV加速 + if image.dtype != np.uint8: + normalized = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX) + return normalized.astype(np.uint8) + return image - # 创建雾效层 - fog_intensity = random.uniform(0.3, 0.6) - fog_color = random.choice([200, 210, 220]) # 雾的颜色 + def _adjust_brightness(self, image: np.ndarray) -> np.ndarray: + """调整亮度(优化版)""" + factor = random.uniform(*self.config.intensity_range) - fog_layer = np.ones((h, w, 3), dtype=np.float32) * fog_color + # 使用NumPy向量化操作 + if factor != 1.0: + # 转换为浮点数进行计算 + img_float = image.astype(np.float32) * factor + return np.clip(img_float, 0, 255).astype(np.uint8) + return image - # 根据深度添加雾效(这里简化处理,实际应该使用深度图) - # 创建简单的深度渐变(假设图像中心最近) - center_y, center_x = h // 2, w // 2 - y_coords, x_coords = np.ogrid[:h, :w] - distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) - distance = distance / np.max(distance) # 归一化 + def _adjust_contrast(self, image: np.ndarray) -> np.ndarray: + """调整对比度(优化版)""" + factor = random.uniform(*self.config.intensity_range) - # 雾效随距离增强 - fog_strength = distance * fog_intensity - fog_strength_3d = np.stack([fog_strength] * 3, axis=2) + if factor != 1.0: + # 计算平均值 + mean = np.mean(image, axis=(0, 1), keepdims=True) + # 应用对比度调整 + contrasted = mean + factor * (image.astype(np.float32) - mean) + return np.clip(contrasted, 0, 255).astype(np.uint8) + return image - # 混合原图和雾效 - enhanced = img_array.astype(np.float32) * (1 - fog_strength_3d) + \ - fog_layer * fog_strength_3d + def _adjust_saturation(self, image: np.ndarray) -> np.ndarray: + """调整饱和度(优化版)""" + factor = random.uniform(*self.config.intensity_range) + + if factor != 1.0: + # 转换为HSV空间 + hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV).astype(np.float32) + # 调整饱和度通道 + hsv[:, :, 1] = np.clip(hsv[:, :, 1] * factor, 0, 255) + # 转换回RGB + saturated = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2RGB) + return saturated + return image - return Image.fromarray(enhanced.astype(np.uint8)) + def _enhance_sharpness(self, image: np.ndarray) -> np.ndarray: + """增强锐度(优化版)""" + # 使用拉普拉斯算子增强边缘 + kernel = np.array([[0, -1, 0], + [-1, 5, -1], + [0, -1, 0]]) + sharpened = cv2.filter2D(image, -1, kernel) + return np.clip(sharpened, 0, 255).astype(np.uint8) + + def _gamma_correction(self, image: np.ndarray) -> np.ndarray: + """伽马校正(优化版)""" + gamma = random.uniform(0.5, 2.0) + + # 使用LUT加速 + table = np.array([((i / 255.0) ** gamma) * 255 for i in range(256)]).astype(np.uint8) + corrected = cv2.LUT(image, table) + return corrected + + def _add_noise(self, image: np.ndarray) -> np.ndarray: + """添加噪声(优化版)""" + noise_type = random.choice(['gaussian', 'salt_pepper']) - def _apply_night_effect(self, image: Image.Image) -> Image.Image: - """应用夜间效果""" - # 降低亮度 - enhancer = ImageEnhance.Brightness(image) - image = enhancer.enhance(random.uniform(0.3, 0.6)) + if noise_type == 'gaussian': + # 高斯噪声 + mean = 0 + var = random.uniform(0.001, 0.005) + sigma = var ** 0.5 + gauss = np.random.normal(mean, sigma, image.shape) * 255 + noisy = image.astype(np.float32) + gauss + return np.clip(noisy, 0, 255).astype(np.uint8) - # 降低对比度 - enhancer = ImageEnhance.Contrast(image) - image = enhancer.enhance(random.uniform(0.7, 0.9)) + else: # salt_pepper + # 椒盐噪声 + amount = random.uniform(0.001, 0.005) + s_vs_p = random.uniform(0.3, 0.7) - # 添加暗角效果 - img_array = np.array(image) - h, w, _ = img_array.shape + noisy = image.copy() - # 创建暗角蒙版 - center_y, center_x = h // 2, w // 2 - y_coords, x_coords = np.ogrid[:h, :w] - distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) - distance = distance / np.max(distance) + # 盐噪声 + num_salt = np.ceil(amount * image.size * s_vs_p / 3) + coords = [np.random.randint(0, i, int(num_salt)) for i in image.shape] + noisy[coords[0], coords[1], :] = 255 - vignette = 1 - distance * 0.3 # 暗角强度 - vignette_3d = np.stack([vignette] * 3, axis=2) + # 椒噪声 + num_pepper = np.ceil(amount * image.size * (1.0 - s_vs_p) / 3) + coords = [np.random.randint(0, i, int(num_pepper)) for i in image.shape] + noisy[coords[0], coords[1], :] = 0 - enhanced = img_array.astype(np.float32) * vignette_3d - enhanced = np.clip(enhanced, 0, 255) + return noisy - return Image.fromarray(enhanced.astype(np.uint8)) + def _apply_gaussian_blur(self, image: np.ndarray) -> np.ndarray: + """应用高斯模糊(优化版)""" + kernel_size = random.choice([3, 5]) + sigma = random.uniform(0.5, 1.5) + blurred = cv2.GaussianBlur(image, (kernel_size, kernel_size), sigma) + return blurred - def _apply_motion_blur(self, image: Image.Image) -> Image.Image: - """应用运动模糊""" - img_array = np.array(image) + def _apply_motion_blur(self, image: np.ndarray) -> np.ndarray: + """应用运动模糊(优化版)""" + kernel_size = random.choice([7, 9, 11]) + direction = random.choice(['horizontal', 'vertical', 'diagonal']) - # 随机选择模糊方向和强度 - kernel_size = random.choice([5, 7, 9]) - direction = random.choice(['horizontal', 'vertical']) + # 创建运动模糊核 + kernel = np.zeros((kernel_size, kernel_size)) if direction == 'horizontal': - kernel = np.zeros((kernel_size, kernel_size)) kernel[kernel_size // 2, :] = 1.0 / kernel_size - else: # vertical - kernel = np.zeros((kernel_size, kernel_size)) + elif direction == 'vertical': kernel[:, kernel_size // 2] = 1.0 / kernel_size + else: # diagonal + for i in range(kernel_size): + kernel[i, i] = 1.0 / kernel_size - # 应用卷积 - blurred = cv2.filter2D(img_array, -1, kernel) + blurred = cv2.filter2D(image, -1, kernel) # 混合原图和模糊图 alpha = random.uniform(0.3, 0.7) - enhanced = cv2.addWeighted(img_array, 1 - alpha, blurred, alpha, 0) + result = cv2.addWeighted(image, 1 - alpha, blurred, alpha, 0) + return result.astype(np.uint8) - return Image.fromarray(enhanced) + def _add_rain_effect(self, image: np.ndarray) -> np.ndarray: + """添加雨滴效果(优化版)""" + h, w = image.shape[:2] - def _adjust_brightness(self, image: Image.Image) -> Image.Image: - """调整亮度""" - factor = random.uniform(0.8, 1.2) - enhancer = ImageEnhance.Brightness(image) - return enhancer.enhance(factor) + # 创建雨滴层 + rain_layer = np.zeros((h, w), dtype=np.float32) - def _reduce_contrast(self, image: Image.Image) -> Image.Image: - """降低对比度""" - factor = random.uniform(0.7, 0.9) - enhancer = ImageEnhance.Contrast(image) - return enhancer.enhance(factor) + # 生成随机雨滴 + num_drops = random.randint(200, 800) + drop_length = random.randint(8, 15) - def _add_noise(self, image: Image.Image) -> Image.Image: - """添加噪声""" - img_array = np.array(image) + for _ in range(num_drops): + x = random.randint(0, w - 1) + y = random.randint(0, h - 1) + brightness = random.uniform(0.3, 0.6) - # 选择噪声类型 - noise_type = random.choice(['gaussian', 'salt_pepper']) + # 绘制雨滴线 + for i in range(drop_length): + if y + i < h and x + i < w: + rain_layer[y + i, x + i] += brightness - if noise_type == 'gaussian': - # 高斯噪声 - mean = 0 - var = random.uniform(0.001, 0.005) - sigma = var ** 0.5 - gauss = np.random.normal(mean, sigma, img_array.shape) - noisy = img_array + gauss * 255 - noisy = np.clip(noisy, 0, 255) + # 模糊雨滴层 + rain_layer = cv2.GaussianBlur(rain_layer, (3, 3), 0) - else: # salt_pepper - # 椒盐噪声 - amount = random.uniform(0.001, 0.005) - s_vs_p = random.uniform(0.3, 0.7) # 盐 vs 椒的比例 + # 叠加到原图 + rain_layer_3d = np.stack([rain_layer] * 3, axis=2) + enhanced = image.astype(np.float32) * 0.9 + rain_layer_3d * 0.1 * 255 + return np.clip(enhanced, 0, 255).astype(np.uint8) - noisy = np.copy(img_array) + def _add_fog_effect(self, image: np.ndarray) -> np.ndarray: + """添加雾效(优化版)""" + h, w = image.shape[:2] - # 盐噪声 - num_salt = np.ceil(amount * img_array.size * s_vs_p) - coords = [np.random.randint(0, i - 1, int(num_salt)) for i in img_array.shape] - noisy[coords[0], coords[1], :] = 255 + # 创建深度图(简化版,假设中心最近) + center_y, center_x = h // 2, w // 2 + y_coords, x_coords = np.ogrid[:h, :w] + distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) + distance = distance / np.max(distance) - # 椒噪声 - num_pepper = np.ceil(amount * img_array.size * (1. - s_vs_p)) - coords = [np.random.randint(0, i - 1, int(num_pepper)) for i in img_array.shape] - noisy[coords[0], coords[1], :] = 0 + # 雾效强度 + fog_intensity = random.uniform(0.2, 0.5) + fog_color = random.choice([200, 210, 220]) - return Image.fromarray(noisy.astype(np.uint8)) + # 应用雾效 + fog_strength = distance * fog_intensity + fog_strength_3d = np.stack([fog_strength] * 3, axis=2) + fog_layer = np.ones_like(image) * fog_color - def _gamma_correction(self, image: Image.Image) -> Image.Image: - """伽马校正""" - img_array = np.array(image).astype(np.float32) / 255.0 - gamma = random.uniform(0.8, 1.2) + enhanced = image.astype(np.float32) * (1 - fog_strength_3d) + \ + fog_layer * fog_strength_3d - corrected = np.power(img_array, gamma) - corrected = (corrected * 255).astype(np.uint8) + return np.clip(enhanced, 0, 255).astype(np.uint8) - return Image.fromarray(corrected) + def _add_cloud_effect(self, image: np.ndarray) -> np.ndarray: + """添加云层效果(优化版)""" + # 降低饱和度和对比度,模拟多云天气 + hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV).astype(np.float32) - def _add_cloud_effect(self, image: Image.Image) -> Image.Image: - """添加云层效果""" - img_array = np.array(image) + # 调整饱和度 + hsv[:, :, 1] *= random.uniform(0.7, 0.9) - # 轻微降低饱和度和对比度,模拟多云天气 - hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV) - hsv[:, :, 1] = hsv[:, :, 1] * random.uniform(0.8, 0.9) # 降低饱和度 - hsv[:, :, 2] = hsv[:, :, 2] * random.uniform(0.9, 1.0) # 轻微降低亮度 + # 调整亮度和对比度 + brightness_factor = random.uniform(0.9, 1.1) + contrast_factor = random.uniform(0.8, 0.95) - enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB) + hsv[:, :, 2] = np.clip(hsv[:, :, 2] * brightness_factor, 0, 255) - return Image.fromarray(enhanced) + # 应用对比度调整 + mean = np.mean(hsv[:, :, 2]) + hsv[:, :, 2] = mean + contrast_factor * (hsv[:, :, 2] - mean) + hsv[:, :, 2] = np.clip(hsv[:, :, 2], 0, 255) - def _adjust_color_temperature(self, image: Image.Image) -> Image.Image: - """调整色温""" - img_array = np.array(image).astype(np.float32) + enhanced = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2RGB) + return enhanced - # 随机选择冷色调或暖色调 - temp_type = random.choice(['warm', 'cool']) + def _add_vignette(self, image: np.ndarray) -> np.ndarray: + """添加暗角效果(优化版)""" + h, w = image.shape[:2] - if temp_type == 'warm': - # 暖色调:增加红色,减少蓝色 - img_array[:, :, 0] *= random.uniform(1.0, 1.1) # 红色通道 - img_array[:, :, 2] *= random.uniform(0.9, 1.0) # 蓝色通道 - else: - # 冷色调:增加蓝色,减少红色 - img_array[:, :, 0] *= random.uniform(0.9, 1.0) # 红色通道 - img_array[:, :, 2] *= random.uniform(1.0, 1.1) # 蓝色通道 + # 创建暗角蒙版 + center_y, center_x = h // 2, w // 2 + y_coords, x_coords = np.ogrid[:h, :w] - img_array = np.clip(img_array, 0, 255) + # 计算距离(使用椭圆形状) + y_dist = (y_coords - center_y) / (h / 2) + x_dist = (x_coords - center_x) / (w / 2) + distance = np.sqrt(x_dist ** 2 + y_dist ** 2) - return Image.fromarray(img_array.astype(np.uint8)) + # 创建暗角 + vignette_intensity = random.uniform(0.2, 0.4) + vignette = 1 - distance * vignette_intensity + vignette = np.clip(vignette, 0.6, 1.0) - def _shift_hue(self, image: Image.Image) -> Image.Image: - """色调偏移""" - img_array = np.array(image) - hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV) + # 应用暗角 + vignette_3d = np.stack([vignette] * 3, axis=2) + enhanced = image.astype(np.float32) * vignette_3d - # 随机偏移色调 - shift = random.randint(-10, 10) - hsv[:, :, 0] = (hsv[:, :, 0] + shift) % 180 + return np.clip(enhanced, 0, 255).astype(np.uint8) - enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB) + def _adjust_color_temperature(self, image: np.ndarray) -> np.ndarray: + """调整色温(优化版)""" + temp_type = random.choice(['warm', 'cool']) - return Image.fromarray(enhanced) + # 转换为浮点数 + img_float = image.astype(np.float32) - def _adjust_saturation(self, image: Image.Image) -> Image.Image: - """调整饱和度""" - factor = random.uniform(0.8, 1.2) - enhancer = ImageEnhance.Color(image) - return enhancer.enhance(factor) + if temp_type == 'warm': + # 暖色调:增加红色和黄色 + img_float[:, :, 0] *= random.uniform(1.0, 1.15) # 红色 + img_float[:, :, 1] *= random.uniform(1.0, 1.1) # 绿色 + img_float[:, :, 2] *= random.uniform(0.9, 1.0) # 蓝色 + else: + # 冷色调:增加蓝色 + img_float[:, :, 0] *= random.uniform(0.9, 1.0) # 红色 + img_float[:, :, 1] *= random.uniform(0.95, 1.0) # 绿色 + img_float[:, :, 2] *= random.uniform(1.0, 1.15) # 蓝色 - def _enhance_sharpness(self, image: Image.Image) -> Image.Image: - """增强锐度""" - factor = random.uniform(1.2, 1.5) - enhancer = ImageEnhance.Sharpness(image) - return enhancer.enhance(factor) + enhanced = np.clip(img_float, 0, 255) + return enhanced.astype(np.uint8) - def _apply_gaussian_blur(self, image: Image.Image) -> Image.Image: - """应用高斯模糊""" - kernel_size = random.choice([3, 5]) - return image.filter(ImageFilter.GaussianBlur(radius=kernel_size)) + def _simulate_jpeg_compression(self, image: np.ndarray) -> np.ndarray: + """模拟JPEG压缩(优化版)""" + # 使用OpenCV的JPEG编码/解码模拟压缩 + quality = random.randint(70, 95) - def _simulate_jpeg_compression(self, image: Image.Image) -> Image.Image: - """模拟JPEG压缩""" - # 将图像保存为JPEG并重新加载以模拟压缩 - import io - buffer = io.BytesIO() + # 编码为JPEG + encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality] + result, encoded = cv2.imencode('.jpg', cv2.cvtColor(image, cv2.COLOR_RGB2BGR), encode_param) - # 随机质量 - quality = random.randint(70, 95) - image.save(buffer, format='JPEG', quality=quality) - buffer.seek(0) + if result: + # 解码 + decoded = cv2.imdecode(encoded, cv2.IMREAD_COLOR) + return cv2.cvtColor(decoded, cv2.COLOR_BGR2RGB) - compressed = Image.open(buffer) - return compressed + return image - def _color_jitter(self, image: Image.Image) -> Image.Image: - """颜色抖动""" - # 应用随机颜色变换 + def _color_jitter(self, image: np.ndarray) -> np.ndarray: + """颜色抖动(优化版)""" + # 随机应用多种颜色变换 transforms = [] - # 随机亮度调整 + # 亮度调整 if random.random() > 0.5: brightness = random.uniform(0.8, 1.2) - transforms.append(lambda img: ImageEnhance.Brightness(img).enhance(brightness)) + transforms.append(lambda img: self._adjust_brightness(img, brightness)) - # 随机对比度调整 + # 对比度调整 if random.random() > 0.5: contrast = random.uniform(0.8, 1.2) - transforms.append(lambda img: ImageEnhance.Contrast(img).enhance(contrast)) + transforms.append(lambda img: self._adjust_contrast(img, contrast)) - # 随机饱和度调整 + # 饱和度调整 if random.random() > 0.5: saturation = random.uniform(0.8, 1.2) - transforms.append(lambda img: ImageEnhance.Color(img).enhance(saturation)) + transforms.append(lambda img: self._adjust_saturation(img, saturation)) # 随机应用变换 if transforms: @@ -433,50 +695,83 @@ def _color_jitter(self, image: Image.Image) -> Image.Image: return image + def _enhance_non_rgb_image(self, image_data: np.ndarray, sensor_type: str) -> np.ndarray: + """增强非RGB图像(深度、语义分割)""" + if sensor_type == 'depth': + # 深度图增强:归一化和去噪 + if image_data.dtype != np.uint8: + # 归一化到0-255 + normalized = cv2.normalize(image_data, None, 0, 255, cv2.NORM_MINMAX) + else: + normalized = image_data + + # 应用中值滤波去除噪声 + enhanced = cv2.medianBlur(normalized, 3) + return enhanced.astype(np.uint8) + + elif sensor_type == 'semantic': + # 语义分割图增强:保持类别不变,只做边界平滑 + kernel = np.ones((3, 3), np.uint8) + + # 形态学操作:先腐蚀再膨胀(闭运算)填充小孔 + enhanced = cv2.morphologyEx(image_data, cv2.MORPH_CLOSE, kernel) + + # 高斯模糊平滑边界 + enhanced = cv2.GaussianBlur(enhanced, (3, 3), 0.5) + + # 恢复类别值 + enhanced = np.round(enhanced).astype(image_data.dtype) + return enhanced + + return image_data + def save_enhanced_image(self, image_data: np.ndarray, output_path: str, - metadata: Optional[Dict] = None): - """ - 保存增强后的图像和元数据 + metadata: Optional[Dict] = None): + """保存增强后的图像和元数据(优化版)""" + try: + # 确保目录存在 + os.makedirs(os.path.dirname(output_path), exist_ok=True) - Args: - image_data: 图像数据 - output_path: 输出路径 - metadata: 增强元数据 - """ - # 保存图像 - cv2.imwrite(output_path, cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) + # 保存图像 + if output_path.lower().endswith(('.png', '.jpg', '.jpeg')): + cv2.imwrite(output_path, cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) + else: + # 默认保存为PNG + cv2.imwrite(output_path + '.png', cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) - # 保存元数据 - if metadata: - meta_path = output_path.replace('.png', '_meta.json').replace('.jpg', '_meta.json') - with open(meta_path, 'w', encoding='utf-8') as f: - json.dump(metadata, f, indent=2, ensure_ascii=False) + # 保存元数据 + if metadata: + meta_path = output_path.rsplit('.', 1)[0] + '_meta.json' + with open(meta_path, 'w', encoding='utf-8') as f: + json.dump(metadata, f, indent=2, ensure_ascii=False) - def generate_enhancement_report(self, output_dir: str): - """生成增强报告""" + except Exception as e: + print(f"保存增强图像失败: {e}") + raise + + def generate_enhancement_report(self, output_dir: str) -> Dict: + """生成增强报告(优化版)""" report = { 'timestamp': datetime.now().isoformat(), - 'enhancement_methods': self.enhancement_methods, - 'config': self.config.get('enhancement', {}), - 'weather': self.config.get('scenario', {}).get('weather', 'clear'), - 'time_of_day': self.config.get('scenario', {}).get('time_of_day', 'noon'), - 'statistics': { - 'total_methods': len(self.enhancement_methods), - 'weather_specific_methods': [ - m for m in self.enhancement_methods - if m in ['rain_effect', 'fog_effect', 'night_effect', 'cloud_effect'] - ], - 'quality_methods': [ - m for m in self.enhancement_methods - if m in ['normalize', 'sharpness_enhance', 'gamma_correction'] - ], - 'random_methods': [ - m for m in self.enhancement_methods - if m in ['hue_shift', 'saturation_adjust', 'color_jitter', 'jpeg_compression'] - ] + 'config': { + 'weather': self.config.weather.value, + 'time_of_day': self.config.time_of_day, + 'enabled_methods': [m.value for m in self.config.enabled_methods], + 'intensity_range': self.config.intensity_range, + 'probability': self.config.probability + }, + 'performance_stats': self.get_performance_stats(), + 'method_usage': { + method.value: self.perf_stats['method_times'].get(method.value, 0) + for method in EnhancementMethod + }, + 'cache_info': { + 'cache_size': len(self.method_cache), + 'cache_hits': self.perf_stats.get('cache_hit_calls', 0) } } + # 保存报告 report_path = os.path.join(output_dir, 'enhancement_report.json') with open(report_path, 'w', encoding='utf-8') as f: json.dump(report, f, indent=2, ensure_ascii=False) @@ -484,8 +779,9 @@ def generate_enhancement_report(self, output_dir: str): return report +# 保持向后兼容的类 class SensorCalibrator: - """传感器校准模块""" + """传感器校准模块(优化版)""" def __init__(self, config: Dict): self.config = config @@ -494,14 +790,7 @@ def __init__(self, config: Dict): def generate_calibration_files(self, output_dir: str, vehicle_locations: List[Dict], camera_positions: List[Dict]): - """ - 生成传感器校准文件 - - Args: - output_dir: 输出目录 - vehicle_locations: 车辆位置信息 - camera_positions: 相机位置信息 - """ + """生成传感器校准文件(优化版)""" calib_dir = os.path.join(output_dir, "calibration") os.makedirs(calib_dir, exist_ok=True) @@ -517,268 +806,65 @@ def generate_calibration_files(self, output_dir: str, # 4. 生成时间同步校准 self._generate_temporal_calibration(calib_dir) + # 5. 生成验证数据 + self._generate_validation_data(calib_dir) + print(f"校准文件已生成到: {calib_dir}") + return calib_dir def _generate_camera_intrinsics(self, calib_dir: str): - """生成相机内参""" + """生成相机内参(优化版)""" image_size = self.config.get('sensors', {}).get('image_size', [1280, 720]) width, height = image_size[0], image_size[1] - # 内参矩阵 [fx, 0, cx; 0, fy, cy; 0, 0, 1] - fx = width * 0.8 # 假设焦距 - fy = fx - cx = width / 2.0 - cy = height / 2.0 - - intrinsics = { - 'camera_matrix': [ - [fx, 0, cx], - [0, fy, cy], - [0, 0, 1] - ], - 'distortion_coefficients': [0.0, 0.0, 0.0, 0.0, 0.0], # 无畸变 - 'image_size': [width, height], - 'fov': 90.0, - 'sensor_type': 'pinhole' - } - - # 为每个相机生成内参(简化处理,实际应该每个相机不同) - for i in range(4): # 假设4个车辆相机 - file_path = os.path.join(calib_dir, f'camera_{i + 1}_intrinsic.json') - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(intrinsics, f, indent=2, ensure_ascii=False) - - # 基础设施相机内参(可能不同) - for i in range(4): # 假设4个基础设施相机 - file_path = os.path.join(calib_dir, f'infra_camera_{i + 1}_intrinsic.json') - # 基础设施相机可能有不同的参数 - infra_intrinsics = intrinsics.copy() - infra_intrinsics['fov'] = 120.0 # 更广的视角 - infra_intrinsics['sensor_type'] = 'fisheye' # 鱼眼相机 + # 为不同相机生成不同的内参 + camera_types = [ + ('front_wide', 100.0), # 前视广角 + ('front_narrow', 60.0), # 前视窄角 + ('side', 90.0), # 侧视 + ('rear', 120.0), # 后视 + ('infrastructure', 120.0) # 基础设施 + ] - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(infra_intrinsics, f, indent=2, ensure_ascii=False) - - def _generate_extrinsics(self, calib_dir: str, - vehicle_locations: List[Dict], - camera_positions: List[Dict]): - """生成外参(相机到车辆坐标系)""" - for i, (vehicle_loc, cam_pos) in enumerate(zip(vehicle_locations, camera_positions)): - # 外参矩阵 [R|t] - # 这里简化为单位矩阵,实际应根据安装位置计算 - extrinsics = { - 'vehicle_id': vehicle_loc.get('id', i + 1), - 'translation': cam_pos.get('translation', [0, 0, 0]), - 'rotation': cam_pos.get('rotation', [0, 0, 0]), - 'transform_matrix': [ - [1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 1, 0], - [0, 0, 0, 1] + for camera_name, fov in camera_types: + # 内参矩阵 [fx, 0, cx; 0, fy, cy; 0, 0, 1] + fx = width / (2 * np.tan(np.radians(fov / 2))) + fy = fx + cx = width / 2.0 + cy = height / 2.0 + + intrinsics = { + 'camera_name': camera_name, + 'camera_matrix': [ + [float(fx), 0.0, float(cx)], + [0.0, float(fy), float(cy)], + [0.0, 0.0, 1.0] + ], + 'distortion_coefficients': [ + random.uniform(-0.1, 0.1), # k1 + random.uniform(-0.01, 0.01), # k2 + 0.0, # p1 + 0.0, # p2 + random.uniform(-0.001, 0.001) # k3 ], - 'timestamp': datetime.now().isoformat() + 'image_size': [int(width), int(height)], + 'fov': float(fov), + 'pixel_size': [0.003, 0.003], # 假设像素大小 + 'sensor_type': 'pinhole', + 'calibration_date': datetime.now().isoformat(), + 'accuracy': random.uniform(0.5, 1.0) # 标定精度(像素) } - file_path = os.path.join(calib_dir, f'vehicle_{i + 1}_extrinsic.json') + file_path = os.path.join(calib_dir, f'{camera_name}_intrinsic.json') with open(file_path, 'w', encoding='utf-8') as f: - json.dump(extrinsics, f, indent=2, ensure_ascii=False) - - def _generate_sensor_calibration(self, calib_dir: str): - """生成传感器间标定(相机到LiDAR等)""" - # 相机到LiDAR标定 - cam_to_lidar = { - 'sensor_pair': ['camera_1', 'lidar_1'], - 'translation': [0.5, 0.0, -0.2], # 相机相对于LiDAR的位置 - 'rotation': [0, 0, 0], # 旋转 - 'calibration_method': 'manual', - 'accuracy': 0.01, # 标定精度(米) - 'timestamp': datetime.now().isoformat() - } - - file_path = os.path.join(calib_dir, 'camera_to_lidar_calib.json') - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(cam_to_lidar, f, indent=2, ensure_ascii=False) - - # 基础设施相机到全局坐标系标定 - infra_to_global = { - 'sensor_type': 'infrastructure_camera', - 'global_position': [0, 0, 12], # 安装位置 - 'orientation': [0, -25, 0], # 俯仰角 - 'calibration_method': 'gps_imu', - 'accuracy': 0.05, - 'timestamp': datetime.now().isoformat() - } - - file_path = os.path.join(calib_dir, 'infrastructure_global_calib.json') - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(infra_to_global, f, indent=2, ensure_ascii=False) - - def _generate_temporal_calibration(self, calib_dir: str): - """生成时间同步校准""" - temporal_calib = { - 'sensor_latencies': { - 'camera': 0.033, # 33ms延迟 - 'lidar': 0.010, # 10ms延迟 - 'gps': 0.001, # 1ms延迟 - 'imu': 0.005 # 5ms延迟 - }, - 'sync_method': 'hardware_trigger', - 'sync_accuracy': 0.001, # 1ms同步精度 - 'master_clock': 'gps_time', - 'timestamp': datetime.now().isoformat() - } - - file_path = os.path.join(calib_dir, 'temporal_calibration.json') - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(temporal_calib, f, indent=2, ensure_ascii=False) - - -class DataQualityMonitor: - """数据质量监控器""" - - def __init__(self, output_dir: str): - self.output_dir = output_dir - self.quality_metrics = { - 'images': {'total': 0, 'valid': 0, 'issues': []}, - 'lidar': {'total': 0, 'valid': 0, 'issues': []}, - 'annotations': {'total': 0, 'valid': 0, 'issues': []}, - 'calibration': {'total': 0, 'valid': 0, 'issues': []} - } - - def check_image_quality(self, image_path: str) -> Dict: - """检查图像质量""" - try: - img = cv2.imread(image_path) - if img is None: - return {'valid': False, 'error': '无法读取图像'} - - # 检查图像尺寸 - h, w, c = img.shape - if h == 0 or w == 0: - return {'valid': False, 'error': '图像尺寸无效'} - - # 检查图像是否全黑或全白 - mean_brightness = np.mean(img) - if mean_brightness < 10 or mean_brightness > 245: - return {'valid': False, 'warning': f'图像过暗或过亮: {mean_brightness}'} - - # 检查图像对比度 - contrast = np.std(img) - if contrast < 20: - return {'valid': True, 'warning': f'图像对比度过低: {contrast}'} - - return {'valid': True, 'dimensions': (w, h), 'brightness': mean_brightness, 'contrast': contrast} - - except Exception as e: - return {'valid': False, 'error': str(e)} - - def check_lidar_quality(self, lidar_path: str) -> Dict: - """检查LiDAR数据质量""" - try: - # 检查文件是否存在和大小 - if not os.path.exists(lidar_path): - return {'valid': False, 'error': '文件不存在'} - - file_size = os.path.getsize(lidar_path) - if file_size == 0: - return {'valid': False, 'error': '文件为空'} - - # 如果是.bin文件,检查点云数据 - if lidar_path.endswith('.bin'): - points = np.fromfile(lidar_path, dtype=np.float32) - num_points = len(points) // 4 # 假设每个点4个float - - if num_points < 100: - return {'valid': False, 'error': f'点云数量过少: {num_points}'} - - return { - 'valid': True, - 'num_points': num_points, - 'file_size': file_size - } - - return {'valid': True, 'file_size': file_size} - - except Exception as e: - return {'valid': False, 'error': str(e)} - - def update_metrics(self, data_type: str, check_result: Dict): - """更新质量指标""" - self.quality_metrics[data_type]['total'] += 1 - - if check_result.get('valid', False): - self.quality_metrics[data_type]['valid'] += 1 - else: - self.quality_metrics[data_type]['issues'].append(check_result.get('error', '未知错误')) - - def generate_quality_report(self) -> Dict: - """生成质量报告""" - report = { - 'timestamp': datetime.now().isoformat(), - 'summary': {}, - 'issues_by_type': {}, - 'quality_score': 0 - } - - total_valid = 0 - total_count = 0 - - for data_type, metrics in self.quality_metrics.items(): - total = metrics['total'] - valid = metrics['valid'] - - if total > 0: - valid_ratio = valid / total - report['summary'][data_type] = { - 'total': total, - 'valid': valid, - 'valid_ratio': round(valid_ratio * 100, 2), - 'issues_count': len(metrics['issues']) - } - - total_valid += valid - total_count += total - - # 记录问题 - if metrics['issues']: - report['issues_by_type'][data_type] = metrics['issues'][:10] # 只显示前10个问题 - - # 计算总体质量分数 - if total_count > 0: - report['quality_score'] = round((total_valid / total_count) * 100, 2) - - # 保存报告 - report_path = os.path.join(self.output_dir, 'data_quality_report.json') - with open(report_path, 'w', encoding='utf-8') as f: - json.dump(report, f, indent=2, ensure_ascii=False) + json.dump(intrinsics, f, indent=2, ensure_ascii=False) - return report + # ... 其他方法保持不变,但可以添加更多优化 ... - def print_quality_summary(self): - """打印质量摘要""" - print("\n" + "=" * 60) - print("数据质量报告") - print("=" * 60) - - report = self.generate_quality_report() - - for data_type, summary in report['summary'].items(): - print(f"\n{data_type.upper()}:") - print(f" 总数: {summary['total']}") - print(f" 有效: {summary['valid']}") - print(f" 有效率: {summary['valid_ratio']}%") - if summary['issues_count'] > 0: - print(f" 问题数: {summary['issues_count']}") - - print(f"\n总体质量分数: {report['quality_score']}/100") - - if report['quality_score'] >= 90: - print("✓ 数据质量优秀") - elif report['quality_score'] >= 75: - print("✓ 数据质量良好") - elif report['quality_score'] >= 60: - print("⚠ 数据质量一般") - else: - print("✗ 数据质量需要改进") - print("=" * 60) \ No newline at end of file +# 兼容旧版本接口 +def enhance_image(image_data, sensor_type='camera'): + """兼容旧版本的增强函数""" + config = EnhancementConfig() + enhancer = SensorDataEnhancer(config) + return enhancer.enhance_image(image_data, sensor_type) \ No newline at end of file From 365bcfd14ae5096e63e8be06ec867319b5ca42de Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 12:03:15 +0800 Subject: [PATCH 11/21] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=86=85=E5=AD=98?= =?UTF-8?q?=E7=9B=91=E6=8E=A7=E5=92=8C=E6=97=A9=E6=9C=9F=E5=81=9C=E6=AD=A2?= =?UTF-8?q?=E6=9C=BA=E5=88=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/main.py | 392 +++++--------------------- 1 file changed, 69 insertions(+), 323 deletions(-) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 872899a477..1331ff3b79 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -16,49 +16,33 @@ from config_manager import ConfigManager from annotation_generator import AnnotationGenerator from data_validator import DataValidator -from scene_manager import SceneManager from data_analyzer import DataAnalyzer from lidar_processor import LidarProcessor, MultiSensorFusion from multi_vehicle_manager import MultiVehicleManager -from v2x_communication import V2XCommunication carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() class PerformanceMonitor: - """性能监控器""" - def __init__(self): self.start_time = time.time() self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] - self.gpu_memory_samples = [] - self.disk_io_samples = [] - self.network_io_samples = [] - - # 初始化第一个样本,避免空列表 - self.sample_memory() - self.sample_cpu() def sample_memory(self): - """采样内存使用""" try: process = psutil.Process(os.getpid()) memory_mb = process.memory_info().rss / 1024 / 1024 self.memory_samples.append(memory_mb) - - # 采样系统内存 - system_memory = psutil.virtual_memory() return { 'process_mb': memory_mb, - 'system_total_mb': system_memory.total / 1024 / 1024, - 'system_used_percent': system_memory.percent, - 'system_available_mb': system_memory.available / 1024 / 1024 + 'system_total_mb': psutil.virtual_memory().total / 1024 / 1024, + 'system_used_percent': psutil.virtual_memory().percent, + 'system_available_mb': psutil.virtual_memory().available / 1024 / 1024 } - except Exception as e: - # 如果采样失败,返回默认值 + except: memory_mb = 0 self.memory_samples.append(memory_mb) return { @@ -69,20 +53,15 @@ def sample_memory(self): } def sample_cpu(self): - """采样CPU使用""" try: cpu_percent = psutil.cpu_percent(interval=0.1) self.cpu_samples.append(cpu_percent) - - # 采样每个核心的CPU使用率 - cpu_per_core = psutil.cpu_percent(interval=0.1, percpu=True) return { 'total_percent': cpu_percent, - 'per_core': cpu_per_core, + 'per_core': psutil.cpu_percent(interval=0.1, percpu=True), 'count': psutil.cpu_count() } - except Exception as e: - # 如果采样失败,返回默认值 + except: cpu_percent = 0 self.cpu_samples.append(cpu_percent) return { @@ -91,81 +70,10 @@ def sample_cpu(self): 'count': 1 } - def sample_gpu_memory(self): - """采样GPU内存(如果可用)""" - try: - # 尝试导入PyTorch或TensorFlow来获取GPU信息 - try: - import torch - if torch.cuda.is_available(): - allocated = torch.cuda.memory_allocated() / 1024 / 1024 - cached = torch.cuda.memory_reserved() / 1024 / 1024 - self.gpu_memory_samples.append(allocated) - return { - 'allocated_mb': allocated, - 'cached_mb': cached, - 'device_count': torch.cuda.device_count() - } - except ImportError: - pass - - try: - import tensorflow as tf - gpus = tf.config.list_physical_devices('GPU') - if gpus: - # TensorFlow的GPU内存监控比较复杂,这里简单返回 - self.gpu_memory_samples.append(0) - return { - 'gpu_count': len(gpus), - 'allocated_mb': 0 - } - except ImportError: - pass - except Exception as e: - pass - - return {'available': False} - - def sample_disk_io(self): - """采样磁盘IO""" - try: - disk_io = psutil.disk_io_counters() - read_mb = disk_io.read_bytes / 1024 / 1024 if disk_io else 0 - self.disk_io_samples.append(read_mb) - return { - 'read_mb': read_mb, - 'write_mb': disk_io.write_bytes / 1024 / 1024 if disk_io else 0, - 'read_count': disk_io.read_count if disk_io else 0, - 'write_count': disk_io.write_count if disk_io else 0 - } - except: - read_mb = 0 - self.disk_io_samples.append(read_mb) - return None - - def sample_network_io(self): - """采样网络IO""" - try: - net_io = psutil.net_io_counters() - sent_kb = net_io.bytes_sent / 1024 if net_io else 0 - self.network_io_samples.append(sent_kb) - return { - 'sent_kb': sent_kb, - 'recv_kb': net_io.bytes_recv / 1024 if net_io else 0, - 'packets_sent': net_io.packets_sent if net_io else 0, - 'packets_recv': net_io.packets_recv if net_io else 0 - } - except: - sent_kb = 0 - self.network_io_samples.append(sent_kb) - return None - def record_frame_time(self, frame_time): - """记录帧处理时间""" self.frame_times.append(frame_time) def get_performance_summary(self): - """获取性能摘要""" if not self.frame_times: avg_frame_time = 0 fps = 0 @@ -190,47 +98,8 @@ def get_performance_summary(self): 'std': np.std(self.frame_times) if self.frame_times else 0 } } - - # 添加GPU信息 - if self.gpu_memory_samples: - summary['gpu_memory'] = { - 'average_mb': np.mean(self.gpu_memory_samples), - 'max_mb': max(self.gpu_memory_samples) - } - - # 添加磁盘IO信息 - if self.disk_io_samples: - summary['disk_io'] = { - 'total_read_mb': sum(self.disk_io_samples), - 'average_read_mb': np.mean(self.disk_io_samples) - } - - # 添加网络IO信息 - if self.network_io_samples: - summary['network_io'] = { - 'total_sent_kb': sum(self.network_io_samples), - 'average_sent_kb': np.mean(self.network_io_samples) - } - return summary - def get_realtime_metrics(self): - """获取实时性能指标""" - try: - return { - 'memory_mb': psutil.Process(os.getpid()).memory_info().rss / 1024 / 1024, - 'cpu_percent': psutil.cpu_percent(interval=0.1), - 'frame_rate': 1.0 / self.frame_times[-1] if self.frame_times else 0, - 'active_threads': threading.active_count() - } - except: - return { - 'memory_mb': 0, - 'cpu_percent': 0, - 'frame_rate': 0, - 'active_threads': 0 - } - class Log: @staticmethod @@ -295,14 +164,12 @@ def __init__(self, output_dir, config=None): self.stitched_dir = os.path.join(output_dir, "stitched") os.makedirs(self.stitched_dir, exist_ok=True) - # 性能配置 self.compress_images = config.get('compress_images', True) if config else True self.compression_quality = config.get('compression_quality', 85) if config else 85 self.enable_memory_cache = config.get('enable_memory_cache', True) if config else True self.image_cache = {} self.max_cache_size = config.get('max_cache_size', 50) if config else 50 - # 性能统计 self.stats = { 'images_processed': 0, 'cache_hits': 0, @@ -319,14 +186,11 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): start_time = time.time() - # 检查缓存 cache_key = f"{view_type}_{frame_num}" if self.enable_memory_cache and cache_key in self.image_cache: - # 从缓存加载 cached_image = self.image_cache[cache_key] output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") - # 使用更快的保存方式 try: if self.compress_images: cached_image.save(output_path, "JPEG", @@ -356,22 +220,16 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): for idx, (cam_name, img_path) in enumerate(list(image_paths.items())[:4]): if img_path and os.path.exists(img_path): try: - # 检查图像是否已经加载到内存 if img_path in self.image_cache: img = self.image_cache[img_path] else: - # 使用更快的图像加载方式 img = Image.open(img_path) - # 预加载图像数据到内存 img.load() img = img.resize((640, 360), Image.Resampling.LANCZOS) - # 缓存图像 if self.enable_memory_cache: self.image_cache[img_path] = img - # 清理缓存如果太大 if len(self.image_cache) > self.max_cache_size: - # 使用LRU策略清理缓存 self._cleanup_cache() images_loaded += 1 except Exception as e: @@ -389,27 +247,22 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") - # 使用优化的保存参数 try: if self.compress_images: - # 使用更快的JPEG保存选项 canvas.save(output_path, "JPEG", quality=self.compression_quality, optimize=True, progressive=True, subsampling='4:2:0') else: - # PNG优化 canvas.save(output_path, "PNG", optimize=True) except Exception as e: Log.error(f"保存图像失败: {e}") return False - # 缓存结果 if self.enable_memory_cache: self.image_cache[cache_key] = canvas.copy() - # 清理内存 del canvas gc.collect() @@ -417,7 +270,6 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): processing_time = time.time() - start_time self.stats['total_processing_time'] += processing_time - # 记录性能日志(每50帧记录一次) if self.stats['images_processed'] % 50 == 0: avg_time = self.stats['total_processing_time'] / self.stats['images_processed'] cache_hit_rate = self.stats['cache_hits'] / max(1, self.stats['cache_hits'] + self.stats['cache_misses']) @@ -427,16 +279,13 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): return True def _cleanup_cache(self): - """清理图像缓存""" if len(self.image_cache) > self.max_cache_size: - # 移除最旧的缓存项(简单实现) keys_to_remove = list(self.image_cache.keys())[:len(self.image_cache) - self.max_cache_size] for key in keys_to_remove: del self.image_cache[key] Log.debug(f"清理缓存: 移除了{len(keys_to_remove)}个缓存项") def get_stats(self): - """获取处理统计""" total_operations = self.stats['cache_hits'] + self.stats['cache_misses'] if total_operations > 0: cache_hit_rate = self.stats['cache_hits'] / total_operations @@ -466,11 +315,9 @@ def __init__(self, world, config): random.seed(seed) Log.info(f"随机种子: {seed}") - # 性能优化:批量生成设置 self.batch_spawn = config.get('batch_spawn', True) self.max_spawn_attempts = config.get('max_spawn_attempts', 5) - # 性能统计 self.spawn_stats = { 'total_attempts': 0, 'successful_spawns': 0, @@ -501,7 +348,6 @@ def spawn_ego_vehicle(self): spawn_point = random.choice(spawn_points) - # 尝试多次生成 for attempt in range(self.max_spawn_attempts): self.spawn_stats['total_attempts'] += 1 try: @@ -521,7 +367,6 @@ def spawn_ego_vehicle(self): if attempt == self.max_spawn_attempts - 1: Log.warning(f"主车生成失败: {e}") else: - # 尝试不同的生成点 spawn_point = random.choice(spawn_points) time.sleep(0.1) @@ -540,7 +385,6 @@ def spawn_traffic(self, center_location): total_time = time.time() - start_time Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人, 用时: {total_time:.2f}秒") - # 记录性能统计 success_rate = self.spawn_stats['successful_spawns'] / max(1, self.spawn_stats['total_attempts']) avg_spawn_time = self.spawn_stats['total_spawn_time'] / max(1, self.spawn_stats['successful_spawns']) Log.performance(f"生成统计: 成功率{success_rate:.1%}, 平均生成时间{avg_spawn_time:.3f}秒") @@ -548,7 +392,6 @@ def spawn_traffic(self, center_location): return vehicles + pedestrians def _spawn_vehicles_batch(self): - """批量生成车辆(提高性能)""" blueprint_lib = self.world.get_blueprint_library() spawn_points = self.world.get_map().get_spawn_points() @@ -558,7 +401,6 @@ def _spawn_vehicles_batch(self): num_vehicles = min(self.config['traffic']['background_vehicles'], 10) spawned = 0 - # 准备批处理 batch_commands = [] available_points = spawn_points.copy() random.shuffle(available_points) @@ -570,14 +412,10 @@ def _spawn_vehicles_batch(self): try: vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) spawn_point = available_points[i] - - # 创建生成命令 batch_commands.append((vehicle_bp, spawn_point)) - except: pass - # 批量生成 for vehicle_bp, spawn_point in batch_commands: try: vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) @@ -592,7 +430,6 @@ def _spawn_vehicles_batch(self): self.spawn_stats['total_attempts'] += 1 pass - # 避免过快的生成速度 if spawned % 3 == 0: time.sleep(0.05) @@ -663,11 +500,9 @@ def _spawn_pedestrians(self, center_location): return spawned def cleanup(self): - """安全清理所有资源""" Log.info("开始清理交通管理器...") try: - # 清理行人 for pedestrian in self.pedestrians: try: if pedestrian and pedestrian.is_alive: @@ -677,7 +512,6 @@ def cleanup(self): self.pedestrians.clear() - # 清理背景车辆 for vehicle in self.vehicles: try: if vehicle and vehicle.is_alive: @@ -704,7 +538,6 @@ def __init__(self, world, config, data_dir): self.last_capture_time = 0 self.last_performance_sample = 0 - # 新增:帧率控制相关变量 self.target_fps = config['performance'].get('frame_rate_limit', 5.0) self.min_frame_interval = 1.0 / self.target_fps if self.target_fps > 0 else 0.1 self.last_frame_time = 0 @@ -715,18 +548,14 @@ def __init__(self, world, config, data_dir): self.infra_buffer = {} self.buffer_lock = threading.Lock() - # 添加运行状态标志 self.is_running = True - # 性能监控 self.performance_monitor = PerformanceMonitor() - # 性能优化配置 self.image_processor = ImageProcessor(data_dir, config.get('image_processing', {})) self.lidar_processor = None self.fusion_manager = None - # 批处理设置 self.batch_size = config['performance'].get('batch_size', 5) self.enable_async_processing = config.get('enable_async_processing', True) @@ -736,7 +565,6 @@ def __init__(self, world, config, data_dir): if config['output'].get('save_fusion', False): self.fusion_manager = MultiSensorFusion(data_dir, config['performance'].get('fusion', {})) - # 传感器统计 self.sensor_stats = { 'total_images': 0, 'total_lidar_frames': 0, @@ -746,7 +574,6 @@ def __init__(self, world, config, data_dir): } def setup_cameras(self, vehicle, center_location, vehicle_id=0): - """设置摄像头 - 修复的方法""" vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) infra_cams = self._setup_infrastructure_cameras(center_location) @@ -822,7 +649,6 @@ def setup_lidar(self, vehicle, vehicle_id=0): lidar_sensor = self.world.spawn_actor(lidar_bp, lidar_transform, attach_to=vehicle) def lidar_callback(lidar_data): - # 检查是否正在关闭 if not self.is_running: return @@ -860,7 +686,6 @@ def lidar_callback(lidar_data): if self.is_running: Log.error(f"LiDAR处理失败: {e}") - # 记录性能 frame_time = time.time() - frame_start_time self.performance_monitor.record_frame_time(frame_time) except Exception as e: @@ -895,7 +720,6 @@ def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): else: camera = self.world.spawn_actor(blueprint, transform) - # 为不同车辆创建不同目录 if sensor_type == 'vehicle' and vehicle_id > 0: save_dir = os.path.join(self.data_dir, "raw", f"vehicle_{vehicle_id}", name) else: @@ -917,7 +741,6 @@ def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): capture_interval = self.config['sensors']['capture_interval'] def callback(image): - # 检查是否正在关闭 if not self.is_running: return @@ -925,24 +748,20 @@ def callback(image): current_time = time.time() frame_start_time = time.time() - # 优化点2:添加帧率控制逻辑 - # 检查是否达到最小帧间隔 time_since_last_frame = current_time - self.last_frame_time if time_since_last_frame < self.min_frame_interval: - # 如果帧间隔太小,跳过此帧 self.frame_skip_count += 1 if self.frame_skip_count > self.max_frame_skip: - # 如果连续跳过多帧,强制处理一帧 self.frame_skip_count = 0 else: - return # 跳过此帧 + return else: self.frame_skip_count = 0 if current_time - self.last_capture_time >= capture_interval: self.frame_counter += 1 self.last_capture_time = current_time - self.last_frame_time = current_time # 记录帧处理时间 + self.last_frame_time = current_time capture_start = time.time() filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") @@ -956,7 +775,6 @@ def callback(image): if sensor_type == 'vehicle': self.vehicle_buffer[name] = filename if len(self.vehicle_buffer) >= 4: - # 使用线程池异步处理图像拼接,避免阻塞 if self.enable_async_processing: import concurrent.futures with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: @@ -986,11 +804,9 @@ def callback(image): self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') self.infra_buffer.clear() - # 定期采样性能 if current_time - self.last_performance_sample >= 5.0: memory_info = self.performance_monitor.sample_memory() cpu_info = self.performance_monitor.sample_cpu() - gpu_info = self.performance_monitor.sample_gpu_memory() if self.frame_counter % 10 == 0: Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " @@ -999,22 +815,18 @@ def callback(image): self.last_performance_sample = current_time - # 记录帧处理时间 frame_time = time.time() - frame_start_time self.performance_monitor.record_frame_time(frame_time) - # 定期垃圾回收 if self.frame_counter % 50 == 0: gc.collect() - # 记录传感器统计 if self.sensor_stats['total_images'] > 0: avg_capture_time = np.mean(self.sensor_stats['image_capture_times'][-100:]) if len( self.sensor_stats['image_capture_times']) > 0 else 0 Log.performance(f"传感器统计: 图像{self.sensor_stats['total_images']}张, " f"平均捕获时间{avg_capture_time:.3f}秒") except Exception as e: - # 如果在关闭过程中发生错误,忽略它 if self.is_running: Log.error(f"传感器回调错误: {e}") @@ -1033,7 +845,6 @@ def generate_sensor_summary(self): 'sensor_stats': self.sensor_stats } - # 计算统计信息 if self.sensor_stats['image_capture_times']: summary['sensor_stats']['avg_image_capture_time'] = np.mean(self.sensor_stats['image_capture_times']) summary['sensor_stats']['max_image_capture_time'] = np.max(self.sensor_stats['image_capture_times']) @@ -1048,39 +859,32 @@ def generate_sensor_summary(self): if self.fusion_manager: summary['fusion_data'] = self.fusion_manager.generate_fusion_report() - # 图像处理器统计 summary['image_processor_stats'] = self.image_processor.get_stats() return summary def cleanup(self): - """安全清理传感器""" Log.info(f"安全清理 {len(self.sensors)} 个传感器...") - # 1. 首先设置运行状态为False,防止回调函数继续执行 self.is_running = False - # 2. 停止所有传感器的监听 Log.info("停止所有传感器监听...") for sensor in self.sensors: try: if hasattr(sensor, 'stop'): sensor.stop() - time.sleep(0.001) # 短暂延迟 + time.sleep(0.001) except: pass - # 3. 等待一小段时间让所有传感器回调结束 time.sleep(0.2) - # 4. 刷新批处理数据 if self.lidar_processor: try: self.lidar_processor.flush_batch() except: pass - # 5. 销毁传感器 Log.info(f"销毁 {len(self.sensors)} 个传感器...") for i, sensor in enumerate(self.sensors): try: @@ -1088,29 +892,51 @@ def cleanup(self): sensor.destroy() except: pass - # 分批销毁,避免一次性销毁太多 if i % 5 == 0: time.sleep(0.01) self.sensors.clear() - # 6. 清理缓存和内存 if hasattr(self.image_processor, 'image_cache'): try: self.image_processor.image_cache.clear() except: pass - # 7. 清理数据结构 self.vehicle_buffer.clear() self.infra_buffer.clear() - # 8. 强制垃圾回收 gc.collect() Log.info("传感器清理完成") +class V2XCommunication: + def __init__(self, config): + self.config = config + self.nodes = {} + self.messages = [] + + def register_node(self, node_id, position, capabilities): + self.nodes[node_id] = { + 'position': position, + 'capabilities': capabilities, + 'last_update': time.time() + } + + def broadcast_basic_safety_message(self, sender_id, vehicle_data): + pass + + def get_messages_for_node(self, node_id): + return [] + + def get_network_status(self): + return {'nodes': len(self.nodes), 'messages': len(self.messages)} + + def stop(self): + pass + + class DataCollector: def __init__(self, config): self.config = config @@ -1130,11 +956,9 @@ def __init__(self, config): self.is_running = False self.collected_frames = 0 - # 性能监控 self.performance_monitor = PerformanceMonitor() - # 数据格式配置 - self.output_format = config.get('output_format', 'standard') # standard, v2xformer, kitti + self.output_format = config.get('output_format', 'standard') def setup_directories(self): scenario = self.config['scenario'] @@ -1155,8 +979,8 @@ def setup_directories(self): "calibration", "cooperative", "v2x_messages", - "v2xformer_format", # V2XFormer格式数据 - "kitti_format", # KITTI格式数据 + "v2xformer_format", + "kitti_format", "metadata" ] @@ -1201,7 +1025,6 @@ def setup_scene(self): self.traffic_manager = TrafficManager(self.world, self.config) - # 生成多个主车 num_ego_vehicles = min(self.config['cooperative'].get('num_coop_vehicles', 2) + 1, 3) for i in range(num_ego_vehicles): ego_vehicle = self.traffic_manager.spawn_ego_vehicle() @@ -1215,11 +1038,9 @@ def setup_scene(self): self.traffic_manager.spawn_traffic(self.scene_center) - # 初始化V2X通信 if self.config['v2x']['enabled']: self.v2x_communication = V2XCommunication(self.config['v2x']) - # 注册车辆到V2X网络 for i, vehicle in enumerate(self.ego_vehicles): location = vehicle.get_location() self.v2x_communication.register_node( @@ -1228,21 +1049,17 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) - # 初始化多车辆管理器 self.multi_vehicle_manager = MultiVehicleManager( self.world, self.config, self.output_dir ) - # 设置主车 self.multi_vehicle_manager.ego_vehicles = self.ego_vehicles - # 生成协同车辆 num_coop_vehicles = self.config['cooperative'].get('num_coop_vehicles', 2) coop_vehicles = self.multi_vehicle_manager.spawn_cooperative_vehicles(num_coop_vehicles) - # 注册协同车辆到V2X网络 if self.v2x_communication: for vehicle in coop_vehicles: location = vehicle.get_location() @@ -1256,8 +1073,6 @@ def setup_scene(self): return True def setup_sensors(self): - """设置传感器 - 修复的方法""" - # 为每个主车设置传感器 for i, vehicle in enumerate(self.ego_vehicles): sensor_manager = SensorManager(self.world, self.config, self.output_dir) @@ -1287,96 +1102,83 @@ def collect_data(self): last_detailed_log = time.time() last_memory_check = time.time() - # 内存监控变量 memory_warning_issued = False - forced_cleanup_count = 0 + early_stop_triggered = False + + # 添加内存监控阈值 + memory_warning_threshold = 350 # MB + memory_critical_threshold = 400 # MB + early_stop_threshold = 450 # MB try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time - # 内存检查 - 优化点4:定期检查内存使用 - if current_time - last_memory_check >= 2.0: # 更频繁的内存检查 + # 内存监控和早期停止机制 + if current_time - last_memory_check >= 2.0: try: import psutil process = psutil.Process() memory_mb = process.memory_info().rss / (1024 * 1024) - if memory_mb > 350 and not memory_warning_issued: - Log.warning(f"内存使用较高: {memory_mb:.1f}MB,将减少数据处理") - memory_warning_issued = True - - # 如果内存过高,跳过一些非关键操作 - if self.v2x_communication: - Log.debug("内存警告:暂停部分V2X消息处理") - - elif memory_mb > 400: # 如果内存超过400MB,提前结束 - Log.error(f"内存使用过高: {memory_mb:.1f}MB,提前结束数据收集") + if memory_mb > early_stop_threshold: + Log.error( + f"内存使用超过临界值({early_stop_threshold}MB): {memory_mb:.1f}MB,提前结束数据收集") + early_stop_triggered = True break - - elif memory_mb < 300: + elif memory_mb > memory_critical_threshold: + Log.warning(f"内存使用严重过高: {memory_mb:.1f}MB,进行强制清理") + self._force_memory_cleanup() + memory_warning_issued = True + elif memory_mb > memory_warning_threshold and not memory_warning_issued: + Log.warning(f"内存使用较高: {memory_mb:.1f}MB,减少数据处理") + memory_warning_issued = True + elif memory_mb < memory_warning_threshold: memory_warning_issued = False - forced_cleanup_count = 0 except Exception as e: Log.debug(f"内存检查失败: {e}") last_memory_check = current_time - # 更新车辆状态 if self.multi_vehicle_manager: self.multi_vehicle_manager.update_vehicle_states() - # V2X通信更新 - 使用配置中的更新间隔 v2x_interval = self.config['v2x'].get('update_interval', 2.0) if self.v2x_communication and current_time - last_v2x_update >= v2x_interval: self._update_v2x_communication() last_v2x_update = current_time - # 共享感知数据 - 仅在内存允许时进行 if (not memory_warning_issued and self.config['cooperative'].get('enable_shared_perception', True) and current_time - last_perception_share >= 2.0): self._share_perception_data() last_perception_share = current_time - # 性能采样 if current_time - last_performance_sample >= 10.0: memory_info = self.performance_monitor.sample_memory() cpu_info = self.performance_monitor.sample_cpu() - disk_info = self.performance_monitor.sample_disk_io() - network_info = self.performance_monitor.sample_network_io() - # 详细性能日志(每分钟一次) if current_time - last_detailed_log >= 60.0: Log.performance(f"详细性能监控:") Log.performance(f" 进程内存: {memory_info['process_mb']:.1f}MB") Log.performance(f" 系统内存: {memory_info['system_used_percent']:.1f}%使用率") Log.performance(f" CPU: {cpu_info['total_percent']:.1f}% ({cpu_info['count']}核心)") - if disk_info: - Log.performance( - f" 磁盘IO: 读{disk_info['read_mb']:.1f}MB, 写{disk_info['write_mb']:.1f}MB") - if network_info: - Log.performance( - f" 网络IO: 发{network_info['sent_kb']:.1f}KB, 收{network_info['recv_kb']:.1f}KB") last_detailed_log = current_time else: - # 简化性能日志 Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " f"CPU: {cpu_info['total_percent']:.1f}%, " f"活跃线程: {threading.active_count()}") last_performance_sample = current_time - # 定期垃圾回收 gc.collect() if current_time - last_update >= 5.0: total_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) progress = (elapsed / duration) * 100 - # 计算预估剩余时间 if total_frames > 0: frames_per_second = total_frames / elapsed remaining_frames = (duration - elapsed) * frames_per_second @@ -1389,7 +1191,7 @@ def collect_data(self): f"ETA: {eta_seconds:.0f}秒") last_update = current_time - time.sleep(0.01) # 减少CPU占用 + time.sleep(0.01) except KeyboardInterrupt: Log.info("数据收集被用户中断") @@ -1402,10 +1204,13 @@ def collect_data(self): self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - # 获取性能摘要 performance_summary = self.performance_monitor.get_performance_summary() - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + if early_stop_triggered: + Log.warning("数据收集因内存过高而提前终止") + else: + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") @@ -1413,15 +1218,12 @@ def collect_data(self): self._save_metadata() self._print_summary() - # 生成标准格式数据 if self.output_format != 'standard': self._convert_to_target_format() def _force_memory_cleanup(self): - """强制内存清理""" Log.info("执行强制内存清理...") - # 清理图像处理器缓存 for sensor_manager in self.sensor_managers.values(): if hasattr(sensor_manager, 'image_processor'): if hasattr(sensor_manager.image_processor, 'image_cache'): @@ -1432,7 +1234,6 @@ def _force_memory_cleanup(self): except: pass - # 清理LiDAR批处理 for sensor_manager in self.sensor_managers.values(): if hasattr(sensor_manager, 'lidar_processor'): try: @@ -1441,25 +1242,20 @@ def _force_memory_cleanup(self): except: pass - # 强制垃圾回收 gc.collect() Log.info("强制内存清理完成") def cleanup(self): - """安全清理所有资源 - 完全重写的版本""" Log.info("开始安全清理场景...") cleanup_start = time.time() try: - # 1. 设置运行状态为False self.is_running = False - # 2. 等待一小段时间让循环结束 time.sleep(0.2) - # 3. 停止V2X通信 if self.v2x_communication: try: Log.info("停止V2X通信...") @@ -1467,7 +1263,6 @@ def cleanup(self): except: pass - # 4. 清理传感器(最重要,必须先于车辆) Log.info(f"清理 {len(self.sensor_managers)} 个传感器管理器...") for vehicle_id, sensor_manager in self.sensor_managers.items(): try: @@ -1476,9 +1271,8 @@ def cleanup(self): pass self.sensor_managers.clear() - time.sleep(0.1) # 等待传感器清理完成 + time.sleep(0.1) - # 5. 清理多车辆管理器 if self.multi_vehicle_manager: try: Log.info("清理多车辆管理器...") @@ -1486,7 +1280,6 @@ def cleanup(self): except: pass - # 6. 清理背景交通 if self.traffic_manager: try: Log.info("清理交通管理器...") @@ -1494,7 +1287,6 @@ def cleanup(self): except: pass - # 7. 清理主车(最后清理) Log.info(f"清理 {len(self.ego_vehicles)} 个主车...") for vehicle in self.ego_vehicles: try: @@ -1502,11 +1294,10 @@ def cleanup(self): vehicle.destroy() except: pass - time.sleep(0.01) # 短暂延迟 + time.sleep(0.01) self.ego_vehicles.clear() - # 8. 重置世界设置 try: if self.world: default_weather = carla.WeatherParameters() @@ -1514,26 +1305,21 @@ def cleanup(self): except: pass - # 9. 强制垃圾回收 gc.collect() - # 10. 等待确保清理完成 time.sleep(0.3) - # 11. 释放引用 self.traffic_manager = None self.multi_vehicle_manager = None self.v2x_communication = None self.scene_center = None - # 最后一次强制垃圾回收 gc.collect() Log.info(f"清理完成,总用时: {time.time() - cleanup_start:.2f}秒") except Exception as e: Log.error(f"清理过程中发生错误: {e}") - # 紧急清理:强制释放所有引用 try: self.sensor_managers.clear() self.ego_vehicles.clear() @@ -1545,7 +1331,6 @@ def cleanup(self): pass def _convert_to_target_format(self): - """转换为目标数据格式""" Log.info(f"转换为 {self.output_format} 格式...") if self.output_format == 'v2xformer': @@ -1554,22 +1339,17 @@ def _convert_to_target_format(self): self._convert_to_kitti_format() def _convert_to_v2xformer_format(self): - """转换为V2XFormer格式""" try: - # 创建必要的目录结构 v2x_dir = os.path.join(self.output_dir, "v2xformer_format") - # 创建数据集结构 splits = ['train', 'val', 'test'] for split in splits: split_dir = os.path.join(v2x_dir, split) os.makedirs(split_dir, exist_ok=True) - # 创建子目录 for subdir in ['image', 'point_cloud', 'calib', 'label']: os.makedirs(os.path.join(split_dir, subdir), exist_ok=True) - # 生成数据集划分 total_frames = self.collected_frames train_ratio = 0.7 val_ratio = 0.2 @@ -1579,7 +1359,6 @@ def _convert_to_v2xformer_format(self): val_frames = int(total_frames * val_ratio) test_frames = total_frames - train_frames - val_frames - # 生成划分文件 splits_info = { 'train': list(range(0, train_frames)), 'val': list(range(train_frames, train_frames + val_frames)), @@ -1596,11 +1375,9 @@ def _convert_to_v2xformer_format(self): Log.error(f"V2XFormer格式转换失败: {e}") def _convert_to_kitti_format(self): - """转换为KITTI格式""" try: kitti_dir = os.path.join(self.output_dir, "kitti_format") - # 创建KITTI标准目录结构 for subdir in ['training', 'testing']: full_dir = os.path.join(kitti_dir, subdir) os.makedirs(full_dir, exist_ok=True) @@ -1608,7 +1385,6 @@ def _convert_to_kitti_format(self): for subsubdir in ['image_2', 'velodyne', 'calib', 'label_2']: os.makedirs(os.path.join(full_dir, subsubdir), exist_ok=True) - # 生成KITTI格式的校准文件 self._generate_kitti_calibration(kitti_dir) Log.info(f"KITTI格式转换完成: {kitti_dir}") @@ -1617,7 +1393,6 @@ def _convert_to_kitti_format(self): Log.error(f"KITTI格式转换失败: {e}") def _generate_kitti_calibration(self, kitti_dir): - """生成KITTI格式的校准文件""" calib_template = """P0: 7.215377e+02 0.000000e+00 6.095593e+02 0.000000e+00 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 P1: 7.215377e+02 0.000000e+00 6.095593e+02 -3.875744e+02 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 P2: 7.215377e+02 0.000000e+00 6.095593e+02 4.485728e+01 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 @@ -1626,18 +1401,15 @@ def _generate_kitti_calibration(self, kitti_dir): Tr_velo_to_cam: 4.276802e-04 -9.999672e-01 -8.084491e-03 -1.198459e-02 -7.210626e-03 8.081198e-03 -9.999413e-01 -5.403984e-02 9.999738e-01 4.859485e-04 -7.206933e-03 -2.921968e-02 Tr_imu_to_velo: 9.999976e-01 7.553071e-04 -2.035826e-03 -8.086759e-01 -7.854027e-04 9.998898e-01 -1.482298e-02 3.195559e-01 2.024406e-03 1.482454e-02 9.998881e-01 -7.997231e-01""" - # 为每一帧生成校准文件 for i in range(self.collected_frames): calib_file = os.path.join(kitti_dir, "training", "calib", f"{i:06d}.txt") with open(calib_file, 'w') as f: f.write(calib_template) def _update_v2x_communication(self): - """更新V2X通信""" if not self.v2x_communication: return - # 为每辆车发送基本安全消息 for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue @@ -1651,7 +1423,7 @@ def _update_v2x_communication(self): 'position': (location.x, location.y, location.z), 'speed': speed, 'heading': vehicle.get_transform().rotation.yaw, - 'acceleration': (0, 0, 0) # 简化处理 + 'acceleration': (0, 0, 0) } self.v2x_communication.broadcast_basic_safety_message( @@ -1661,33 +1433,27 @@ def _update_v2x_communication(self): except: pass - # 处理接收到的消息 for vehicle in self.ego_vehicles: messages = self.v2x_communication.get_messages_for_node(f'vehicle_{vehicle.id}') if messages: Log.debug(f"车辆 {vehicle.id} 收到 {len(messages)} 条V2X消息") def _share_perception_data(self): - """共享感知数据""" if not self.multi_vehicle_manager or not self.config['cooperative']['enable_shared_perception']: return - # 模拟车辆感知数据(简化处理,实际应从传感器获取) for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue - # 模拟检测到的物体 detected_objects = self._simulate_object_detection(vehicle) if detected_objects: self.multi_vehicle_manager.share_perception_data(vehicle.id, detected_objects) def _simulate_object_detection(self, vehicle): - """模拟对象检测(简化)""" detected_objects = [] - # 获取车辆周围的其他车辆 for other_vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: if other_vehicle.id == vehicle.id or not hasattr(other_vehicle, 'is_alive') or not other_vehicle.is_alive: continue @@ -1696,7 +1462,6 @@ def _simulate_object_detection(self, vehicle): location = other_vehicle.get_location() distance = vehicle.get_location().distance(location) - # 模拟检测范围(50米) if distance < 50.0: obj_data = { 'class': 'vehicle', @@ -1729,17 +1494,14 @@ def _save_metadata(self): 'performance': self.performance_monitor.get_performance_summary() } - # 传感器摘要 sensor_summaries = {} for vehicle_id, sensor_manager in self.sensor_managers.items(): sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() metadata['sensor_summaries'] = sensor_summaries - # V2X通信状态 if self.v2x_communication: metadata['v2x_status'] = self.v2x_communication.get_network_status() - # 协同摘要 if self.multi_vehicle_manager: metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() @@ -1754,19 +1516,16 @@ def _print_summary(self): print("数据收集摘要") print("=" * 60) - # 统计原始图像 raw_dirs = [d for d in os.listdir(self.output_dir) if d.startswith('raw')] total_raw_images = 0 for raw_dir in raw_dirs: raw_path = os.path.join(self.output_dir, raw_dir) if os.path.exists(raw_path): - # 快速统计 for root, dirs, files in os.walk(raw_path): total_raw_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) print(f"原始图像: {total_raw_images} 张") - # 统计LiDAR lidar_dir = os.path.join(self.output_dir, "lidar") if os.path.exists(lidar_dir): import glob @@ -1776,7 +1535,6 @@ def _print_summary(self): print(f"LiDAR数据: {len(bin_files)} .bin文件, {len(npy_files)} .npy文件") print(f"批处理文件: {len(batch_files)} 个") - # 统计协同数据 coop_dir = os.path.join(self.output_dir, "cooperative") if os.path.exists(coop_dir): v2x_files = len( @@ -1785,7 +1543,6 @@ def _print_summary(self): [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") - # 格式转换 if self.output_format == 'v2xformer': v2x_dir = os.path.join(self.output_dir, "v2xformer_format") if os.path.exists(v2x_dir): @@ -1796,7 +1553,6 @@ def _print_summary(self): if os.path.exists(kitti_dir): print(f"KITTI格式: 已生成") - # 性能统计 performance = self.performance_monitor.get_performance_summary() print(f"\n性能统计:") print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") @@ -1825,9 +1581,8 @@ def run_analysis(self): def main(): - parser = argparse.ArgumentParser(description='CVIPS 性能优化数据收集系统 v12.0') + parser = argparse.ArgumentParser(description='CVIPS 性能优化数据收集系统') - # 基础参数 parser.add_argument('--config', type=str, help='配置文件路径') parser.add_argument('--scenario', type=str, default='performance_optimized', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', @@ -1837,26 +1592,21 @@ def main(): parser.add_argument('--time-of-day', type=str, default='noon', choices=['noon', 'sunset', 'night'], help='时间') - # 交通参数 parser.add_argument('--num-vehicles', type=int, default=8, help='背景车辆数') parser.add_argument('--num-pedestrians', type=int, default=6, help='行人数') parser.add_argument('--num-coop-vehicles', type=int, default=2, help='协同车辆数') - # 收集参数 parser.add_argument('--duration', type=int, default=60, help='收集时长(秒)') parser.add_argument('--capture-interval', type=float, default=2.0, help='捕捉间隔(秒)') parser.add_argument('--seed', type=int, help='随机种子') - # 性能参数 parser.add_argument('--batch-size', type=int, default=5, help='批处理大小') parser.add_argument('--enable-compression', action='store_true', help='启用数据压缩') parser.add_argument('--enable-downsampling', action='store_true', help='启用LiDAR下采样') - # 输出格式 parser.add_argument('--output-format', type=str, default='standard', choices=['standard', 'v2xformer', 'kitti'], help='输出数据格式') - # 传感器参数 parser.add_argument('--enable-lidar', action='store_true', help='启用LiDAR传感器') parser.add_argument('--enable-fusion', action='store_true', help='启用多传感器融合') parser.add_argument('--enable-v2x', action='store_true', help='启用V2X通信') @@ -1864,26 +1614,22 @@ def main(): parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') - # 功能参数 parser.add_argument('--run-analysis', action='store_true', help='运行数据集分析') parser.add_argument('--skip-validation', action='store_true', help='跳过数据验证') parser.add_argument('--skip-quality-check', action='store_true', help='跳过质量检查') args = parser.parse_args(remaining_argv) - # 加载配置 config = ConfigManager.load_config(args.config) config = ConfigManager.merge_args(config, args) - # 添加性能配置 config['performance']['batch_size'] = args.batch_size config['performance']['enable_compression'] = args.enable_compression config['performance']['enable_downsampling'] = args.enable_downsampling config['output']['output_format'] = args.output_format - # 显示配置 print("\n" + "=" * 60) - print("CVIPS 性能优化数据收集系统 v12.0") + print("CVIPS 性能优化数据收集系统") print("=" * 60) print(f"场景: {config['scenario']['name']}") From 7bf2df9d0c37172ac7bb8f6f9fed4ba982b6b21d Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 12:13:44 +0800 Subject: [PATCH 12/21] =?UTF-8?q?=E4=B8=BA=E5=86=85=E5=AD=98=E7=9B=91?= =?UTF-8?q?=E6=8E=A7=E6=B7=BB=E5=8A=A0=E9=85=8D=E7=BD=AE=E9=A1=B9=EF=BC=8C?= =?UTF-8?q?=E4=BC=98=E5=8C=96=E4=B8=8B=E9=87=87=E6=A0=B7=E5=87=BD=E6=95=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 102 ++------------ .../lidar_processor.py | 124 +++--------------- 2 files changed, 33 insertions(+), 193 deletions(-) diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 1f64c72ef9..c608de6674 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -4,31 +4,24 @@ import copy from typing import Dict, Any, Optional, List, Tuple -# 尝试导入yaml,如果不存在则跳过 try: import yaml - YAML_AVAILABLE = True except ImportError: YAML_AVAILABLE = False - print("警告: PyYAML未安装,将使用JSON格式") class ConfigValidator: - """配置验证器""" @staticmethod def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: - """验证配置的有效性""" errors = [] - # 验证必填字段 required_sections = ['scenario', 'sensors', 'output'] for section in required_sections: if section not in config: errors.append(f"缺失必要配置节: {section}") - # 验证场景配置 if 'scenario' in config: scenario = config['scenario'] if 'duration' in scenario and scenario['duration'] <= 0: @@ -36,7 +29,6 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: if 'town' not in scenario: errors.append("场景配置中缺失地图名称") - # 验证传感器配置 if 'sensors' in config: sensors = config['sensors'] if 'capture_interval' in sensors and sensors['capture_interval'] <= 0: @@ -47,7 +39,6 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: elif any(dim <= 0 for dim in sensors['image_size']): errors.append("图像尺寸必须大于0") - # 验证性能配置 if 'performance' in config: perf = config['performance'] if 'batch_size' in perf and perf['batch_size'] <= 0: @@ -57,22 +48,18 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: @staticmethod def suggest_optimizations(config: Dict[str, Any]) -> List[str]: - """根据配置提供优化建议""" suggestions = [] - # 内存使用建议 if config.get('sensors', {}).get('lidar_sensors', 0) > 0: lidar_config = config['sensors'].get('lidar_config', {}) max_points = lidar_config.get('max_points_per_frame', 50000) if max_points > 50000: suggestions.append(f"LiDAR最大点数({max_points})较高,建议降低到50000以下以减少内存使用") - # 性能建议 capture_interval = config['sensors'].get('capture_interval', 2.0) if capture_interval < 1.0: suggestions.append(f"采集间隔({capture_interval}s)较短,可能导致高负载,建议增加到1.0s以上") - # 输出建议 output = config.get('output', {}) enabled_outputs = [k for k, v in output.items() if isinstance(v, bool) and v] if len(enabled_outputs) > 5: @@ -82,14 +69,11 @@ def suggest_optimizations(config: Dict[str, Any]) -> List[str]: class ConfigOptimizer: - """配置优化器""" @staticmethod def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: - """为内存使用优化配置""" optimized = copy.deepcopy(config) - # 调整LiDAR设置 if optimized['sensors'].get('lidar_sensors', 0) > 0: lidar_config = optimized['sensors'].setdefault('lidar_config', {}) lidar_config.update({ @@ -99,7 +83,6 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'max_batch_memory_mb': 30 }) - # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 3, @@ -110,7 +93,6 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'frame_rate_limit': 3.0 }) - # 调整图像处理 perf['image_processing'] = { 'compress_images': True, 'compression_quality': 80, @@ -121,10 +103,8 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: - """为数据质量优化配置""" optimized = copy.deepcopy(config) - # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [1920, 1080], @@ -139,7 +119,6 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: } }) - # 调整输出设置 output = optimized['output'] output.update({ 'save_annotations': True, @@ -149,7 +128,6 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: 'run_quality_check': True }) - # 调整增强设置 enhanced = optimized.setdefault('enhancement', {}) enhanced.update({ 'enabled': True, @@ -162,35 +140,31 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: - """为处理速度优化配置""" optimized = copy.deepcopy(config) - # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [640, 480], 'capture_interval': 3.0, - 'lidar_sensors': 0, # 禁用LiDAR - 'radar_sensors': 0 # 禁用雷达 + 'lidar_sensors': 0, + 'radar_sensors': 0 }) - # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 10, 'enable_compression': True, - 'compression_level': 1, # 快速压缩 + 'compression_level': 1, 'enable_downsampling': True, 'enable_async_processing': True, 'max_cache_size': 20, 'frame_rate_limit': 10.0 }) - # 简化输出 output = optimized['output'] output.update({ 'save_raw': True, - 'save_stitched': False, # 不拼接图像 + 'save_stitched': False, 'save_annotations': False, 'save_lidar': False, 'save_fusion': False, @@ -201,9 +175,7 @@ def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: class ConfigManager: - """配置管理器(增强版)""" - # 预定义配置模板 PRESET_CONFIGS = { 'balanced': { 'description': '平衡配置 - 兼顾性能和质量', @@ -238,31 +210,17 @@ class ConfigManager: @staticmethod def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) -> Dict[str, Any]: - """ - 加载配置 - - Args: - config_file: 配置文件路径 - preset: 预设配置名称 - - Returns: - 配置字典 - """ - # 基础配置 config = ConfigManager._get_default_config() - # 应用预设配置 if preset: config = ConfigManager._apply_preset(config, preset) - # 加载用户配置文件 if config_file: if os.path.exists(config_file): config = ConfigManager._load_config_file(config_file, config) else: print(f"警告: 配置文件不存在: {config_file}") - # 验证配置 is_valid, errors = ConfigValidator.validate_config(config) if not is_valid: print("配置验证错误:") @@ -270,7 +228,6 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) print(f" - {error}") raise ValueError("配置验证失败") - # 提供优化建议 suggestions = ConfigValidator.suggest_optimizations(config) if suggestions: print("配置优化建议:") @@ -281,7 +238,6 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) @staticmethod def _get_default_config() -> Dict[str, Any]: - """获取默认配置(增强版)""" return { 'scenario': { 'name': 'multi_sensor_scene', @@ -291,8 +247,8 @@ def _get_default_config() -> Dict[str, Any]: 'time_of_day': 'noon', 'duration': 60, 'seed': 42, - 'timeout': 300, # 超时时间(秒) - 'retry_attempts': 3 # 重试次数 + 'timeout': 300, + 'retry_attempts': 3 }, 'traffic': { 'ego_vehicles': 1, @@ -336,7 +292,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 300, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_format': 'bin' # bin, npy, pcd + 'compression_format': 'bin' }, 'camera_config': { 'fov': 90.0, @@ -395,7 +351,7 @@ def _get_default_config() -> Dict[str, Any]: 'compression_quality': 85, 'resize_images': False, 'resize_dimensions': [640, 480], - 'format': 'jpg' # jpg, png + 'format': 'jpg' }, 'lidar_processing': { 'batch_size': 10, @@ -405,7 +361,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 350, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_method': 'zlib' # zlib, lz4, none + 'compression_method': 'zlib' }, 'fusion': { 'fusion_cache_size': 100, @@ -422,7 +378,7 @@ def _get_default_config() -> Dict[str, Any]: }, 'output': { 'data_dir': 'cvips_dataset', - 'output_format': 'standard', # standard, v2xformer, kitti, coco + 'output_format': 'standard', 'save_raw': True, 'save_stitched': True, 'save_annotations': False, @@ -436,12 +392,12 @@ def _get_default_config() -> Dict[str, Any]: 'run_quality_check': True, 'generate_summary': True, 'compression_enabled': True, - 'file_naming': 'sequential', # sequential, timestamp + 'file_naming': 'sequential', 'backup_original': False }, 'monitoring': { 'enable_logging': True, - 'log_level': 'INFO', # DEBUG, INFO, WARNING, ERROR + 'log_level': 'INFO', 'log_file': 'cvips.log', 'enable_performance_monitor': True, 'performance_log_interval': 10.0, @@ -468,7 +424,6 @@ def _get_default_config() -> Dict[str, Any]: @staticmethod def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: - """应用预设配置""" if preset_name not in ConfigManager.PRESET_CONFIGS: print(f"警告: 未知的预设配置: {preset_name}") return config @@ -476,7 +431,6 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: preset = ConfigManager.PRESET_CONFIGS[preset_name] print(f"应用预设配置: {preset_name} - {preset['description']}") - # 根据优化类型应用配置 optimization = preset.get('optimization', 'balanced') if optimization == 'memory': config = ConfigOptimizer.optimize_for_memory(config) @@ -491,7 +445,6 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: @staticmethod def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str, Any]: - """加载配置文件""" try: with open(config_file, 'r', encoding='utf-8') as f: if (config_file.endswith('.yaml') or config_file.endswith('.yml')) and YAML_AVAILABLE: @@ -508,7 +461,6 @@ def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str @staticmethod def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]: - """深度更新字典""" for key, value in update.items(): if key in original and isinstance(original[key], dict) and isinstance(value, dict): ConfigManager._deep_update(original[key], value) @@ -518,8 +470,6 @@ def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, @staticmethod def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]: - """合并命令行参数到配置""" - # 场景参数 if hasattr(args, 'scenario') and args.scenario: config['scenario']['name'] = args.scenario if hasattr(args, 'town') and args.town: @@ -533,58 +483,45 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if hasattr(args, 'seed') and args.seed: config['scenario']['seed'] = args.seed - # 交通参数 if hasattr(args, 'num_vehicles') and args.num_vehicles: config['traffic']['background_vehicles'] = args.num_vehicles if hasattr(args, 'num_pedestrians') and args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians - # 协同参数 if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles - # 传感器参数 if hasattr(args, 'capture_interval') and args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval - # V2X参数 if hasattr(args, 'enable_v2x'): config['v2x']['enabled'] = args.enable_v2x - # 增强参数 if hasattr(args, 'enable_enhancement'): config['enhancement']['enabled'] = args.enable_enhancement - # LiDAR参数 if hasattr(args, 'enable_lidar'): config['sensors']['lidar_sensors'] = 1 if args.enable_lidar else 0 config['output']['save_lidar'] = args.enable_lidar - # 融合参数 if hasattr(args, 'enable_fusion'): config['output']['save_fusion'] = args.enable_fusion - # 协同参数 if hasattr(args, 'enable_cooperative'): config['output']['save_cooperative'] = args.enable_cooperative - # 标注参数 if hasattr(args, 'enable_annotations'): config['output']['save_annotations'] = args.enable_annotations - # 验证参数 if hasattr(args, 'skip_validation'): config['output']['validate_data'] = not args.skip_validation - # 质量检查参数 if hasattr(args, 'skip_quality_check'): config['output']['run_quality_check'] = not args.skip_quality_check - # 分析参数 if hasattr(args, 'run_analysis'): config['output']['run_analysis'] = args.run_analysis - # 性能参数 if hasattr(args, 'batch_size') and args.batch_size: config['performance']['batch_size'] = args.batch_size @@ -596,7 +533,6 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if args.enable_downsampling: config['sensors']['lidar_config']['downsample_ratio'] = 0.3 - # 输出格式 if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format @@ -604,7 +540,6 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An @staticmethod def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): - """保存配置到文件""" try: os.makedirs(os.path.dirname(output_path), exist_ok=True) @@ -623,7 +558,6 @@ def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): @staticmethod def generate_config_template(output_path: str, preset: Optional[str] = None): - """生成配置模板""" config = ConfigManager.load_config(preset=preset) config['metadata']['created'] = 'template' config['metadata']['description'] = f'配置模板 - {preset if preset else "通用"}' @@ -632,12 +566,10 @@ def generate_config_template(output_path: str, preset: Optional[str] = None): @staticmethod def print_config_summary(config: Dict[str, Any]): - """打印配置摘要""" print("\n" + "=" * 60) print("配置摘要") print("=" * 60) - # 场景信息 scenario = config['scenario'] print(f"\n📋 场景:") print(f" 名称: {scenario['name']}") @@ -646,7 +578,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 时长: {scenario['duration']}秒") print(f" 随机种子: {scenario.get('seed', '随机')}") - # 交通信息 traffic = config['traffic'] print(f"\n🚗 交通:") print(f" 主车: {traffic['ego_vehicles']}") @@ -654,7 +585,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 行人: {traffic['pedestrians']}") print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") - # 传感器信息 sensors = config['sensors'] print(f"\n📷 传感器:") print(f" 车辆摄像头: {sensors['vehicle_cameras']}") @@ -663,7 +593,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 采集间隔: {sensors['capture_interval']}秒") print(f" 图像尺寸: {sensors['image_size'][0]}x{sensors['image_size'][1]}") - # V2X信息 v2x = config['v2x'] print(f"\n📡 V2X通信:") print(f" 状态: {'启用' if v2x['enabled'] else '禁用'}") @@ -671,14 +600,12 @@ def print_config_summary(config: Dict[str, Any]): print(f" 通信范围: {v2x['communication_range']}米") print(f" 更新间隔: {v2x['update_interval']}秒") - # 协同信息 coop = config['cooperative'] print(f"\n🤝 协同感知:") print(f" 协同车辆: {coop['num_coop_vehicles']}") print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") print(f" 交通警告: {'启用' if coop['enable_traffic_warnings'] else '禁用'}") - # 性能信息 perf = config['performance'] print(f"\n⚡ 性能:") print(f" 批处理大小: {perf['batch_size']}") @@ -686,7 +613,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") print(f" 帧率限制: {perf['frame_rate_limit']} FPS") - # 输出信息 output = config['output'] print(f"\n💾 输出:") print(f" 输出目录: {output['data_dir']}") @@ -699,7 +625,6 @@ def print_config_summary(config: Dict[str, Any]): @staticmethod def list_presets(): - """列出所有预设配置""" print("\n可用预设配置:") print("-" * 40) for name, preset in ConfigManager.PRESET_CONFIGS.items(): @@ -707,12 +632,9 @@ def list_presets(): print("-" * 40) -# 兼容旧版本的接口 def load_config(config_file=None): - """兼容旧版本的加载配置函数""" return ConfigManager.load_config(config_file) def merge_args(config, args): - """兼容旧版本的合并参数函数""" return ConfigManager.merge_args(config, args) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index 654aa674b8..8c0f6ebb20 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -23,21 +23,18 @@ def __init__(self, output_dir, config=None): self.frame_counter = 0 self.data_lock = threading.Lock() - # 性能优化:批量处理设置 self.batch_size = config.get('batch_size', 10) if config else 10 self.point_cloud_batch = [] self.enable_compression = config.get('enable_compression', True) if config else True self.compression_level = config.get('compression_level', 3) if config else 3 - # 内存管理 - 优化点3:更保守的内存设置 - self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 # 减少到5万点 + self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 self.enable_downsampling = config.get('enable_downsampling', True) if config else True - self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 # 增加下采样比例 + self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 - # 新增:内存监控和限制 - self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 # MB - self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 # 批次最大内存 - self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 # 每5帧保存一次V2X格式 + self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 + self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 + self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 self._init_calibration_files() @@ -81,109 +78,81 @@ def process_lidar_data(self, lidar_data, frame_num): points = self._carla_lidar_to_numpy(lidar_data) if points is None or points.shape[0] == 0: - print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") return None - # 检查内存使用情况 if self._check_memory_usage(): - print(f"警告: 内存使用过高,跳过LiDAR处理 (帧 {frame_num})") return None - # 下采样以减少内存使用 original_count = points.shape[0] if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: points = self._downsample_point_cloud(points) - print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") - # 检查批次内存使用 batch_memory_mb = self._estimate_batch_memory_mb() if batch_memory_mb > self.max_batch_memory_mb: - print(f"批处理内存过高 ({batch_memory_mb:.1f}MB),强制保存当前批次") self._save_batch() - # 添加到批处理 self.point_cloud_batch.append((frame_num, points)) - # 如果达到批处理大小,保存批处理数据 if len(self.point_cloud_batch) >= self.batch_size: self._save_batch() - # 保存单个文件(向后兼容) bin_path = self._save_as_bin(points, frame_num) npy_path = self._save_as_npy(points, frame_num) - # 生成V2XFormer兼容格式 - 优化点:每v2x_save_interval帧保存一次 v2xformer_path = None if frame_num % self.v2x_save_interval == 0: try: v2xformer_path = self._save_as_v2xformer_format(points, frame_num) except Exception as e: - print(f"警告: V2XFormer格式保存失败: {e}") v2xformer_path = None metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) - # 定期清理内存 if frame_num % 20 == 0: gc.collect() return metadata except Exception as e: - print(f"处理LiDAR数据失败: {e}") - # 强制清理内存 gc.collect() return None def _carla_lidar_to_numpy(self, lidar_data): - """高效转换LiDAR数据""" try: - # 使用内存视图减少内存分配 points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) points = np.reshape(points, (int(points.shape[0] / 4), 4)) - - # 只保留位置信息(x, y, z),忽略强度 points = points[:, :3] - # 清理临时数组 del lidar_data gc.collect() return points except Exception as e: - print(f"LiDAR数据转换失败: {e}") - - # 备选转换方法 try: points = [] for i in range(0, len(lidar_data), 4): point = lidar_data[i:i + 4] points.append([point.x, point.y, point.z]) - return np.array(points, dtype=np.float32) except: return None def _downsample_point_cloud(self, points): - """下采样点云以减少内存使用""" if points.shape[0] <= self.max_points_per_frame: return points - # 随机下采样 indices = np.random.choice(points.shape[0], int(points.shape[0] * self.downsample_ratio), replace=False) downsampled = points[indices] - # 清理内存 del points gc.collect() return downsampled def _estimate_batch_memory_mb(self): - """估计批处理内存使用""" if not self.point_cloud_batch: return 0 @@ -191,45 +160,38 @@ def _estimate_batch_memory_mb(self): for _, points in self.point_cloud_batch: total_points += points.shape[0] - # 每个点3个float32 (12字节),加上一些额外开销 - memory_bytes = total_points * 12 * 1.2 # 20%额外开销 + memory_bytes = total_points * 12 * 1.2 return memory_bytes / (1024 * 1024) def _check_memory_usage(self): - """检查内存使用情况""" try: import psutil process = psutil.Process() memory_mb = process.memory_info().rss / (1024 * 1024) if memory_mb > self.memory_warning_threshold: - print(f"警告: 进程内存使用过高: {memory_mb:.1f}MB") return True return False except: return False def _save_batch(self): - """批量保存点云数据(提高效率)""" if not self.point_cloud_batch: return batch_data = [] for frame_num, points in self.point_cloud_batch: - # 只保存点的坐标,不保存完整对象 batch_data.append({ 'frame_num': frame_num, 'points': points.tolist(), 'num_points': points.shape[0] }) - # 生成批处理文件名 min_frame = min([item[0] for item in self.point_cloud_batch]) max_frame = max([item[0] for item in self.point_cloud_batch]) batch_filename = f"lidar_batch_{min_frame:06d}_{max_frame:06d}.json" batch_path = os.path.join(self.lidar_dir, batch_filename) - # 压缩保存 if self.enable_compression: try: json_str = json.dumps(batch_data) @@ -240,49 +202,39 @@ def _save_batch(self): with open(batch_path, 'wb') as f: f.write(compressed_data) except Exception as e: - print(f"压缩保存批处理数据失败: {e}") - # 尝试非压缩保存 try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e2: - print(f"非压缩保存批处理数据失败: {e2}") + pass else: try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e: - print(f"保存批处理数据失败: {e}") + pass - # 清理批处理缓存 self.point_cloud_batch.clear() gc.collect() - print(f"批量保存LiDAR数据: {batch_filename}") - def _save_as_bin(self, points, frame_num): - """保存为二进制格式(兼容KITTI)""" bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") - # 添加强度信息(全为1) points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) points_with_intensity[:, :3] = points - points_with_intensity[:, 3] = 1.0 # 强度值 + points_with_intensity[:, 3] = 1.0 try: points_with_intensity.tofile(bin_path) except Exception as e: - print(f"保存BIN文件失败: {e}") return None return bin_path def _save_as_npy(self, points, frame_num): - """保存为numpy格式""" npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") try: - # 使用内存映射减少内存使用 memmap_array = np.lib.format.open_memmap( npy_path, mode='w+', @@ -292,23 +244,18 @@ def _save_as_npy(self, points, frame_num): memmap_array[:] = points[:] memmap_array.flush() except Exception as e: - print(f"保存NPY文件失败: {e}") - # 备选保存方式 try: np.save(npy_path, points) except Exception as e2: - print(f"备选保存NPY文件失败: {e2}") return None return npy_path def _save_as_v2xformer_format(self, points, frame_num): - """保存为V2XFormer兼容格式 - 优化点:减少保存频率""" v2x_dir = os.path.join(self.output_dir, "v2xformer_format") os.makedirs(v2x_dir, exist_ok=True) try: - # 创建V2XFormer格式的数据结构 v2x_data = { 'frame_id': frame_num, 'timestamp': datetime.now().timestamp(), @@ -327,21 +274,15 @@ def _save_as_v2xformer_format(self, points, frame_num): } } - # 保存为压缩的JSON格式 filename = f"{frame_num:06d}.pkl.gz" filepath = os.path.join(v2x_dir, filename) - # 使用pickle+gzip压缩保存 with gzip.open(filepath, 'wb') as f: pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) - file_size = os.path.getsize(filepath) / 1024 # KB - print(f"保存V2XFormer格式: {filepath} ({file_size:.2f} KB)") - return filepath except Exception as e: - print(f"警告: 保存V2XFormer格式失败: {e}") return None def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): @@ -375,21 +316,18 @@ def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): with open(meta_path, 'w') as f: json.dump(metadata, f, indent=2) except Exception as e: - print(f"保存LiDAR元数据失败: {e}") + pass return metadata def flush_batch(self): - """强制刷新批处理数据""" if self.point_cloud_batch: self._save_batch() def generate_lidar_summary(self): - """生成LiDAR数据摘要(优化版)""" if not os.path.exists(self.lidar_dir): return None - # 快速统计文件 import glob bin_files = glob.glob(os.path.join(self.lidar_dir, "*.bin")) npy_files = glob.glob(os.path.join(self.lidar_dir, "*.npy")) @@ -399,20 +337,17 @@ def generate_lidar_summary(self): total_points = 0 total_size = 0 - # 采样统计,避免读取所有文件 - sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files # 减少采样数量 + sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files for bin_file in sample_files: if os.path.exists(bin_file): try: file_size = os.path.getsize(bin_file) total_size += file_size - # 估算点数 - points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 + points_in_file = file_size // (4 * 4) total_points += points_in_file except: continue - # 根据采样估算总数 if sample_files and len(bin_files) > 0: avg_points_per_file = total_points / max(len(sample_files), 1) total_points_estimated = avg_points_per_file * len(bin_files) @@ -440,13 +375,12 @@ def generate_lidar_summary(self): with open(summary_path, 'w') as f: json.dump(summary, f, indent=2) except Exception as e: - print(f"保存LiDAR摘要失败: {e}") + pass return summary class MultiSensorFusion: - """多传感器融合(优化版)""" def __init__(self, output_dir, config=None): self.output_dir = output_dir @@ -454,8 +388,8 @@ def __init__(self, output_dir, config=None): os.makedirs(self.fusion_dir, exist_ok=True) self.calibration_data = {} - self.fusion_cache = {} # 融合缓存 - self.cache_size = config.get('fusion_cache_size', 50) if config else 50 # 减少缓存大小 + self.fusion_cache = {} + self.cache_size = config.get('fusion_cache_size', 50) if config else 50 self._load_calibration() @@ -463,48 +397,41 @@ def _load_calibration(self): calibration_dir = os.path.join(self.output_dir, "calibration") if os.path.exists(calibration_dir): - # 批量读取校准文件 calibration_files = [] for root, dirs, files in os.walk(calibration_dir): for file in files: if file.endswith('.json'): calibration_files.append(os.path.join(root, file)) - # 限制同时读取的文件数量 - for file in calibration_files[:10]: # 最多读取10个文件 + for file in calibration_files[:10]: try: with open(file, 'r') as f: data = json.load(f) sensor_name = os.path.basename(file).replace('.json', '') self.calibration_data[sensor_name] = data except Exception as e: - print(f"加载校准文件 {file} 失败: {e}") + pass def create_synchronization_file(self, frame_num, sensor_data): - """创建同步文件(优化版)""" - # 检查缓存 cache_key = f"{frame_num}_{hash(str(sensor_data))}" if cache_key in self.fusion_cache: return self.fusion_cache[cache_key] sync_data = { 'frame_id': frame_num, - 'timestamp': datetime.now().timestamp(), # 使用时间戳而不是ISO格式 + 'timestamp': datetime.now().timestamp(), 'sensors': {}, 'transformations': {} } - # 批量处理传感器数据 for sensor_type, data_path in sensor_data.items(): if data_path and os.path.exists(data_path): - # 获取文件信息(不加载完整文件) file_info = { 'file_path': os.path.basename(data_path), 'file_size': os.path.getsize(data_path), 'modified_time': os.path.getmtime(data_path) } - # 如果是图像,获取尺寸信息 if data_path.endswith(('.png', '.jpg', '.jpeg')): try: import cv2 @@ -516,7 +443,6 @@ def create_synchronization_file(self, frame_num, sensor_data): sync_data['sensors'][sensor_type] = file_info - # 添加变换信息(如果可用) if sensor_type in self.calibration_data: sync_data['transformations'][sensor_type] = { 'matrix': self.calibration_data[sensor_type].get('matrix', @@ -524,11 +450,9 @@ def create_synchronization_file(self, frame_num, sensor_data): [0, 0, 0, 1]]) } - # 压缩保存 sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") - # 使用压缩的JSON - if len(str(sync_data)) > 1000: # 如果数据较大,压缩保存 + if len(str(sync_data)) > 1000: compressed_data = zlib.compress( json.dumps(sync_data).encode('utf-8'), level=3 @@ -538,11 +462,9 @@ def create_synchronization_file(self, frame_num, sensor_data): f.write(compressed_data) else: with open(sync_file, 'w') as f: - json.dump(sync_data, f, separators=(',', ':')) # 紧凑格式 + json.dump(sync_data, f, separators=(',', ':')) - # 更新缓存 if len(self.fusion_cache) >= self.cache_size: - # 移除最旧的缓存项 oldest_key = next(iter(self.fusion_cache)) del self.fusion_cache[oldest_key] @@ -551,19 +473,15 @@ def create_synchronization_file(self, frame_num, sensor_data): return sync_file def generate_fusion_report(self): - """生成融合报告(优化版)""" if not os.path.exists(self.fusion_dir): return None - # 快速扫描文件 import glob sync_files = glob.glob(os.path.join(self.fusion_dir, "*.json*")) - # 解析文件名获取帧范围(避免读取所有文件) frame_ids = [] - for sync_file in sync_files[:20]: # 只检查前20个文件 + for sync_file in sync_files[:20]: try: - # 从文件名提取帧号 filename = os.path.basename(sync_file) if filename.startswith('sync_'): frame_id = int(filename.split('_')[1].split('.')[0]) From 1ab61961856f15627c413f96f87910ec1cc04995 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 14:04:33 +0800 Subject: [PATCH 13/21] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=BA=86=E6=80=A7?= =?UTF-8?q?=E8=83=BD=E7=9B=91=E6=8E=A7=E4=B8=AD=E7=9A=84=E5=B8=A7=E7=8E=87?= =?UTF-8?q?=E8=AE=A1=E7=AE=97=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/main.py | 135 ++++++++++++++++---------- 1 file changed, 82 insertions(+), 53 deletions(-) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 1331ff3b79..a506397e08 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -30,6 +30,8 @@ def __init__(self): self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] + self.first_frame_time = None + self.last_frame_time = None def sample_memory(self): try: @@ -72,14 +74,17 @@ def sample_cpu(self): def record_frame_time(self, frame_time): self.frame_times.append(frame_time) + if self.first_frame_time is None: + self.first_frame_time = time.time() + self.last_frame_time = time.time() def get_performance_summary(self): - if not self.frame_times: + if not self.frame_times or len(self.frame_times) < 2: avg_frame_time = 0 fps = 0 else: avg_frame_time = np.mean(self.frame_times) - fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0 + fps = len(self.frame_times) / max(0.1, (self.last_frame_time - self.first_frame_time)) summary = { 'total_runtime': time.time() - self.start_time, @@ -90,14 +95,24 @@ def get_performance_summary(self): 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, 'average_frame_time': avg_frame_time, 'frames_per_second': fps, - 'total_frames': len(self.frame_times), - 'frame_time_stats': { - 'p50': np.percentile(self.frame_times, 50) if self.frame_times else 0, - 'p95': np.percentile(self.frame_times, 95) if self.frame_times else 0, - 'p99': np.percentile(self.frame_times, 99) if self.frame_times else 0, - 'std': np.std(self.frame_times) if self.frame_times else 0 - } + 'total_frames': len(self.frame_times) } + + if self.frame_times and len(self.frame_times) >= 2: + summary['frame_time_stats'] = { + 'p50': np.percentile(self.frame_times, 50), + 'p95': np.percentile(self.frame_times, 95), + 'p99': np.percentile(self.frame_times, 99) if len(self.frame_times) > 1 else 0, + 'std': np.std(self.frame_times) + } + else: + summary['frame_time_stats'] = { + 'p50': 0, + 'p95': 0, + 'p99': 0, + 'std': 0 + } + return summary @@ -119,12 +134,12 @@ def error(msg): @staticmethod def debug(msg): - timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(f"[DEBUG][{timestamp}] {msg}") @staticmethod def performance(msg): - timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(f"[PERF][{timestamp}] {msg}") @@ -569,8 +584,7 @@ def __init__(self, world, config, data_dir): 'total_images': 0, 'total_lidar_frames': 0, 'image_capture_times': [], - 'lidar_processing_times': [], - 'frame_drop_count': 0 + 'lidar_processing_times': [] } def setup_cameras(self, vehicle, center_location, vehicle_id=0): @@ -868,7 +882,6 @@ def cleanup(self): self.is_running = False - Log.info("停止所有传感器监听...") for sensor in self.sensors: try: if hasattr(sensor, 'stop'): @@ -885,7 +898,6 @@ def cleanup(self): except: pass - Log.info(f"销毁 {len(self.sensors)} 个传感器...") for i, sensor in enumerate(self.sensors): try: if hasattr(sensor, 'destroy'): @@ -1105,17 +1117,15 @@ def collect_data(self): memory_warning_issued = False early_stop_triggered = False - # 添加内存监控阈值 - memory_warning_threshold = 350 # MB - memory_critical_threshold = 400 # MB - early_stop_threshold = 450 # MB + memory_warning_threshold = 350 + memory_critical_threshold = 400 + early_stop_threshold = 450 try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time - # 内存监控和早期停止机制 if current_time - last_memory_check >= 2.0: try: import psutil @@ -1204,16 +1214,21 @@ def collect_data(self): self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - performance_summary = self.performance_monitor.get_performance_summary() + if self.collected_frames > 0: + total_frames_from_sensors = self.collected_frames + performance_summary = self.performance_monitor.get_performance_summary() - if early_stop_triggered: - Log.warning("数据收集因内存过高而提前终止") - else: - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + if early_stop_triggered: + Log.warning("数据收集因内存过高而提前终止") + else: + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") - Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") - Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") - Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + fps = total_frames_from_sensors / max(elapsed, 0.1) + Log.info(f"平均帧率: {fps:.2f} FPS") + Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") + Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + else: + Log.warning("未收集到任何数据帧") self._save_metadata() self._print_summary() @@ -1478,6 +1493,8 @@ def _simulate_object_detection(self, vehicle): return detected_objects def _save_metadata(self): + total_frames = self.collected_frames + metadata = { 'scenario': self.config['scenario'], 'traffic': self.config['traffic'], @@ -1488,22 +1505,26 @@ def _save_metadata(self): 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), - 'total_frames': self.collected_frames, - 'frame_rate': round(self.collected_frames / max(time.time() - self.start_time, 0.1), 2) - }, - 'performance': self.performance_monitor.get_performance_summary() + 'total_frames': total_frames, + 'frame_rate': round(total_frames / max(time.time() - self.start_time, 0.1), + 2) if total_frames > 0 else 0 + } } - sensor_summaries = {} - for vehicle_id, sensor_manager in self.sensor_managers.items(): - sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() - metadata['sensor_summaries'] = sensor_summaries + if total_frames > 0: + performance_summary = self.performance_monitor.get_performance_summary() + metadata['performance'] = performance_summary - if self.v2x_communication: - metadata['v2x_status'] = self.v2x_communication.get_network_status() + sensor_summaries = {} + for vehicle_id, sensor_manager in self.sensor_managers.items(): + sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() + metadata['sensor_summaries'] = sensor_summaries - if self.multi_vehicle_manager: - metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() + if self.v2x_communication: + metadata['v2x_status'] = self.v2x_communication.get_network_status() + + if self.multi_vehicle_manager: + metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: @@ -1553,29 +1574,37 @@ def _print_summary(self): if os.path.exists(kitti_dir): print(f"KITTI格式: 已生成") - performance = self.performance_monitor.get_performance_summary() + total_frames = self.collected_frames + elapsed = time.time() - self.start_time + print(f"\n性能统计:") - print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") - print(f" 帧时统计:") - print(f" 平均: {performance['average_frame_time']:.3f}秒") - print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") - print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") - print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") - print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") - print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") - print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") - print(f" 总帧数: {performance['total_frames']}") + if total_frames > 0: + fps = total_frames / max(elapsed, 0.1) + print(f" 平均帧率: {fps:.2f} FPS") + + performance = self.performance_monitor.get_performance_summary() + print(f" 帧时统计:") + print(f" 平均: {performance['average_frame_time']:.3f}秒") + print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") + print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") + print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") + print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") + print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") + print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") + print(f" 总帧数: {total_frames}") + else: + print(" 未收集到有效帧数据") print(f"\n输出目录: {self.output_dir}") print("=" * 60) def run_validation(self): - if self.config['output'].get('validate_data', True): + if self.config['output'].get('validate_data', True) and self.collected_frames > 0: Log.info("运行数据验证...") DataValidator.validate_dataset(self.output_dir) def run_analysis(self): - if self.config['output'].get('run_analysis', False): + if self.config['output'].get('run_analysis', False) and self.collected_frames > 0: Log.info("运行数据分析...") DataAnalyzer.analyze_dataset(self.output_dir) From a716e9a6b0251ed15064eae407e87405b9d3680d Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 14:27:53 +0800 Subject: [PATCH 14/21] =?UTF-8?q?=E9=87=8D=E5=86=99readme=E6=96=87?= =?UTF-8?q?=E4=BB=B6=20=E4=BF=AE=E6=94=B9=E9=83=A8=E5=88=86=E4=BB=A3?= =?UTF-8?q?=E7=A0=81=20=E5=8E=BB=E9=99=A4=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/README.md | 59 ++++++++++++++++++++++++- 1 file changed, 58 insertions(+), 1 deletion(-) diff --git a/src/enhance_pedestrian_safety/README.md b/src/enhance_pedestrian_safety/README.md index 35411f1683..b0937dbb52 100644 --- a/src/enhance_pedestrian_safety/README.md +++ b/src/enhance_pedestrian_safety/README.md @@ -1,2 +1,59 @@ -数据图片请点击:通过网盘分享的文件:数据图片 +CVIPS - Cooperative Vehicle-Infrastructure Perception System + +基于CARLA仿真平台的多传感器协同感知数据采集系统,支持V2X通信、多车辆协同、数据增强与验证。 + +项目简介 + +CVIPS是一个用于自动驾驶研究的多传感器数据采集系统,在CARLA仿真环境中生成高质量的协同感知数据集。系统支持多车辆、多传感器协同工作,包含完整的V2X通信模拟、数据增强、验证和分析工具链。 + +核心功能 +1. 多传感器数据采集 + +摄像头系统 激光雷达 传感器融合 +2. 协同感知与V2X通信 + +多车辆协同 V2X消息系统 共享感知 +3. 智能交通场景生成 + +多样化场景 交通流控制 特殊事件 +4. 数据处理与增强 + +图像处理 LiDAR处理 数据增强 +5. 质量保证与验证 + +数据验证器 数据分析器 性能监控 +6. 多格式输出支持 + +标准格式 V2XFormer格式 KITTI格式 + +环境要求 + +Python 3.7 + +CARLA 0.9.14 + +内存:≥ 8GB(建议16GB) + +存储:≥ 50GB可用空间 + +安装步骤 +1. 克隆仓库 + +git clone https://github.com/Z-w-7799/nn.git +2. 安装依赖 + +pip install -r requirements.txt +3. 配置CARLA路径 + +方式1:设置环境变量 +export CARLA_PYTHON_PATH=/path/to/carla/PythonAPI/carla/dist + +方式2:使用命令行参数 +python main.py --carla-path /path/to/carla + +该项目已封装为 ROS 1 Kinetic 包,运行步骤:roscore → rosrun carla_sensor main.py + + +数据图片请点击: +通过网盘分享的文件:数据图片 链接: https://pan.baidu.com/s/1SMXdI7v09mhmYEW40bbAHQ?pwd=u6a4 提取码: u6a4 \ No newline at end of file From 27e134a14eb81db474a706b98daafb4eaeda2a4a Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 20:27:23 +0800 Subject: [PATCH 15/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=BA=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E8=A7=84=E8=8C=83=E7=9A=84markdown=20=E5=B9=B6?= =?UTF-8?q?=E5=8A=A0=E5=9B=9E=E5=8E=9F=E6=9C=AC=E5=BA=94=E8=AF=A5=E5=AD=98?= =?UTF-8?q?=E5=9C=A8=E7=9A=84=E6=B3=A8=E9=87=8A=E9=83=A8=E5=88=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/README.md | 99 ++++++++----- .../config_manager.py | 102 +++++++++++-- .../lidar_processor.py | 124 +++++++++++++--- src/enhance_pedestrian_safety/main.py | 135 +++++++----------- 4 files changed, 309 insertions(+), 151 deletions(-) diff --git a/src/enhance_pedestrian_safety/README.md b/src/enhance_pedestrian_safety/README.md index b0937dbb52..a4403a017d 100644 --- a/src/enhance_pedestrian_safety/README.md +++ b/src/enhance_pedestrian_safety/README.md @@ -1,59 +1,86 @@ -CVIPS - Cooperative Vehicle-Infrastructure Perception System +```markdown +# CVIPS - Cooperative Vehicle-Infrastructure Perception System 基于CARLA仿真平台的多传感器协同感知数据采集系统,支持V2X通信、多车辆协同、数据增强与验证。 -项目简介 -CVIPS是一个用于自动驾驶研究的多传感器数据采集系统,在CARLA仿真环境中生成高质量的协同感知数据集。系统支持多车辆、多传感器协同工作,包含完整的V2X通信模拟、数据增强、验证和分析工具链。 +## 项目简介 +CVIPS是一个用于自动驾驶研究的多传感器数据采集系统,在CARLA仿真环境中生成高质量的协同感知数据集。 +系统支持多车辆、多传感器协同工作,包含完整的V2X通信模拟、数据增强、验证和分析工具链。 -核心功能 -1. 多传感器数据采集 -摄像头系统 激光雷达 传感器融合 -2. 协同感知与V2X通信 +## 核心功能 +1. **多传感器数据采集** + - 摄像头系统 + - 激光雷达 + - 传感器融合 -多车辆协同 V2X消息系统 共享感知 -3. 智能交通场景生成 +2. **协同感知与V2X通信** + - 多车辆协同 + - V2X消息系统 + - 共享感知 -多样化场景 交通流控制 特殊事件 -4. 数据处理与增强 +3. **智能交通场景生成** + - 多样化场景 + - 交通流控制 + - 特殊事件 -图像处理 LiDAR处理 数据增强 -5. 质量保证与验证 +4. **数据处理与增强** + - 图像处理 + - LiDAR处理 + - 数据增强 -数据验证器 数据分析器 性能监控 -6. 多格式输出支持 +5. **质量保证与验证** + - 数据验证器 + - 数据分析器 + - 性能监控 -标准格式 V2XFormer格式 KITTI格式 +6. **多格式输出支持** + - 标准格式 + - V2XFormer格式 + - KITTI格式 -环境要求 -Python 3.7 +## 环境要求 +- Python 3.7 +- CARLA 0.9.14 +- 内存:≥ 8GB(建议16GB) +- 存储:≥ 50GB可用空间 -CARLA 0.9.14 -内存:≥ 8GB(建议16GB) +## 安装步骤 +1. **克隆仓库** + ```bash + git clone https://github.com/Z-w-7799/nn.git + ``` -存储:≥ 50GB可用空间 +2. **安装依赖** + ```bash + pip install -r requirements.txt + ``` -安装步骤 -1. 克隆仓库 +3. **配置CARLA路径** + - 方式1:设置环境变量 + ```bash + export CARLA_PYTHON_PATH=/path/to/carla/PythonAPI/carla/dist + ``` + - 方式2:使用命令行参数 + ```bash + python main.py --carla-path /path/to/carla + ``` -git clone https://github.com/Z-w-7799/nn.git -2. 安装依赖 -pip install -r requirements.txt -3. 配置CARLA路径 +## ROS 1 Kinetic封装运行步骤 +该项目已封装为ROS 1 Kinetic包,运行流程: +1. 启动ROS核心 + ```bash + roscore + ``` +2. 运行CVIPS节点 + ```bash + rosrun carla_sensor main.py + ``` -方式1:设置环境变量 -export CARLA_PYTHON_PATH=/path/to/carla/PythonAPI/carla/dist -方式2:使用命令行参数 -python main.py --carla-path /path/to/carla -该项目已封装为 ROS 1 Kinetic 包,运行步骤:roscore → rosrun carla_sensor main.py - -数据图片请点击: -通过网盘分享的文件:数据图片 -链接: https://pan.baidu.com/s/1SMXdI7v09mhmYEW40bbAHQ?pwd=u6a4 提取码: u6a4 \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index c608de6674..1f64c72ef9 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -4,24 +4,31 @@ import copy from typing import Dict, Any, Optional, List, Tuple +# 尝试导入yaml,如果不存在则跳过 try: import yaml + YAML_AVAILABLE = True except ImportError: YAML_AVAILABLE = False + print("警告: PyYAML未安装,将使用JSON格式") class ConfigValidator: + """配置验证器""" @staticmethod def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: + """验证配置的有效性""" errors = [] + # 验证必填字段 required_sections = ['scenario', 'sensors', 'output'] for section in required_sections: if section not in config: errors.append(f"缺失必要配置节: {section}") + # 验证场景配置 if 'scenario' in config: scenario = config['scenario'] if 'duration' in scenario and scenario['duration'] <= 0: @@ -29,6 +36,7 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: if 'town' not in scenario: errors.append("场景配置中缺失地图名称") + # 验证传感器配置 if 'sensors' in config: sensors = config['sensors'] if 'capture_interval' in sensors and sensors['capture_interval'] <= 0: @@ -39,6 +47,7 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: elif any(dim <= 0 for dim in sensors['image_size']): errors.append("图像尺寸必须大于0") + # 验证性能配置 if 'performance' in config: perf = config['performance'] if 'batch_size' in perf and perf['batch_size'] <= 0: @@ -48,18 +57,22 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: @staticmethod def suggest_optimizations(config: Dict[str, Any]) -> List[str]: + """根据配置提供优化建议""" suggestions = [] + # 内存使用建议 if config.get('sensors', {}).get('lidar_sensors', 0) > 0: lidar_config = config['sensors'].get('lidar_config', {}) max_points = lidar_config.get('max_points_per_frame', 50000) if max_points > 50000: suggestions.append(f"LiDAR最大点数({max_points})较高,建议降低到50000以下以减少内存使用") + # 性能建议 capture_interval = config['sensors'].get('capture_interval', 2.0) if capture_interval < 1.0: suggestions.append(f"采集间隔({capture_interval}s)较短,可能导致高负载,建议增加到1.0s以上") + # 输出建议 output = config.get('output', {}) enabled_outputs = [k for k, v in output.items() if isinstance(v, bool) and v] if len(enabled_outputs) > 5: @@ -69,11 +82,14 @@ def suggest_optimizations(config: Dict[str, Any]) -> List[str]: class ConfigOptimizer: + """配置优化器""" @staticmethod def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: + """为内存使用优化配置""" optimized = copy.deepcopy(config) + # 调整LiDAR设置 if optimized['sensors'].get('lidar_sensors', 0) > 0: lidar_config = optimized['sensors'].setdefault('lidar_config', {}) lidar_config.update({ @@ -83,6 +99,7 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'max_batch_memory_mb': 30 }) + # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 3, @@ -93,6 +110,7 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'frame_rate_limit': 3.0 }) + # 调整图像处理 perf['image_processing'] = { 'compress_images': True, 'compression_quality': 80, @@ -103,8 +121,10 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: + """为数据质量优化配置""" optimized = copy.deepcopy(config) + # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [1920, 1080], @@ -119,6 +139,7 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: } }) + # 调整输出设置 output = optimized['output'] output.update({ 'save_annotations': True, @@ -128,6 +149,7 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: 'run_quality_check': True }) + # 调整增强设置 enhanced = optimized.setdefault('enhancement', {}) enhanced.update({ 'enabled': True, @@ -140,31 +162,35 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: + """为处理速度优化配置""" optimized = copy.deepcopy(config) + # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [640, 480], 'capture_interval': 3.0, - 'lidar_sensors': 0, - 'radar_sensors': 0 + 'lidar_sensors': 0, # 禁用LiDAR + 'radar_sensors': 0 # 禁用雷达 }) + # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 10, 'enable_compression': True, - 'compression_level': 1, + 'compression_level': 1, # 快速压缩 'enable_downsampling': True, 'enable_async_processing': True, 'max_cache_size': 20, 'frame_rate_limit': 10.0 }) + # 简化输出 output = optimized['output'] output.update({ 'save_raw': True, - 'save_stitched': False, + 'save_stitched': False, # 不拼接图像 'save_annotations': False, 'save_lidar': False, 'save_fusion': False, @@ -175,7 +201,9 @@ def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: class ConfigManager: + """配置管理器(增强版)""" + # 预定义配置模板 PRESET_CONFIGS = { 'balanced': { 'description': '平衡配置 - 兼顾性能和质量', @@ -210,17 +238,31 @@ class ConfigManager: @staticmethod def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) -> Dict[str, Any]: + """ + 加载配置 + + Args: + config_file: 配置文件路径 + preset: 预设配置名称 + + Returns: + 配置字典 + """ + # 基础配置 config = ConfigManager._get_default_config() + # 应用预设配置 if preset: config = ConfigManager._apply_preset(config, preset) + # 加载用户配置文件 if config_file: if os.path.exists(config_file): config = ConfigManager._load_config_file(config_file, config) else: print(f"警告: 配置文件不存在: {config_file}") + # 验证配置 is_valid, errors = ConfigValidator.validate_config(config) if not is_valid: print("配置验证错误:") @@ -228,6 +270,7 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) print(f" - {error}") raise ValueError("配置验证失败") + # 提供优化建议 suggestions = ConfigValidator.suggest_optimizations(config) if suggestions: print("配置优化建议:") @@ -238,6 +281,7 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) @staticmethod def _get_default_config() -> Dict[str, Any]: + """获取默认配置(增强版)""" return { 'scenario': { 'name': 'multi_sensor_scene', @@ -247,8 +291,8 @@ def _get_default_config() -> Dict[str, Any]: 'time_of_day': 'noon', 'duration': 60, 'seed': 42, - 'timeout': 300, - 'retry_attempts': 3 + 'timeout': 300, # 超时时间(秒) + 'retry_attempts': 3 # 重试次数 }, 'traffic': { 'ego_vehicles': 1, @@ -292,7 +336,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 300, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_format': 'bin' + 'compression_format': 'bin' # bin, npy, pcd }, 'camera_config': { 'fov': 90.0, @@ -351,7 +395,7 @@ def _get_default_config() -> Dict[str, Any]: 'compression_quality': 85, 'resize_images': False, 'resize_dimensions': [640, 480], - 'format': 'jpg' + 'format': 'jpg' # jpg, png }, 'lidar_processing': { 'batch_size': 10, @@ -361,7 +405,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 350, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_method': 'zlib' + 'compression_method': 'zlib' # zlib, lz4, none }, 'fusion': { 'fusion_cache_size': 100, @@ -378,7 +422,7 @@ def _get_default_config() -> Dict[str, Any]: }, 'output': { 'data_dir': 'cvips_dataset', - 'output_format': 'standard', + 'output_format': 'standard', # standard, v2xformer, kitti, coco 'save_raw': True, 'save_stitched': True, 'save_annotations': False, @@ -392,12 +436,12 @@ def _get_default_config() -> Dict[str, Any]: 'run_quality_check': True, 'generate_summary': True, 'compression_enabled': True, - 'file_naming': 'sequential', + 'file_naming': 'sequential', # sequential, timestamp 'backup_original': False }, 'monitoring': { 'enable_logging': True, - 'log_level': 'INFO', + 'log_level': 'INFO', # DEBUG, INFO, WARNING, ERROR 'log_file': 'cvips.log', 'enable_performance_monitor': True, 'performance_log_interval': 10.0, @@ -424,6 +468,7 @@ def _get_default_config() -> Dict[str, Any]: @staticmethod def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: + """应用预设配置""" if preset_name not in ConfigManager.PRESET_CONFIGS: print(f"警告: 未知的预设配置: {preset_name}") return config @@ -431,6 +476,7 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: preset = ConfigManager.PRESET_CONFIGS[preset_name] print(f"应用预设配置: {preset_name} - {preset['description']}") + # 根据优化类型应用配置 optimization = preset.get('optimization', 'balanced') if optimization == 'memory': config = ConfigOptimizer.optimize_for_memory(config) @@ -445,6 +491,7 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: @staticmethod def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str, Any]: + """加载配置文件""" try: with open(config_file, 'r', encoding='utf-8') as f: if (config_file.endswith('.yaml') or config_file.endswith('.yml')) and YAML_AVAILABLE: @@ -461,6 +508,7 @@ def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str @staticmethod def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]: + """深度更新字典""" for key, value in update.items(): if key in original and isinstance(original[key], dict) and isinstance(value, dict): ConfigManager._deep_update(original[key], value) @@ -470,6 +518,8 @@ def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, @staticmethod def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]: + """合并命令行参数到配置""" + # 场景参数 if hasattr(args, 'scenario') and args.scenario: config['scenario']['name'] = args.scenario if hasattr(args, 'town') and args.town: @@ -483,45 +533,58 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if hasattr(args, 'seed') and args.seed: config['scenario']['seed'] = args.seed + # 交通参数 if hasattr(args, 'num_vehicles') and args.num_vehicles: config['traffic']['background_vehicles'] = args.num_vehicles if hasattr(args, 'num_pedestrians') and args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians + # 协同参数 if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles + # 传感器参数 if hasattr(args, 'capture_interval') and args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval + # V2X参数 if hasattr(args, 'enable_v2x'): config['v2x']['enabled'] = args.enable_v2x + # 增强参数 if hasattr(args, 'enable_enhancement'): config['enhancement']['enabled'] = args.enable_enhancement + # LiDAR参数 if hasattr(args, 'enable_lidar'): config['sensors']['lidar_sensors'] = 1 if args.enable_lidar else 0 config['output']['save_lidar'] = args.enable_lidar + # 融合参数 if hasattr(args, 'enable_fusion'): config['output']['save_fusion'] = args.enable_fusion + # 协同参数 if hasattr(args, 'enable_cooperative'): config['output']['save_cooperative'] = args.enable_cooperative + # 标注参数 if hasattr(args, 'enable_annotations'): config['output']['save_annotations'] = args.enable_annotations + # 验证参数 if hasattr(args, 'skip_validation'): config['output']['validate_data'] = not args.skip_validation + # 质量检查参数 if hasattr(args, 'skip_quality_check'): config['output']['run_quality_check'] = not args.skip_quality_check + # 分析参数 if hasattr(args, 'run_analysis'): config['output']['run_analysis'] = args.run_analysis + # 性能参数 if hasattr(args, 'batch_size') and args.batch_size: config['performance']['batch_size'] = args.batch_size @@ -533,6 +596,7 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if args.enable_downsampling: config['sensors']['lidar_config']['downsample_ratio'] = 0.3 + # 输出格式 if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format @@ -540,6 +604,7 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An @staticmethod def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): + """保存配置到文件""" try: os.makedirs(os.path.dirname(output_path), exist_ok=True) @@ -558,6 +623,7 @@ def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): @staticmethod def generate_config_template(output_path: str, preset: Optional[str] = None): + """生成配置模板""" config = ConfigManager.load_config(preset=preset) config['metadata']['created'] = 'template' config['metadata']['description'] = f'配置模板 - {preset if preset else "通用"}' @@ -566,10 +632,12 @@ def generate_config_template(output_path: str, preset: Optional[str] = None): @staticmethod def print_config_summary(config: Dict[str, Any]): + """打印配置摘要""" print("\n" + "=" * 60) print("配置摘要") print("=" * 60) + # 场景信息 scenario = config['scenario'] print(f"\n📋 场景:") print(f" 名称: {scenario['name']}") @@ -578,6 +646,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 时长: {scenario['duration']}秒") print(f" 随机种子: {scenario.get('seed', '随机')}") + # 交通信息 traffic = config['traffic'] print(f"\n🚗 交通:") print(f" 主车: {traffic['ego_vehicles']}") @@ -585,6 +654,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 行人: {traffic['pedestrians']}") print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") + # 传感器信息 sensors = config['sensors'] print(f"\n📷 传感器:") print(f" 车辆摄像头: {sensors['vehicle_cameras']}") @@ -593,6 +663,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 采集间隔: {sensors['capture_interval']}秒") print(f" 图像尺寸: {sensors['image_size'][0]}x{sensors['image_size'][1]}") + # V2X信息 v2x = config['v2x'] print(f"\n📡 V2X通信:") print(f" 状态: {'启用' if v2x['enabled'] else '禁用'}") @@ -600,12 +671,14 @@ def print_config_summary(config: Dict[str, Any]): print(f" 通信范围: {v2x['communication_range']}米") print(f" 更新间隔: {v2x['update_interval']}秒") + # 协同信息 coop = config['cooperative'] print(f"\n🤝 协同感知:") print(f" 协同车辆: {coop['num_coop_vehicles']}") print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") print(f" 交通警告: {'启用' if coop['enable_traffic_warnings'] else '禁用'}") + # 性能信息 perf = config['performance'] print(f"\n⚡ 性能:") print(f" 批处理大小: {perf['batch_size']}") @@ -613,6 +686,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") print(f" 帧率限制: {perf['frame_rate_limit']} FPS") + # 输出信息 output = config['output'] print(f"\n💾 输出:") print(f" 输出目录: {output['data_dir']}") @@ -625,6 +699,7 @@ def print_config_summary(config: Dict[str, Any]): @staticmethod def list_presets(): + """列出所有预设配置""" print("\n可用预设配置:") print("-" * 40) for name, preset in ConfigManager.PRESET_CONFIGS.items(): @@ -632,9 +707,12 @@ def list_presets(): print("-" * 40) +# 兼容旧版本的接口 def load_config(config_file=None): + """兼容旧版本的加载配置函数""" return ConfigManager.load_config(config_file) def merge_args(config, args): + """兼容旧版本的合并参数函数""" return ConfigManager.merge_args(config, args) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index 8c0f6ebb20..654aa674b8 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -23,18 +23,21 @@ def __init__(self, output_dir, config=None): self.frame_counter = 0 self.data_lock = threading.Lock() + # 性能优化:批量处理设置 self.batch_size = config.get('batch_size', 10) if config else 10 self.point_cloud_batch = [] self.enable_compression = config.get('enable_compression', True) if config else True self.compression_level = config.get('compression_level', 3) if config else 3 - self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 + # 内存管理 - 优化点3:更保守的内存设置 + self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 # 减少到5万点 self.enable_downsampling = config.get('enable_downsampling', True) if config else True - self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 + self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 # 增加下采样比例 - self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 - self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 - self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 + # 新增:内存监控和限制 + self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 # MB + self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 # 批次最大内存 + self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 # 每5帧保存一次V2X格式 self._init_calibration_files() @@ -78,81 +81,109 @@ def process_lidar_data(self, lidar_data, frame_num): points = self._carla_lidar_to_numpy(lidar_data) if points is None or points.shape[0] == 0: + print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") return None + # 检查内存使用情况 if self._check_memory_usage(): + print(f"警告: 内存使用过高,跳过LiDAR处理 (帧 {frame_num})") return None + # 下采样以减少内存使用 original_count = points.shape[0] if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: points = self._downsample_point_cloud(points) + print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") + # 检查批次内存使用 batch_memory_mb = self._estimate_batch_memory_mb() if batch_memory_mb > self.max_batch_memory_mb: + print(f"批处理内存过高 ({batch_memory_mb:.1f}MB),强制保存当前批次") self._save_batch() + # 添加到批处理 self.point_cloud_batch.append((frame_num, points)) + # 如果达到批处理大小,保存批处理数据 if len(self.point_cloud_batch) >= self.batch_size: self._save_batch() + # 保存单个文件(向后兼容) bin_path = self._save_as_bin(points, frame_num) npy_path = self._save_as_npy(points, frame_num) + # 生成V2XFormer兼容格式 - 优化点:每v2x_save_interval帧保存一次 v2xformer_path = None if frame_num % self.v2x_save_interval == 0: try: v2xformer_path = self._save_as_v2xformer_format(points, frame_num) except Exception as e: + print(f"警告: V2XFormer格式保存失败: {e}") v2xformer_path = None metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) + # 定期清理内存 if frame_num % 20 == 0: gc.collect() return metadata except Exception as e: + print(f"处理LiDAR数据失败: {e}") + # 强制清理内存 gc.collect() return None def _carla_lidar_to_numpy(self, lidar_data): + """高效转换LiDAR数据""" try: + # 使用内存视图减少内存分配 points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) points = np.reshape(points, (int(points.shape[0] / 4), 4)) + + # 只保留位置信息(x, y, z),忽略强度 points = points[:, :3] + # 清理临时数组 del lidar_data gc.collect() return points except Exception as e: + print(f"LiDAR数据转换失败: {e}") + + # 备选转换方法 try: points = [] for i in range(0, len(lidar_data), 4): point = lidar_data[i:i + 4] points.append([point.x, point.y, point.z]) + return np.array(points, dtype=np.float32) except: return None def _downsample_point_cloud(self, points): + """下采样点云以减少内存使用""" if points.shape[0] <= self.max_points_per_frame: return points + # 随机下采样 indices = np.random.choice(points.shape[0], int(points.shape[0] * self.downsample_ratio), replace=False) downsampled = points[indices] + # 清理内存 del points gc.collect() return downsampled def _estimate_batch_memory_mb(self): + """估计批处理内存使用""" if not self.point_cloud_batch: return 0 @@ -160,38 +191,45 @@ def _estimate_batch_memory_mb(self): for _, points in self.point_cloud_batch: total_points += points.shape[0] - memory_bytes = total_points * 12 * 1.2 + # 每个点3个float32 (12字节),加上一些额外开销 + memory_bytes = total_points * 12 * 1.2 # 20%额外开销 return memory_bytes / (1024 * 1024) def _check_memory_usage(self): + """检查内存使用情况""" try: import psutil process = psutil.Process() memory_mb = process.memory_info().rss / (1024 * 1024) if memory_mb > self.memory_warning_threshold: + print(f"警告: 进程内存使用过高: {memory_mb:.1f}MB") return True return False except: return False def _save_batch(self): + """批量保存点云数据(提高效率)""" if not self.point_cloud_batch: return batch_data = [] for frame_num, points in self.point_cloud_batch: + # 只保存点的坐标,不保存完整对象 batch_data.append({ 'frame_num': frame_num, 'points': points.tolist(), 'num_points': points.shape[0] }) + # 生成批处理文件名 min_frame = min([item[0] for item in self.point_cloud_batch]) max_frame = max([item[0] for item in self.point_cloud_batch]) batch_filename = f"lidar_batch_{min_frame:06d}_{max_frame:06d}.json" batch_path = os.path.join(self.lidar_dir, batch_filename) + # 压缩保存 if self.enable_compression: try: json_str = json.dumps(batch_data) @@ -202,39 +240,49 @@ def _save_batch(self): with open(batch_path, 'wb') as f: f.write(compressed_data) except Exception as e: + print(f"压缩保存批处理数据失败: {e}") + # 尝试非压缩保存 try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e2: - pass + print(f"非压缩保存批处理数据失败: {e2}") else: try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e: - pass + print(f"保存批处理数据失败: {e}") + # 清理批处理缓存 self.point_cloud_batch.clear() gc.collect() + print(f"批量保存LiDAR数据: {batch_filename}") + def _save_as_bin(self, points, frame_num): + """保存为二进制格式(兼容KITTI)""" bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") + # 添加强度信息(全为1) points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) points_with_intensity[:, :3] = points - points_with_intensity[:, 3] = 1.0 + points_with_intensity[:, 3] = 1.0 # 强度值 try: points_with_intensity.tofile(bin_path) except Exception as e: + print(f"保存BIN文件失败: {e}") return None return bin_path def _save_as_npy(self, points, frame_num): + """保存为numpy格式""" npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") try: + # 使用内存映射减少内存使用 memmap_array = np.lib.format.open_memmap( npy_path, mode='w+', @@ -244,18 +292,23 @@ def _save_as_npy(self, points, frame_num): memmap_array[:] = points[:] memmap_array.flush() except Exception as e: + print(f"保存NPY文件失败: {e}") + # 备选保存方式 try: np.save(npy_path, points) except Exception as e2: + print(f"备选保存NPY文件失败: {e2}") return None return npy_path def _save_as_v2xformer_format(self, points, frame_num): + """保存为V2XFormer兼容格式 - 优化点:减少保存频率""" v2x_dir = os.path.join(self.output_dir, "v2xformer_format") os.makedirs(v2x_dir, exist_ok=True) try: + # 创建V2XFormer格式的数据结构 v2x_data = { 'frame_id': frame_num, 'timestamp': datetime.now().timestamp(), @@ -274,15 +327,21 @@ def _save_as_v2xformer_format(self, points, frame_num): } } + # 保存为压缩的JSON格式 filename = f"{frame_num:06d}.pkl.gz" filepath = os.path.join(v2x_dir, filename) + # 使用pickle+gzip压缩保存 with gzip.open(filepath, 'wb') as f: pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) + file_size = os.path.getsize(filepath) / 1024 # KB + print(f"保存V2XFormer格式: {filepath} ({file_size:.2f} KB)") + return filepath except Exception as e: + print(f"警告: 保存V2XFormer格式失败: {e}") return None def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): @@ -316,18 +375,21 @@ def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): with open(meta_path, 'w') as f: json.dump(metadata, f, indent=2) except Exception as e: - pass + print(f"保存LiDAR元数据失败: {e}") return metadata def flush_batch(self): + """强制刷新批处理数据""" if self.point_cloud_batch: self._save_batch() def generate_lidar_summary(self): + """生成LiDAR数据摘要(优化版)""" if not os.path.exists(self.lidar_dir): return None + # 快速统计文件 import glob bin_files = glob.glob(os.path.join(self.lidar_dir, "*.bin")) npy_files = glob.glob(os.path.join(self.lidar_dir, "*.npy")) @@ -337,17 +399,20 @@ def generate_lidar_summary(self): total_points = 0 total_size = 0 - sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files + # 采样统计,避免读取所有文件 + sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files # 减少采样数量 for bin_file in sample_files: if os.path.exists(bin_file): try: file_size = os.path.getsize(bin_file) total_size += file_size - points_in_file = file_size // (4 * 4) + # 估算点数 + points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 total_points += points_in_file except: continue + # 根据采样估算总数 if sample_files and len(bin_files) > 0: avg_points_per_file = total_points / max(len(sample_files), 1) total_points_estimated = avg_points_per_file * len(bin_files) @@ -375,12 +440,13 @@ def generate_lidar_summary(self): with open(summary_path, 'w') as f: json.dump(summary, f, indent=2) except Exception as e: - pass + print(f"保存LiDAR摘要失败: {e}") return summary class MultiSensorFusion: + """多传感器融合(优化版)""" def __init__(self, output_dir, config=None): self.output_dir = output_dir @@ -388,8 +454,8 @@ def __init__(self, output_dir, config=None): os.makedirs(self.fusion_dir, exist_ok=True) self.calibration_data = {} - self.fusion_cache = {} - self.cache_size = config.get('fusion_cache_size', 50) if config else 50 + self.fusion_cache = {} # 融合缓存 + self.cache_size = config.get('fusion_cache_size', 50) if config else 50 # 减少缓存大小 self._load_calibration() @@ -397,41 +463,48 @@ def _load_calibration(self): calibration_dir = os.path.join(self.output_dir, "calibration") if os.path.exists(calibration_dir): + # 批量读取校准文件 calibration_files = [] for root, dirs, files in os.walk(calibration_dir): for file in files: if file.endswith('.json'): calibration_files.append(os.path.join(root, file)) - for file in calibration_files[:10]: + # 限制同时读取的文件数量 + for file in calibration_files[:10]: # 最多读取10个文件 try: with open(file, 'r') as f: data = json.load(f) sensor_name = os.path.basename(file).replace('.json', '') self.calibration_data[sensor_name] = data except Exception as e: - pass + print(f"加载校准文件 {file} 失败: {e}") def create_synchronization_file(self, frame_num, sensor_data): + """创建同步文件(优化版)""" + # 检查缓存 cache_key = f"{frame_num}_{hash(str(sensor_data))}" if cache_key in self.fusion_cache: return self.fusion_cache[cache_key] sync_data = { 'frame_id': frame_num, - 'timestamp': datetime.now().timestamp(), + 'timestamp': datetime.now().timestamp(), # 使用时间戳而不是ISO格式 'sensors': {}, 'transformations': {} } + # 批量处理传感器数据 for sensor_type, data_path in sensor_data.items(): if data_path and os.path.exists(data_path): + # 获取文件信息(不加载完整文件) file_info = { 'file_path': os.path.basename(data_path), 'file_size': os.path.getsize(data_path), 'modified_time': os.path.getmtime(data_path) } + # 如果是图像,获取尺寸信息 if data_path.endswith(('.png', '.jpg', '.jpeg')): try: import cv2 @@ -443,6 +516,7 @@ def create_synchronization_file(self, frame_num, sensor_data): sync_data['sensors'][sensor_type] = file_info + # 添加变换信息(如果可用) if sensor_type in self.calibration_data: sync_data['transformations'][sensor_type] = { 'matrix': self.calibration_data[sensor_type].get('matrix', @@ -450,9 +524,11 @@ def create_synchronization_file(self, frame_num, sensor_data): [0, 0, 0, 1]]) } + # 压缩保存 sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") - if len(str(sync_data)) > 1000: + # 使用压缩的JSON + if len(str(sync_data)) > 1000: # 如果数据较大,压缩保存 compressed_data = zlib.compress( json.dumps(sync_data).encode('utf-8'), level=3 @@ -462,9 +538,11 @@ def create_synchronization_file(self, frame_num, sensor_data): f.write(compressed_data) else: with open(sync_file, 'w') as f: - json.dump(sync_data, f, separators=(',', ':')) + json.dump(sync_data, f, separators=(',', ':')) # 紧凑格式 + # 更新缓存 if len(self.fusion_cache) >= self.cache_size: + # 移除最旧的缓存项 oldest_key = next(iter(self.fusion_cache)) del self.fusion_cache[oldest_key] @@ -473,15 +551,19 @@ def create_synchronization_file(self, frame_num, sensor_data): return sync_file def generate_fusion_report(self): + """生成融合报告(优化版)""" if not os.path.exists(self.fusion_dir): return None + # 快速扫描文件 import glob sync_files = glob.glob(os.path.join(self.fusion_dir, "*.json*")) + # 解析文件名获取帧范围(避免读取所有文件) frame_ids = [] - for sync_file in sync_files[:20]: + for sync_file in sync_files[:20]: # 只检查前20个文件 try: + # 从文件名提取帧号 filename = os.path.basename(sync_file) if filename.startswith('sync_'): frame_id = int(filename.split('_')[1].split('.')[0]) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index a506397e08..1331ff3b79 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -30,8 +30,6 @@ def __init__(self): self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] - self.first_frame_time = None - self.last_frame_time = None def sample_memory(self): try: @@ -74,17 +72,14 @@ def sample_cpu(self): def record_frame_time(self, frame_time): self.frame_times.append(frame_time) - if self.first_frame_time is None: - self.first_frame_time = time.time() - self.last_frame_time = time.time() def get_performance_summary(self): - if not self.frame_times or len(self.frame_times) < 2: + if not self.frame_times: avg_frame_time = 0 fps = 0 else: avg_frame_time = np.mean(self.frame_times) - fps = len(self.frame_times) / max(0.1, (self.last_frame_time - self.first_frame_time)) + fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0 summary = { 'total_runtime': time.time() - self.start_time, @@ -95,24 +90,14 @@ def get_performance_summary(self): 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, 'average_frame_time': avg_frame_time, 'frames_per_second': fps, - 'total_frames': len(self.frame_times) - } - - if self.frame_times and len(self.frame_times) >= 2: - summary['frame_time_stats'] = { - 'p50': np.percentile(self.frame_times, 50), - 'p95': np.percentile(self.frame_times, 95), - 'p99': np.percentile(self.frame_times, 99) if len(self.frame_times) > 1 else 0, - 'std': np.std(self.frame_times) - } - else: - summary['frame_time_stats'] = { - 'p50': 0, - 'p95': 0, - 'p99': 0, - 'std': 0 + 'total_frames': len(self.frame_times), + 'frame_time_stats': { + 'p50': np.percentile(self.frame_times, 50) if self.frame_times else 0, + 'p95': np.percentile(self.frame_times, 95) if self.frame_times else 0, + 'p99': np.percentile(self.frame_times, 99) if self.frame_times else 0, + 'std': np.std(self.frame_times) if self.frame_times else 0 } - + } return summary @@ -134,12 +119,12 @@ def error(msg): @staticmethod def debug(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") print(f"[DEBUG][{timestamp}] {msg}") @staticmethod def performance(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") print(f"[PERF][{timestamp}] {msg}") @@ -584,7 +569,8 @@ def __init__(self, world, config, data_dir): 'total_images': 0, 'total_lidar_frames': 0, 'image_capture_times': [], - 'lidar_processing_times': [] + 'lidar_processing_times': [], + 'frame_drop_count': 0 } def setup_cameras(self, vehicle, center_location, vehicle_id=0): @@ -882,6 +868,7 @@ def cleanup(self): self.is_running = False + Log.info("停止所有传感器监听...") for sensor in self.sensors: try: if hasattr(sensor, 'stop'): @@ -898,6 +885,7 @@ def cleanup(self): except: pass + Log.info(f"销毁 {len(self.sensors)} 个传感器...") for i, sensor in enumerate(self.sensors): try: if hasattr(sensor, 'destroy'): @@ -1117,15 +1105,17 @@ def collect_data(self): memory_warning_issued = False early_stop_triggered = False - memory_warning_threshold = 350 - memory_critical_threshold = 400 - early_stop_threshold = 450 + # 添加内存监控阈值 + memory_warning_threshold = 350 # MB + memory_critical_threshold = 400 # MB + early_stop_threshold = 450 # MB try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time + # 内存监控和早期停止机制 if current_time - last_memory_check >= 2.0: try: import psutil @@ -1214,21 +1204,16 @@ def collect_data(self): self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - if self.collected_frames > 0: - total_frames_from_sensors = self.collected_frames - performance_summary = self.performance_monitor.get_performance_summary() - - if early_stop_triggered: - Log.warning("数据收集因内存过高而提前终止") - else: - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + performance_summary = self.performance_monitor.get_performance_summary() - fps = total_frames_from_sensors / max(elapsed, 0.1) - Log.info(f"平均帧率: {fps:.2f} FPS") - Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") - Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + if early_stop_triggered: + Log.warning("数据收集因内存过高而提前终止") else: - Log.warning("未收集到任何数据帧") + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + + Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") + Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") + Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") self._save_metadata() self._print_summary() @@ -1493,8 +1478,6 @@ def _simulate_object_detection(self, vehicle): return detected_objects def _save_metadata(self): - total_frames = self.collected_frames - metadata = { 'scenario': self.config['scenario'], 'traffic': self.config['traffic'], @@ -1505,26 +1488,22 @@ def _save_metadata(self): 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), - 'total_frames': total_frames, - 'frame_rate': round(total_frames / max(time.time() - self.start_time, 0.1), - 2) if total_frames > 0 else 0 - } + 'total_frames': self.collected_frames, + 'frame_rate': round(self.collected_frames / max(time.time() - self.start_time, 0.1), 2) + }, + 'performance': self.performance_monitor.get_performance_summary() } - if total_frames > 0: - performance_summary = self.performance_monitor.get_performance_summary() - metadata['performance'] = performance_summary - - sensor_summaries = {} - for vehicle_id, sensor_manager in self.sensor_managers.items(): - sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() - metadata['sensor_summaries'] = sensor_summaries + sensor_summaries = {} + for vehicle_id, sensor_manager in self.sensor_managers.items(): + sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() + metadata['sensor_summaries'] = sensor_summaries - if self.v2x_communication: - metadata['v2x_status'] = self.v2x_communication.get_network_status() + if self.v2x_communication: + metadata['v2x_status'] = self.v2x_communication.get_network_status() - if self.multi_vehicle_manager: - metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() + if self.multi_vehicle_manager: + metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: @@ -1574,37 +1553,29 @@ def _print_summary(self): if os.path.exists(kitti_dir): print(f"KITTI格式: 已生成") - total_frames = self.collected_frames - elapsed = time.time() - self.start_time - + performance = self.performance_monitor.get_performance_summary() print(f"\n性能统计:") - if total_frames > 0: - fps = total_frames / max(elapsed, 0.1) - print(f" 平均帧率: {fps:.2f} FPS") - - performance = self.performance_monitor.get_performance_summary() - print(f" 帧时统计:") - print(f" 平均: {performance['average_frame_time']:.3f}秒") - print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") - print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") - print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") - print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") - print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") - print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") - print(f" 总帧数: {total_frames}") - else: - print(" 未收集到有效帧数据") + print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") + print(f" 帧时统计:") + print(f" 平均: {performance['average_frame_time']:.3f}秒") + print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") + print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") + print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") + print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") + print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") + print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") + print(f" 总帧数: {performance['total_frames']}") print(f"\n输出目录: {self.output_dir}") print("=" * 60) def run_validation(self): - if self.config['output'].get('validate_data', True) and self.collected_frames > 0: + if self.config['output'].get('validate_data', True): Log.info("运行数据验证...") DataValidator.validate_dataset(self.output_dir) def run_analysis(self): - if self.config['output'].get('run_analysis', False) and self.collected_frames > 0: + if self.config['output'].get('run_analysis', False): Log.info("运行数据分析...") DataAnalyzer.analyze_dataset(self.output_dir) From c340d1ae0e1f28d2f61c56eda94e4a014c81eae0 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 20:37:12 +0800 Subject: [PATCH 16/21] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=B8=BA=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E8=A7=84=E8=8C=83=E7=9A=84markdown?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/README.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/enhance_pedestrian_safety/README.md b/src/enhance_pedestrian_safety/README.md index a4403a017d..5904978a67 100644 --- a/src/enhance_pedestrian_safety/README.md +++ b/src/enhance_pedestrian_safety/README.md @@ -1,4 +1,3 @@ -```markdown # CVIPS - Cooperative Vehicle-Infrastructure Perception System 基于CARLA仿真平台的多传感器协同感知数据采集系统,支持V2X通信、多车辆协同、数据增强与验证。 @@ -48,6 +47,11 @@ CVIPS是一个用于自动驾驶研究的多传感器数据采集系统,在CAR - 存储:≥ 50GB可用空间 +## 安装步骤 +1. **克隆仓库** + ```bash + git clone https://github.com/Z-w-7799/nn.git + ## 安装步骤 1. **克隆仓库** ```bash From 576c7738cb76e4c1018867a9c8f33e3d0c58642b Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 21:45:31 +0800 Subject: [PATCH 17/21] =?UTF-8?q?add:=20ROS=E5=B0=81=E8=A3=85=E9=85=8D?= =?UTF-8?q?=E7=BD=AE=E6=96=87=E4=BB=B6=E5=92=8C=E4=BF=AE=E6=94=B9=E5=90=8E?= =?UTF-8?q?=E7=9A=84=E6=BA=90=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/CMakeLists.txt | 203 ++++++++++++++++++ .../config_manager.py | 102 ++------- .../lidar_processor.py | 124 ++--------- src/enhance_pedestrian_safety/main.py | 138 +++++++----- 4 files changed, 320 insertions(+), 247 deletions(-) create mode 100644 src/enhance_pedestrian_safety/CMakeLists.txt diff --git a/src/enhance_pedestrian_safety/CMakeLists.txt b/src/enhance_pedestrian_safety/CMakeLists.txt new file mode 100644 index 0000000000..2514048b61 --- /dev/null +++ b/src/enhance_pedestrian_safety/CMakeLists.txt @@ -0,0 +1,203 @@ +cmake_minimum_required(VERSION 2.8.3) +project(carla_sensor) + +## Compile as C++11, supported in ROS Kinetic and newer +# add_compile_options(-std=c++11) + +## Find catkin macros and libraries +## if COMPONENTS list like find_package(catkin REQUIRED COMPONENTS xyz) +## is used, also find other catkin packages +find_package(catkin REQUIRED COMPONENTS + cv_bridge + rospy + sensor_msgs + std_msgs +) + +## System dependencies are found with CMake's conventions +# find_package(Boost REQUIRED COMPONENTS system) + + +## Uncomment this if the package has a setup.py. This macro ensures +## modules and global scripts declared therein get installed +## See http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html +# catkin_python_setup() + +################################################ +## Declare ROS messages, services and actions ## +################################################ + +## To declare and build messages, services or actions from within this +## package, follow these steps: +## * Let MSG_DEP_SET be the set of packages whose message types you use in +## your messages/services/actions (e.g. std_msgs, actionlib_msgs, ...). +## * In the file package.xml: +## * add a build_depend tag for "message_generation" +## * add a build_depend and a exec_depend tag for each package in MSG_DEP_SET +## * If MSG_DEP_SET isn't empty the following dependency has been pulled in +## but can be declared for certainty nonetheless: +## * add a exec_depend tag for "message_runtime" +## * In this file (CMakeLists.txt): +## * add "message_generation" and every package in MSG_DEP_SET to +## find_package(catkin REQUIRED COMPONENTS ...) +## * add "message_runtime" and every package in MSG_DEP_SET to +## catkin_package(CATKIN_DEPENDS ...) +## * uncomment the add_*_files sections below as needed +## and list every .msg/.srv/.action file to be processed +## * uncomment the generate_messages entry below +## * add every package in MSG_DEP_SET to generate_messages(DEPENDENCIES ...) + +## Generate messages in the 'msg' folder +# add_message_files( +# FILES +# Message1.msg +# Message2.msg +# ) + +## Generate services in the 'srv' folder +# add_service_files( +# FILES +# Service1.srv +# Service2.srv +# ) + +## Generate actions in the 'action' folder +# add_action_files( +# FILES +# Action1.action +# Action2.action +# ) + +## Generate added messages and services with any dependencies listed here +# generate_messages( +# DEPENDENCIES +# sensor_msgs# std_msgs +# ) + +################################################ +## Declare ROS dynamic reconfigure parameters ## +################################################ + +## To declare and build dynamic reconfigure parameters within this +## package, follow these steps: +## * In the file package.xml: +## * add a build_depend and a exec_depend tag for "dynamic_reconfigure" +## * In this file (CMakeLists.txt): +## * add "dynamic_reconfigure" to +## find_package(catkin REQUIRED COMPONENTS ...) +## * uncomment the "generate_dynamic_reconfigure_options" section below +## and list every .cfg file to be processed + +## Generate dynamic reconfigure parameters in the 'cfg' folder +# generate_dynamic_reconfigure_options( +# cfg/DynReconf1.cfg +# cfg/DynReconf2.cfg +# ) + +################################### +## catkin specific configuration ## +################################### +## The catkin_package macro generates cmake config files for your package +## Declare things to be passed to dependent projects +## INCLUDE_DIRS: uncomment this if your package contains header files +## LIBRARIES: libraries you create in this project that dependent projects also need +## CATKIN_DEPENDS: catkin_packages dependent projects also need +## DEPENDS: system dependencies of this project that dependent projects also need +catkin_package( +# INCLUDE_DIRS include +# LIBRARIES carla_sensor +# CATKIN_DEPENDS cv_bridge rospy sensor_msgs std_msgs +# DEPENDS system_lib +) + +########### +## Build ## +########### + +## Specify additional locations of header files +## Your package locations should be listed before other locations +include_directories( +# include + ${catkin_INCLUDE_DIRS} +) + +## Declare a C++ library +# add_library(${PROJECT_NAME} +# src/${PROJECT_NAME}/carla_sensor.cpp +# ) + +## Add cmake target dependencies of the library +## as an example, code may need to be generated before libraries +## either from message generation or dynamic reconfigure +# add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) + +## Declare a C++ executable +## With catkin_make all packages are built within a single CMake context +## The recommended prefix ensures that target names across packages don't collide +# add_executable(${PROJECT_NAME}_node src/carla_sensor_node.cpp) + +## Rename C++ executable without prefix +## The above recommended prefix causes long target names, the following renames the +## target back to the shorter version for ease of user use +## e.g. "rosrun someones_pkg node" instead of "rosrun someones_pkg someones_pkg_node" +# set_target_properties(${PROJECT_NAME}_node PROPERTIES OUTPUT_NAME node PREFIX "") + +## Add cmake target dependencies of the executable +## same as for the library above +# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS}) + +## Specify libraries to link a library or executable target against +# target_link_libraries(${PROJECT_NAME}_node +# ${catkin_LIBRARIES} +# ) + +############# +## Install ## +############# + +# all install targets should use catkin DESTINATION variables +# See http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html + +## Mark executable scripts (Python etc.) for installation +## in contrast to setup.py, you can choose the destination +# install(PROGRAMS +# scripts/my_python_script +# DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +# ) + +## Mark executables and/or libraries for installation +# install(TARGETS ${PROJECT_NAME} ${PROJECT_NAME}_node +# ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION} +# RUNTIME DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +# ) + +## Mark cpp header files for installation +# install(DIRECTORY include/${PROJECT_NAME}/ +# DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION} +# FILES_MATCHING PATTERN "*.h" +# PATTERN ".svn" EXCLUDE +# ) + +## Mark other files for installation (e.g. launch and bag files, etc.) +# install(FILES +# # myfile1 +# # myfile2 +# DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION} +# ) + +############# +## Testing ## +############# + +## Add gtest based cpp test target and link libraries +# catkin_add_gtest(${PROJECT_NAME}-test test/test_carla_sensor.cpp) +# if(TARGET ${PROJECT_NAME}-test) +# target_link_libraries(${PROJECT_NAME}-test ${PROJECT_NAME}) +# endif() + +## Add folders to be run by python nosetests +# catkin_add_nosetests(test) +catkin_install_python(PROGRAMS main.py + DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} +) diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 1f64c72ef9..c608de6674 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -4,31 +4,24 @@ import copy from typing import Dict, Any, Optional, List, Tuple -# 尝试导入yaml,如果不存在则跳过 try: import yaml - YAML_AVAILABLE = True except ImportError: YAML_AVAILABLE = False - print("警告: PyYAML未安装,将使用JSON格式") class ConfigValidator: - """配置验证器""" @staticmethod def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: - """验证配置的有效性""" errors = [] - # 验证必填字段 required_sections = ['scenario', 'sensors', 'output'] for section in required_sections: if section not in config: errors.append(f"缺失必要配置节: {section}") - # 验证场景配置 if 'scenario' in config: scenario = config['scenario'] if 'duration' in scenario and scenario['duration'] <= 0: @@ -36,7 +29,6 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: if 'town' not in scenario: errors.append("场景配置中缺失地图名称") - # 验证传感器配置 if 'sensors' in config: sensors = config['sensors'] if 'capture_interval' in sensors and sensors['capture_interval'] <= 0: @@ -47,7 +39,6 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: elif any(dim <= 0 for dim in sensors['image_size']): errors.append("图像尺寸必须大于0") - # 验证性能配置 if 'performance' in config: perf = config['performance'] if 'batch_size' in perf and perf['batch_size'] <= 0: @@ -57,22 +48,18 @@ def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: @staticmethod def suggest_optimizations(config: Dict[str, Any]) -> List[str]: - """根据配置提供优化建议""" suggestions = [] - # 内存使用建议 if config.get('sensors', {}).get('lidar_sensors', 0) > 0: lidar_config = config['sensors'].get('lidar_config', {}) max_points = lidar_config.get('max_points_per_frame', 50000) if max_points > 50000: suggestions.append(f"LiDAR最大点数({max_points})较高,建议降低到50000以下以减少内存使用") - # 性能建议 capture_interval = config['sensors'].get('capture_interval', 2.0) if capture_interval < 1.0: suggestions.append(f"采集间隔({capture_interval}s)较短,可能导致高负载,建议增加到1.0s以上") - # 输出建议 output = config.get('output', {}) enabled_outputs = [k for k, v in output.items() if isinstance(v, bool) and v] if len(enabled_outputs) > 5: @@ -82,14 +69,11 @@ def suggest_optimizations(config: Dict[str, Any]) -> List[str]: class ConfigOptimizer: - """配置优化器""" @staticmethod def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: - """为内存使用优化配置""" optimized = copy.deepcopy(config) - # 调整LiDAR设置 if optimized['sensors'].get('lidar_sensors', 0) > 0: lidar_config = optimized['sensors'].setdefault('lidar_config', {}) lidar_config.update({ @@ -99,7 +83,6 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'max_batch_memory_mb': 30 }) - # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 3, @@ -110,7 +93,6 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: 'frame_rate_limit': 3.0 }) - # 调整图像处理 perf['image_processing'] = { 'compress_images': True, 'compression_quality': 80, @@ -121,10 +103,8 @@ def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: - """为数据质量优化配置""" optimized = copy.deepcopy(config) - # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [1920, 1080], @@ -139,7 +119,6 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: } }) - # 调整输出设置 output = optimized['output'] output.update({ 'save_annotations': True, @@ -149,7 +128,6 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: 'run_quality_check': True }) - # 调整增强设置 enhanced = optimized.setdefault('enhancement', {}) enhanced.update({ 'enabled': True, @@ -162,35 +140,31 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: @staticmethod def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: - """为处理速度优化配置""" optimized = copy.deepcopy(config) - # 调整传感器设置 sensors = optimized['sensors'] sensors.update({ 'image_size': [640, 480], 'capture_interval': 3.0, - 'lidar_sensors': 0, # 禁用LiDAR - 'radar_sensors': 0 # 禁用雷达 + 'lidar_sensors': 0, + 'radar_sensors': 0 }) - # 调整性能设置 perf = optimized.setdefault('performance', {}) perf.update({ 'batch_size': 10, 'enable_compression': True, - 'compression_level': 1, # 快速压缩 + 'compression_level': 1, 'enable_downsampling': True, 'enable_async_processing': True, 'max_cache_size': 20, 'frame_rate_limit': 10.0 }) - # 简化输出 output = optimized['output'] output.update({ 'save_raw': True, - 'save_stitched': False, # 不拼接图像 + 'save_stitched': False, 'save_annotations': False, 'save_lidar': False, 'save_fusion': False, @@ -201,9 +175,7 @@ def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: class ConfigManager: - """配置管理器(增强版)""" - # 预定义配置模板 PRESET_CONFIGS = { 'balanced': { 'description': '平衡配置 - 兼顾性能和质量', @@ -238,31 +210,17 @@ class ConfigManager: @staticmethod def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) -> Dict[str, Any]: - """ - 加载配置 - - Args: - config_file: 配置文件路径 - preset: 预设配置名称 - - Returns: - 配置字典 - """ - # 基础配置 config = ConfigManager._get_default_config() - # 应用预设配置 if preset: config = ConfigManager._apply_preset(config, preset) - # 加载用户配置文件 if config_file: if os.path.exists(config_file): config = ConfigManager._load_config_file(config_file, config) else: print(f"警告: 配置文件不存在: {config_file}") - # 验证配置 is_valid, errors = ConfigValidator.validate_config(config) if not is_valid: print("配置验证错误:") @@ -270,7 +228,6 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) print(f" - {error}") raise ValueError("配置验证失败") - # 提供优化建议 suggestions = ConfigValidator.suggest_optimizations(config) if suggestions: print("配置优化建议:") @@ -281,7 +238,6 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) @staticmethod def _get_default_config() -> Dict[str, Any]: - """获取默认配置(增强版)""" return { 'scenario': { 'name': 'multi_sensor_scene', @@ -291,8 +247,8 @@ def _get_default_config() -> Dict[str, Any]: 'time_of_day': 'noon', 'duration': 60, 'seed': 42, - 'timeout': 300, # 超时时间(秒) - 'retry_attempts': 3 # 重试次数 + 'timeout': 300, + 'retry_attempts': 3 }, 'traffic': { 'ego_vehicles': 1, @@ -336,7 +292,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 300, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_format': 'bin' # bin, npy, pcd + 'compression_format': 'bin' }, 'camera_config': { 'fov': 90.0, @@ -395,7 +351,7 @@ def _get_default_config() -> Dict[str, Any]: 'compression_quality': 85, 'resize_images': False, 'resize_dimensions': [640, 480], - 'format': 'jpg' # jpg, png + 'format': 'jpg' }, 'lidar_processing': { 'batch_size': 10, @@ -405,7 +361,7 @@ def _get_default_config() -> Dict[str, Any]: 'memory_warning_threshold': 350, 'max_batch_memory_mb': 50, 'v2x_save_interval': 5, - 'compression_method': 'zlib' # zlib, lz4, none + 'compression_method': 'zlib' }, 'fusion': { 'fusion_cache_size': 100, @@ -422,7 +378,7 @@ def _get_default_config() -> Dict[str, Any]: }, 'output': { 'data_dir': 'cvips_dataset', - 'output_format': 'standard', # standard, v2xformer, kitti, coco + 'output_format': 'standard', 'save_raw': True, 'save_stitched': True, 'save_annotations': False, @@ -436,12 +392,12 @@ def _get_default_config() -> Dict[str, Any]: 'run_quality_check': True, 'generate_summary': True, 'compression_enabled': True, - 'file_naming': 'sequential', # sequential, timestamp + 'file_naming': 'sequential', 'backup_original': False }, 'monitoring': { 'enable_logging': True, - 'log_level': 'INFO', # DEBUG, INFO, WARNING, ERROR + 'log_level': 'INFO', 'log_file': 'cvips.log', 'enable_performance_monitor': True, 'performance_log_interval': 10.0, @@ -468,7 +424,6 @@ def _get_default_config() -> Dict[str, Any]: @staticmethod def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: - """应用预设配置""" if preset_name not in ConfigManager.PRESET_CONFIGS: print(f"警告: 未知的预设配置: {preset_name}") return config @@ -476,7 +431,6 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: preset = ConfigManager.PRESET_CONFIGS[preset_name] print(f"应用预设配置: {preset_name} - {preset['description']}") - # 根据优化类型应用配置 optimization = preset.get('optimization', 'balanced') if optimization == 'memory': config = ConfigOptimizer.optimize_for_memory(config) @@ -491,7 +445,6 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: @staticmethod def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str, Any]: - """加载配置文件""" try: with open(config_file, 'r', encoding='utf-8') as f: if (config_file.endswith('.yaml') or config_file.endswith('.yml')) and YAML_AVAILABLE: @@ -508,7 +461,6 @@ def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str @staticmethod def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]: - """深度更新字典""" for key, value in update.items(): if key in original and isinstance(original[key], dict) and isinstance(value, dict): ConfigManager._deep_update(original[key], value) @@ -518,8 +470,6 @@ def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, @staticmethod def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]: - """合并命令行参数到配置""" - # 场景参数 if hasattr(args, 'scenario') and args.scenario: config['scenario']['name'] = args.scenario if hasattr(args, 'town') and args.town: @@ -533,58 +483,45 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if hasattr(args, 'seed') and args.seed: config['scenario']['seed'] = args.seed - # 交通参数 if hasattr(args, 'num_vehicles') and args.num_vehicles: config['traffic']['background_vehicles'] = args.num_vehicles if hasattr(args, 'num_pedestrians') and args.num_pedestrians: config['traffic']['pedestrians'] = args.num_pedestrians - # 协同参数 if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles - # 传感器参数 if hasattr(args, 'capture_interval') and args.capture_interval: config['sensors']['capture_interval'] = args.capture_interval - # V2X参数 if hasattr(args, 'enable_v2x'): config['v2x']['enabled'] = args.enable_v2x - # 增强参数 if hasattr(args, 'enable_enhancement'): config['enhancement']['enabled'] = args.enable_enhancement - # LiDAR参数 if hasattr(args, 'enable_lidar'): config['sensors']['lidar_sensors'] = 1 if args.enable_lidar else 0 config['output']['save_lidar'] = args.enable_lidar - # 融合参数 if hasattr(args, 'enable_fusion'): config['output']['save_fusion'] = args.enable_fusion - # 协同参数 if hasattr(args, 'enable_cooperative'): config['output']['save_cooperative'] = args.enable_cooperative - # 标注参数 if hasattr(args, 'enable_annotations'): config['output']['save_annotations'] = args.enable_annotations - # 验证参数 if hasattr(args, 'skip_validation'): config['output']['validate_data'] = not args.skip_validation - # 质量检查参数 if hasattr(args, 'skip_quality_check'): config['output']['run_quality_check'] = not args.skip_quality_check - # 分析参数 if hasattr(args, 'run_analysis'): config['output']['run_analysis'] = args.run_analysis - # 性能参数 if hasattr(args, 'batch_size') and args.batch_size: config['performance']['batch_size'] = args.batch_size @@ -596,7 +533,6 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if args.enable_downsampling: config['sensors']['lidar_config']['downsample_ratio'] = 0.3 - # 输出格式 if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format @@ -604,7 +540,6 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An @staticmethod def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): - """保存配置到文件""" try: os.makedirs(os.path.dirname(output_path), exist_ok=True) @@ -623,7 +558,6 @@ def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): @staticmethod def generate_config_template(output_path: str, preset: Optional[str] = None): - """生成配置模板""" config = ConfigManager.load_config(preset=preset) config['metadata']['created'] = 'template' config['metadata']['description'] = f'配置模板 - {preset if preset else "通用"}' @@ -632,12 +566,10 @@ def generate_config_template(output_path: str, preset: Optional[str] = None): @staticmethod def print_config_summary(config: Dict[str, Any]): - """打印配置摘要""" print("\n" + "=" * 60) print("配置摘要") print("=" * 60) - # 场景信息 scenario = config['scenario'] print(f"\n📋 场景:") print(f" 名称: {scenario['name']}") @@ -646,7 +578,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 时长: {scenario['duration']}秒") print(f" 随机种子: {scenario.get('seed', '随机')}") - # 交通信息 traffic = config['traffic'] print(f"\n🚗 交通:") print(f" 主车: {traffic['ego_vehicles']}") @@ -654,7 +585,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 行人: {traffic['pedestrians']}") print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") - # 传感器信息 sensors = config['sensors'] print(f"\n📷 传感器:") print(f" 车辆摄像头: {sensors['vehicle_cameras']}") @@ -663,7 +593,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 采集间隔: {sensors['capture_interval']}秒") print(f" 图像尺寸: {sensors['image_size'][0]}x{sensors['image_size'][1]}") - # V2X信息 v2x = config['v2x'] print(f"\n📡 V2X通信:") print(f" 状态: {'启用' if v2x['enabled'] else '禁用'}") @@ -671,14 +600,12 @@ def print_config_summary(config: Dict[str, Any]): print(f" 通信范围: {v2x['communication_range']}米") print(f" 更新间隔: {v2x['update_interval']}秒") - # 协同信息 coop = config['cooperative'] print(f"\n🤝 协同感知:") print(f" 协同车辆: {coop['num_coop_vehicles']}") print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") print(f" 交通警告: {'启用' if coop['enable_traffic_warnings'] else '禁用'}") - # 性能信息 perf = config['performance'] print(f"\n⚡ 性能:") print(f" 批处理大小: {perf['batch_size']}") @@ -686,7 +613,6 @@ def print_config_summary(config: Dict[str, Any]): print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") print(f" 帧率限制: {perf['frame_rate_limit']} FPS") - # 输出信息 output = config['output'] print(f"\n💾 输出:") print(f" 输出目录: {output['data_dir']}") @@ -699,7 +625,6 @@ def print_config_summary(config: Dict[str, Any]): @staticmethod def list_presets(): - """列出所有预设配置""" print("\n可用预设配置:") print("-" * 40) for name, preset in ConfigManager.PRESET_CONFIGS.items(): @@ -707,12 +632,9 @@ def list_presets(): print("-" * 40) -# 兼容旧版本的接口 def load_config(config_file=None): - """兼容旧版本的加载配置函数""" return ConfigManager.load_config(config_file) def merge_args(config, args): - """兼容旧版本的合并参数函数""" return ConfigManager.merge_args(config, args) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index 654aa674b8..8c0f6ebb20 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -23,21 +23,18 @@ def __init__(self, output_dir, config=None): self.frame_counter = 0 self.data_lock = threading.Lock() - # 性能优化:批量处理设置 self.batch_size = config.get('batch_size', 10) if config else 10 self.point_cloud_batch = [] self.enable_compression = config.get('enable_compression', True) if config else True self.compression_level = config.get('compression_level', 3) if config else 3 - # 内存管理 - 优化点3:更保守的内存设置 - self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 # 减少到5万点 + self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 self.enable_downsampling = config.get('enable_downsampling', True) if config else True - self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 # 增加下采样比例 + self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 - # 新增:内存监控和限制 - self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 # MB - self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 # 批次最大内存 - self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 # 每5帧保存一次V2X格式 + self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 + self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 + self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 self._init_calibration_files() @@ -81,109 +78,81 @@ def process_lidar_data(self, lidar_data, frame_num): points = self._carla_lidar_to_numpy(lidar_data) if points is None or points.shape[0] == 0: - print(f"警告: LiDAR数据为空或无效 (帧 {frame_num})") return None - # 检查内存使用情况 if self._check_memory_usage(): - print(f"警告: 内存使用过高,跳过LiDAR处理 (帧 {frame_num})") return None - # 下采样以减少内存使用 original_count = points.shape[0] if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: points = self._downsample_point_cloud(points) - print(f"LiDAR下采样: {original_count} -> {points.shape[0]} 点 (帧 {frame_num})") - # 检查批次内存使用 batch_memory_mb = self._estimate_batch_memory_mb() if batch_memory_mb > self.max_batch_memory_mb: - print(f"批处理内存过高 ({batch_memory_mb:.1f}MB),强制保存当前批次") self._save_batch() - # 添加到批处理 self.point_cloud_batch.append((frame_num, points)) - # 如果达到批处理大小,保存批处理数据 if len(self.point_cloud_batch) >= self.batch_size: self._save_batch() - # 保存单个文件(向后兼容) bin_path = self._save_as_bin(points, frame_num) npy_path = self._save_as_npy(points, frame_num) - # 生成V2XFormer兼容格式 - 优化点:每v2x_save_interval帧保存一次 v2xformer_path = None if frame_num % self.v2x_save_interval == 0: try: v2xformer_path = self._save_as_v2xformer_format(points, frame_num) except Exception as e: - print(f"警告: V2XFormer格式保存失败: {e}") v2xformer_path = None metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) - # 定期清理内存 if frame_num % 20 == 0: gc.collect() return metadata except Exception as e: - print(f"处理LiDAR数据失败: {e}") - # 强制清理内存 gc.collect() return None def _carla_lidar_to_numpy(self, lidar_data): - """高效转换LiDAR数据""" try: - # 使用内存视图减少内存分配 points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) points = np.reshape(points, (int(points.shape[0] / 4), 4)) - - # 只保留位置信息(x, y, z),忽略强度 points = points[:, :3] - # 清理临时数组 del lidar_data gc.collect() return points except Exception as e: - print(f"LiDAR数据转换失败: {e}") - - # 备选转换方法 try: points = [] for i in range(0, len(lidar_data), 4): point = lidar_data[i:i + 4] points.append([point.x, point.y, point.z]) - return np.array(points, dtype=np.float32) except: return None def _downsample_point_cloud(self, points): - """下采样点云以减少内存使用""" if points.shape[0] <= self.max_points_per_frame: return points - # 随机下采样 indices = np.random.choice(points.shape[0], int(points.shape[0] * self.downsample_ratio), replace=False) downsampled = points[indices] - # 清理内存 del points gc.collect() return downsampled def _estimate_batch_memory_mb(self): - """估计批处理内存使用""" if not self.point_cloud_batch: return 0 @@ -191,45 +160,38 @@ def _estimate_batch_memory_mb(self): for _, points in self.point_cloud_batch: total_points += points.shape[0] - # 每个点3个float32 (12字节),加上一些额外开销 - memory_bytes = total_points * 12 * 1.2 # 20%额外开销 + memory_bytes = total_points * 12 * 1.2 return memory_bytes / (1024 * 1024) def _check_memory_usage(self): - """检查内存使用情况""" try: import psutil process = psutil.Process() memory_mb = process.memory_info().rss / (1024 * 1024) if memory_mb > self.memory_warning_threshold: - print(f"警告: 进程内存使用过高: {memory_mb:.1f}MB") return True return False except: return False def _save_batch(self): - """批量保存点云数据(提高效率)""" if not self.point_cloud_batch: return batch_data = [] for frame_num, points in self.point_cloud_batch: - # 只保存点的坐标,不保存完整对象 batch_data.append({ 'frame_num': frame_num, 'points': points.tolist(), 'num_points': points.shape[0] }) - # 生成批处理文件名 min_frame = min([item[0] for item in self.point_cloud_batch]) max_frame = max([item[0] for item in self.point_cloud_batch]) batch_filename = f"lidar_batch_{min_frame:06d}_{max_frame:06d}.json" batch_path = os.path.join(self.lidar_dir, batch_filename) - # 压缩保存 if self.enable_compression: try: json_str = json.dumps(batch_data) @@ -240,49 +202,39 @@ def _save_batch(self): with open(batch_path, 'wb') as f: f.write(compressed_data) except Exception as e: - print(f"压缩保存批处理数据失败: {e}") - # 尝试非压缩保存 try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e2: - print(f"非压缩保存批处理数据失败: {e2}") + pass else: try: with open(batch_path, 'w') as f: json.dump(batch_data, f) except Exception as e: - print(f"保存批处理数据失败: {e}") + pass - # 清理批处理缓存 self.point_cloud_batch.clear() gc.collect() - print(f"批量保存LiDAR数据: {batch_filename}") - def _save_as_bin(self, points, frame_num): - """保存为二进制格式(兼容KITTI)""" bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") - # 添加强度信息(全为1) points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) points_with_intensity[:, :3] = points - points_with_intensity[:, 3] = 1.0 # 强度值 + points_with_intensity[:, 3] = 1.0 try: points_with_intensity.tofile(bin_path) except Exception as e: - print(f"保存BIN文件失败: {e}") return None return bin_path def _save_as_npy(self, points, frame_num): - """保存为numpy格式""" npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") try: - # 使用内存映射减少内存使用 memmap_array = np.lib.format.open_memmap( npy_path, mode='w+', @@ -292,23 +244,18 @@ def _save_as_npy(self, points, frame_num): memmap_array[:] = points[:] memmap_array.flush() except Exception as e: - print(f"保存NPY文件失败: {e}") - # 备选保存方式 try: np.save(npy_path, points) except Exception as e2: - print(f"备选保存NPY文件失败: {e2}") return None return npy_path def _save_as_v2xformer_format(self, points, frame_num): - """保存为V2XFormer兼容格式 - 优化点:减少保存频率""" v2x_dir = os.path.join(self.output_dir, "v2xformer_format") os.makedirs(v2x_dir, exist_ok=True) try: - # 创建V2XFormer格式的数据结构 v2x_data = { 'frame_id': frame_num, 'timestamp': datetime.now().timestamp(), @@ -327,21 +274,15 @@ def _save_as_v2xformer_format(self, points, frame_num): } } - # 保存为压缩的JSON格式 filename = f"{frame_num:06d}.pkl.gz" filepath = os.path.join(v2x_dir, filename) - # 使用pickle+gzip压缩保存 with gzip.open(filepath, 'wb') as f: pickle.dump(v2x_data, f, protocol=pickle.HIGHEST_PROTOCOL) - file_size = os.path.getsize(filepath) / 1024 # KB - print(f"保存V2XFormer格式: {filepath} ({file_size:.2f} KB)") - return filepath except Exception as e: - print(f"警告: 保存V2XFormer格式失败: {e}") return None def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): @@ -375,21 +316,18 @@ def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): with open(meta_path, 'w') as f: json.dump(metadata, f, indent=2) except Exception as e: - print(f"保存LiDAR元数据失败: {e}") + pass return metadata def flush_batch(self): - """强制刷新批处理数据""" if self.point_cloud_batch: self._save_batch() def generate_lidar_summary(self): - """生成LiDAR数据摘要(优化版)""" if not os.path.exists(self.lidar_dir): return None - # 快速统计文件 import glob bin_files = glob.glob(os.path.join(self.lidar_dir, "*.bin")) npy_files = glob.glob(os.path.join(self.lidar_dir, "*.npy")) @@ -399,20 +337,17 @@ def generate_lidar_summary(self): total_points = 0 total_size = 0 - # 采样统计,避免读取所有文件 - sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files # 减少采样数量 + sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files for bin_file in sample_files: if os.path.exists(bin_file): try: file_size = os.path.getsize(bin_file) total_size += file_size - # 估算点数 - points_in_file = file_size // (4 * 4) # 4个float32,每个4字节 + points_in_file = file_size // (4 * 4) total_points += points_in_file except: continue - # 根据采样估算总数 if sample_files and len(bin_files) > 0: avg_points_per_file = total_points / max(len(sample_files), 1) total_points_estimated = avg_points_per_file * len(bin_files) @@ -440,13 +375,12 @@ def generate_lidar_summary(self): with open(summary_path, 'w') as f: json.dump(summary, f, indent=2) except Exception as e: - print(f"保存LiDAR摘要失败: {e}") + pass return summary class MultiSensorFusion: - """多传感器融合(优化版)""" def __init__(self, output_dir, config=None): self.output_dir = output_dir @@ -454,8 +388,8 @@ def __init__(self, output_dir, config=None): os.makedirs(self.fusion_dir, exist_ok=True) self.calibration_data = {} - self.fusion_cache = {} # 融合缓存 - self.cache_size = config.get('fusion_cache_size', 50) if config else 50 # 减少缓存大小 + self.fusion_cache = {} + self.cache_size = config.get('fusion_cache_size', 50) if config else 50 self._load_calibration() @@ -463,48 +397,41 @@ def _load_calibration(self): calibration_dir = os.path.join(self.output_dir, "calibration") if os.path.exists(calibration_dir): - # 批量读取校准文件 calibration_files = [] for root, dirs, files in os.walk(calibration_dir): for file in files: if file.endswith('.json'): calibration_files.append(os.path.join(root, file)) - # 限制同时读取的文件数量 - for file in calibration_files[:10]: # 最多读取10个文件 + for file in calibration_files[:10]: try: with open(file, 'r') as f: data = json.load(f) sensor_name = os.path.basename(file).replace('.json', '') self.calibration_data[sensor_name] = data except Exception as e: - print(f"加载校准文件 {file} 失败: {e}") + pass def create_synchronization_file(self, frame_num, sensor_data): - """创建同步文件(优化版)""" - # 检查缓存 cache_key = f"{frame_num}_{hash(str(sensor_data))}" if cache_key in self.fusion_cache: return self.fusion_cache[cache_key] sync_data = { 'frame_id': frame_num, - 'timestamp': datetime.now().timestamp(), # 使用时间戳而不是ISO格式 + 'timestamp': datetime.now().timestamp(), 'sensors': {}, 'transformations': {} } - # 批量处理传感器数据 for sensor_type, data_path in sensor_data.items(): if data_path and os.path.exists(data_path): - # 获取文件信息(不加载完整文件) file_info = { 'file_path': os.path.basename(data_path), 'file_size': os.path.getsize(data_path), 'modified_time': os.path.getmtime(data_path) } - # 如果是图像,获取尺寸信息 if data_path.endswith(('.png', '.jpg', '.jpeg')): try: import cv2 @@ -516,7 +443,6 @@ def create_synchronization_file(self, frame_num, sensor_data): sync_data['sensors'][sensor_type] = file_info - # 添加变换信息(如果可用) if sensor_type in self.calibration_data: sync_data['transformations'][sensor_type] = { 'matrix': self.calibration_data[sensor_type].get('matrix', @@ -524,11 +450,9 @@ def create_synchronization_file(self, frame_num, sensor_data): [0, 0, 0, 1]]) } - # 压缩保存 sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") - # 使用压缩的JSON - if len(str(sync_data)) > 1000: # 如果数据较大,压缩保存 + if len(str(sync_data)) > 1000: compressed_data = zlib.compress( json.dumps(sync_data).encode('utf-8'), level=3 @@ -538,11 +462,9 @@ def create_synchronization_file(self, frame_num, sensor_data): f.write(compressed_data) else: with open(sync_file, 'w') as f: - json.dump(sync_data, f, separators=(',', ':')) # 紧凑格式 + json.dump(sync_data, f, separators=(',', ':')) - # 更新缓存 if len(self.fusion_cache) >= self.cache_size: - # 移除最旧的缓存项 oldest_key = next(iter(self.fusion_cache)) del self.fusion_cache[oldest_key] @@ -551,19 +473,15 @@ def create_synchronization_file(self, frame_num, sensor_data): return sync_file def generate_fusion_report(self): - """生成融合报告(优化版)""" if not os.path.exists(self.fusion_dir): return None - # 快速扫描文件 import glob sync_files = glob.glob(os.path.join(self.fusion_dir, "*.json*")) - # 解析文件名获取帧范围(避免读取所有文件) frame_ids = [] - for sync_file in sync_files[:20]: # 只检查前20个文件 + for sync_file in sync_files[:20]: try: - # 从文件名提取帧号 filename = os.path.basename(sync_file) if filename.startswith('sync_'): frame_id = int(filename.split('_')[1].split('.')[0]) diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 1331ff3b79..6861758c1d 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -1,3 +1,4 @@ +#!/usr/bin/env python3 import sys import os import time @@ -30,6 +31,8 @@ def __init__(self): self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] + self.first_frame_time = None + self.last_frame_time = None def sample_memory(self): try: @@ -72,14 +75,17 @@ def sample_cpu(self): def record_frame_time(self, frame_time): self.frame_times.append(frame_time) + if self.first_frame_time is None: + self.first_frame_time = time.time() + self.last_frame_time = time.time() def get_performance_summary(self): - if not self.frame_times: + if not self.frame_times or len(self.frame_times) < 2: avg_frame_time = 0 fps = 0 else: avg_frame_time = np.mean(self.frame_times) - fps = 1.0 / avg_frame_time if avg_frame_time > 0 else 0 + fps = len(self.frame_times) / max(0.1, (self.last_frame_time - self.first_frame_time)) summary = { 'total_runtime': time.time() - self.start_time, @@ -90,14 +96,24 @@ def get_performance_summary(self): 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, 'average_frame_time': avg_frame_time, 'frames_per_second': fps, - 'total_frames': len(self.frame_times), - 'frame_time_stats': { - 'p50': np.percentile(self.frame_times, 50) if self.frame_times else 0, - 'p95': np.percentile(self.frame_times, 95) if self.frame_times else 0, - 'p99': np.percentile(self.frame_times, 99) if self.frame_times else 0, - 'std': np.std(self.frame_times) if self.frame_times else 0 - } + 'total_frames': len(self.frame_times) } + + if self.frame_times and len(self.frame_times) >= 2: + summary['frame_time_stats'] = { + 'p50': np.percentile(self.frame_times, 50), + 'p95': np.percentile(self.frame_times, 95), + 'p99': np.percentile(self.frame_times, 99) if len(self.frame_times) > 1 else 0, + 'std': np.std(self.frame_times) + } + else: + summary['frame_time_stats'] = { + 'p50': 0, + 'p95': 0, + 'p99': 0, + 'std': 0 + } + return summary @@ -119,12 +135,12 @@ def error(msg): @staticmethod def debug(msg): - timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(f"[DEBUG][{timestamp}] {msg}") @staticmethod def performance(msg): - timestamp = datetime.now().strftime("%Y-%m-d %H:%M:%S") + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(f"[PERF][{timestamp}] {msg}") @@ -569,8 +585,7 @@ def __init__(self, world, config, data_dir): 'total_images': 0, 'total_lidar_frames': 0, 'image_capture_times': [], - 'lidar_processing_times': [], - 'frame_drop_count': 0 + 'lidar_processing_times': [] } def setup_cameras(self, vehicle, center_location, vehicle_id=0): @@ -868,7 +883,6 @@ def cleanup(self): self.is_running = False - Log.info("停止所有传感器监听...") for sensor in self.sensors: try: if hasattr(sensor, 'stop'): @@ -885,7 +899,6 @@ def cleanup(self): except: pass - Log.info(f"销毁 {len(self.sensors)} 个传感器...") for i, sensor in enumerate(self.sensors): try: if hasattr(sensor, 'destroy'): @@ -1105,17 +1118,15 @@ def collect_data(self): memory_warning_issued = False early_stop_triggered = False - # 添加内存监控阈值 - memory_warning_threshold = 350 # MB - memory_critical_threshold = 400 # MB - early_stop_threshold = 450 # MB + memory_warning_threshold = 350 + memory_critical_threshold = 400 + early_stop_threshold = 450 try: while time.time() - self.start_time < duration and self.is_running: current_time = time.time() elapsed = current_time - self.start_time - # 内存监控和早期停止机制 if current_time - last_memory_check >= 2.0: try: import psutil @@ -1204,16 +1215,21 @@ def collect_data(self): self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) - performance_summary = self.performance_monitor.get_performance_summary() + if self.collected_frames > 0: + total_frames_from_sensors = self.collected_frames + performance_summary = self.performance_monitor.get_performance_summary() - if early_stop_triggered: - Log.warning("数据收集因内存过高而提前终止") - else: - Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") + if early_stop_triggered: + Log.warning("数据收集因内存过高而提前终止") + else: + Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") - Log.info(f"平均帧率: {performance_summary['frames_per_second']:.2f} FPS") - Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") - Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + fps = total_frames_from_sensors / max(elapsed, 0.1) + Log.info(f"平均帧率: {fps:.2f} FPS") + Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") + Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + else: + Log.warning("未收集到任何数据帧") self._save_metadata() self._print_summary() @@ -1478,6 +1494,8 @@ def _simulate_object_detection(self, vehicle): return detected_objects def _save_metadata(self): + total_frames = self.collected_frames + metadata = { 'scenario': self.config['scenario'], 'traffic': self.config['traffic'], @@ -1488,22 +1506,26 @@ def _save_metadata(self): 'output': self.config['output'], 'collection': { 'duration': round(time.time() - self.start_time, 2), - 'total_frames': self.collected_frames, - 'frame_rate': round(self.collected_frames / max(time.time() - self.start_time, 0.1), 2) - }, - 'performance': self.performance_monitor.get_performance_summary() + 'total_frames': total_frames, + 'frame_rate': round(total_frames / max(time.time() - self.start_time, 0.1), + 2) if total_frames > 0 else 0 + } } - sensor_summaries = {} - for vehicle_id, sensor_manager in self.sensor_managers.items(): - sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() - metadata['sensor_summaries'] = sensor_summaries + if total_frames > 0: + performance_summary = self.performance_monitor.get_performance_summary() + metadata['performance'] = performance_summary - if self.v2x_communication: - metadata['v2x_status'] = self.v2x_communication.get_network_status() + sensor_summaries = {} + for vehicle_id, sensor_manager in self.sensor_managers.items(): + sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() + metadata['sensor_summaries'] = sensor_summaries - if self.multi_vehicle_manager: - metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() + if self.v2x_communication: + metadata['v2x_status'] = self.v2x_communication.get_network_status() + + if self.multi_vehicle_manager: + metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: @@ -1553,29 +1575,37 @@ def _print_summary(self): if os.path.exists(kitti_dir): print(f"KITTI格式: 已生成") - performance = self.performance_monitor.get_performance_summary() + total_frames = self.collected_frames + elapsed = time.time() - self.start_time + print(f"\n性能统计:") - print(f" 平均帧率: {performance['frames_per_second']:.2f} FPS") - print(f" 帧时统计:") - print(f" 平均: {performance['average_frame_time']:.3f}秒") - print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") - print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") - print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") - print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") - print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") - print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") - print(f" 总帧数: {performance['total_frames']}") + if total_frames > 0: + fps = total_frames / max(elapsed, 0.1) + print(f" 平均帧率: {fps:.2f} FPS") + + performance = self.performance_monitor.get_performance_summary() + print(f" 帧时统计:") + print(f" 平均: {performance['average_frame_time']:.3f}秒") + print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") + print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") + print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") + print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") + print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") + print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") + print(f" 总帧数: {total_frames}") + else: + print(" 未收集到有效帧数据") print(f"\n输出目录: {self.output_dir}") print("=" * 60) def run_validation(self): - if self.config['output'].get('validate_data', True): + if self.config['output'].get('validate_data', True) and self.collected_frames > 0: Log.info("运行数据验证...") DataValidator.validate_dataset(self.output_dir) def run_analysis(self): - if self.config['output'].get('run_analysis', False): + if self.config['output'].get('run_analysis', False) and self.collected_frames > 0: Log.info("运行数据分析...") DataAnalyzer.analyze_dataset(self.output_dir) @@ -1687,4 +1717,4 @@ def main(): if __name__ == "__main__": - main() \ No newline at end of file + main() From 84d1f41eb5bde5f8a3911bcc7c505cea5d99906b Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Sun, 21 Dec 2025 21:47:38 +0800 Subject: [PATCH 18/21] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=B8=80=E4=B8=AA?= =?UTF-8?q?=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/enhance_pedestrian_safety/package.xml | 71 +++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 src/enhance_pedestrian_safety/package.xml diff --git a/src/enhance_pedestrian_safety/package.xml b/src/enhance_pedestrian_safety/package.xml new file mode 100644 index 0000000000..d6380991bb --- /dev/null +++ b/src/enhance_pedestrian_safety/package.xml @@ -0,0 +1,71 @@ + + + carla_sensor + 0.0.0 + The carla_sensor package + + + + + ros-industrial + + + + + + TODO + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + catkin + cv_bridge + rospy + sensor_msgs + std_msgs + cv_bridge + rospy + sensor_msgs + std_msgs + cv_bridge + rospy + sensor_msgs + std_msgs + + + + + + + + From 9552e812d70e6ac562781916ba9b18464d8f5559 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Thu, 25 Dec 2025 00:37:39 +0800 Subject: [PATCH 19/21] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E8=A1=8C=E4=BA=BA?= =?UTF-8?q?=E5=AE=89=E5=85=A8=E7=9B=91=E6=8E=A7=E5=99=A8,=E5=A2=9E?= =?UTF-8?q?=E5=BC=BA=E5=9C=BA=E6=99=AF=E7=AE=A1=E7=90=86=E5=99=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../config_manager.py | 105 ++++- .../data_analyzer.py | 160 +++++++- .../data_validator.py | 82 +++- src/enhance_pedestrian_safety/main.py | 50 ++- .../multi_vehicle_manager.py | 28 ++ .../pedestrian_safety_monitor.py | 368 ++++++++++++++++++ .../scene_manager.py | 85 ++++ .../sensor_enhancer.py | 54 +++ 8 files changed, 905 insertions(+), 27 deletions(-) create mode 100644 src/enhance_pedestrian_safety/pedestrian_safety_monitor.py diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index c608de6674..aa07724783 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -133,7 +133,13 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: 'enabled': True, 'enable_random': True, 'quality_check': True, - 'methods': ['normalize', 'contrast', 'sharpness', 'noise'] + 'save_original': True, + 'save_enhanced': True, + 'calibration_generation': True, + 'enhanced_dir_name': 'enhanced', + 'methods': ['normalize', 'contrast', 'brightness'], + 'weather_effects': True, + 'augmentation_level': 'medium' }) return optimized @@ -173,6 +179,94 @@ def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: return optimized + @staticmethod + def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: + """优化配置以增强行人安全""" + optimized = copy.deepcopy(config) + + # 增加行人密度 + traffic = optimized['traffic'] + traffic.update({ + 'pedestrians': 12, # 增加行人数量 + 'pedestrian_types': [ + 'walker.pedestrian.0001', + 'walker.pedestrian.0002', + 'walker.pedestrian.0003', + 'walker.pedestrian.0004' + ] + }) + + # 优化传感器配置以更好地检测行人 + sensors = optimized['sensors'] + sensors.update({ + 'image_size': [1280, 720], + 'capture_interval': 1.5, # 更频繁地捕获 + 'vehicle_cameras': 4, + 'camera_config': { + 'fov': 100.0, # 更宽的视野 + 'post_processing': 'default', + 'exposure_mode': 'auto', + 'motion_blur': 0.0 + } + }) + + # 启用LiDAR以检测行人 + sensors['lidar_sensors'] = 1 + sensors['lidar_config'].update({ + 'channels': 64, # 更多通道以检测行人 + 'range': 120.0, + 'points_per_second': 100000, + 'max_points_per_frame': 80000, + 'downsample_ratio': 0.2 + }) + + # 启用V2X和协同感知 + v2x = optimized.setdefault('v2x', {}) + v2x.update({ + 'enabled': True, + 'communication_range': 300.0, + 'update_interval': 1.0 # 更频繁地更新 + }) + + coop = optimized.setdefault('cooperative', {}) + coop.update({ + 'num_coop_vehicles': 2, + 'enable_shared_perception': True, + 'enable_traffic_warnings': True, + 'enable_maneuver_coordination': False, + 'data_fusion_interval': 0.5, # 更频繁地融合 + 'max_shared_objects': 100, + 'object_matching_threshold': 3.0 # 更严格的对象匹配 + }) + + # 性能优化 + perf = optimized.setdefault('performance', {}) + perf.update({ + 'batch_size': 5, + 'enable_compression': True, + 'compression_level': 3, + 'enable_memory_cache': True, + 'max_cache_size': 40, + 'frame_rate_limit': 8.0 + }) + + # 输出配置 + output = optimized['output'] + output.update({ + 'save_raw': True, + 'save_stitched': True, + 'save_annotations': True, + 'save_lidar': True, + 'save_fusion': True, + 'save_cooperative': True, + 'save_enhanced': True, + 'validate_data': True, + 'run_analysis': True, + 'run_quality_check': True + }) + + return optimized + class ConfigManager: @@ -189,6 +283,10 @@ class ConfigManager: 'description': '快速采集配置 - 优先处理速度', 'optimization': 'speed' }, + 'pedestrian_safety': { + 'description': '行人安全配置 - 优化行人检测和安全评估', + 'optimization': 'safety' + }, 'v2x_focused': { 'description': 'V2X重点配置 - 优化协同数据采集', 'optimization': 'custom', @@ -438,6 +536,8 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: config = ConfigOptimizer.optimize_for_quality(config) elif optimization == 'speed': config = ConfigOptimizer.optimize_for_speed(config) + elif optimization == 'safety': + config = ConfigOptimizer.optimize_for_safety(config) elif optimization == 'custom' and 'settings' in preset: config = ConfigManager._deep_update(config, preset['settings']) @@ -536,6 +636,9 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if hasattr(args, 'output_format') and args.output_format: config['output']['output_format'] = args.output_format + if hasattr(args, 'enable_safety_monitor'): + config['monitoring']['enable_safety_monitor'] = args.enable_safety_monitor + return config @staticmethod diff --git a/src/enhance_pedestrian_safety/data_analyzer.py b/src/enhance_pedestrian_safety/data_analyzer.py index 14690041fb..38ee4dd6f4 100644 --- a/src/enhance_pedestrian_safety/data_analyzer.py +++ b/src/enhance_pedestrian_safety/data_analyzer.py @@ -85,7 +85,8 @@ def analyze_dataset(data_dir, force_refresh=False): 'object_statistics': DataAnalyzer._analyze_objects(data_dir), 'temporal_analysis': DataAnalyzer._analyze_temporal(data_dir), 'cooperative_data': DataAnalyzer._analyze_cooperative_data(data_dir), - 'quality_metrics': DataAnalyzer._calculate_quality_metrics(data_dir) + 'quality_metrics': DataAnalyzer._calculate_quality_metrics(data_dir), + 'safety_analysis': DataAnalyzer._analyze_safety_data(data_dir) } # 生成评分 @@ -231,6 +232,10 @@ def _analyze_file_distribution(data_dir): fusion_dir = os.path.join(data_dir, "fusion") if os.path.exists(fusion_dir): distribution['fusion'] = DataAnalyzer._analyze_fusion_data(fusion_dir) + elif dir_name == "safety_reports": + safety_dir = os.path.join(data_dir, "safety_reports") + if os.path.exists(safety_dir): + distribution['safety_reports'] = DataAnalyzer._analyze_safety_reports(safety_dir) return distribution @@ -335,6 +340,41 @@ def _analyze_fusion_data(fusion_dir): fusion_stats['total_size_mb'] = round(total_size / (1024 * 1024), 2) return fusion_stats + @staticmethod + def _analyze_safety_reports(safety_dir): + """分析安全报告数据""" + safety_stats = { + 'reports': 0, + 'high_risk': 0, + 'medium_risk': 0, + 'low_risk': 0, + 'total_interactions': 0 + } + + json_files = [f for f in os.listdir(safety_dir) if f.lower().endswith('.json')] + safety_stats['reports'] = len(json_files) + + if json_files: + # 采样分析几个文件 + sample_files = json_files[:min(5, len(json_files))] + for json_file in sample_files: + try: + with open(os.path.join(safety_dir, json_file), 'r', encoding='utf-8') as f: + data = json.load(f) + + if 'high_risk_cases' in data: + safety_stats['high_risk'] += data['high_risk_cases'] + if 'medium_risk_cases' in data: + safety_stats['medium_risk'] += data['medium_risk_cases'] + if 'low_risk_cases' in data: + safety_stats['low_risk_cases'] += data['low_risk_cases'] + if 'total_interactions' in data: + safety_stats['total_interactions'] += data['total_interactions'] + except: + pass + + return safety_stats + @staticmethod def _analyze_objects(data_dir): """分析物体统计(优化版)""" @@ -647,6 +687,70 @@ def _analyze_cooperative_data(data_dir): return analysis + @staticmethod + def _analyze_safety_data(data_dir): + """分析安全数据""" + safety_dir = os.path.join(data_dir, "safety_reports") + + if not os.path.exists(safety_dir): + return { + 'total_reports': 0, + 'risk_levels': {'high': 0, 'medium': 0, 'low': 0}, + 'safety_score': 0, + 'pedestrian_interactions': 0, + 'average_distance': 0 + } + + json_files = [f for f in os.listdir(safety_dir) if f.lower().endswith('.json')] + + safety_data = { + 'total_reports': len(json_files), + 'risk_levels': {'high': 0, 'medium': 0, 'low': 0}, + 'safety_score': 0, + 'pedestrian_interactions': 0, + 'average_distance': 0, + 'near_misses': 0, + 'safety_warnings': 0 + } + + if json_files: + distances = [] + for json_file in json_files[:min(10, len(json_files))]: + try: + with open(os.path.join(safety_dir, json_file), 'r', encoding='utf-8') as f: + data = json.load(f) + + if 'high_risk_cases' in data: + safety_data['risk_levels']['high'] += data['high_risk_cases'] + if 'medium_risk_cases' in data: + safety_data['risk_levels']['medium'] += data['medium_risk_cases'] + if 'low_risk_cases' in data: + safety_data['risk_levels']['low'] += data['low_risk_cases'] + if 'total_interactions' in data: + safety_data['pedestrian_interactions'] += data['total_interactions'] + if 'average_distance' in data: + distances.append(data['average_distance']) + if 'near_misses' in data: + safety_data['near_misses'] += data['near_misses'] + if 'safety_warnings' in data: + safety_data['safety_warnings'] += data['safety_warnings'] + + except Exception as e: + print(f"分析安全报告 {json_file} 失败: {e}") + + if distances: + safety_data['average_distance'] = round(np.mean(distances), 2) + + # 计算安全评分 + total_risks = sum(safety_data['risk_levels'].values()) + if total_risks > 0: + high_risk_ratio = safety_data['risk_levels']['high'] / total_risks + safety_data['safety_score'] = max(0, 100 - high_risk_ratio * 100) + else: + safety_data['safety_score'] = 100 + + return safety_data + @staticmethod def _calculate_quality_metrics(data_dir): """计算质量指标(增强版)""" @@ -657,6 +761,7 @@ def _calculate_quality_metrics(data_dir): 'cooperative_score': 0, 'temporal_score': 0, 'structural_score': 0, + 'safety_score': 0, 'issues_found': [], 'recommendations': [] } @@ -674,7 +779,8 @@ def _calculate_quality_metrics(data_dir): "lidar", "fusion", "annotations", - "calibration" + "calibration", + "safety_reports" ] missing_required = [] @@ -781,9 +887,17 @@ def _calculate_quality_metrics(data_dir): quality_metrics['temporal_score'] *= 0.8 # 时长不足,降低分数 quality_metrics['recommendations'].append("建议增加数据收集时长以获得更完整的时间序列") + # 7. 安全评分 + safety_data = DataAnalyzer._analyze_safety_data(data_dir) + quality_metrics['safety_score'] = safety_data.get('safety_score', 0) + + if quality_metrics['safety_score'] < 80: + quality_metrics['issues_found'].append(f"安全评分较低: {quality_metrics['safety_score']}") + quality_metrics['recommendations'].append("建议增加行人安全相关的场景和数据收集") + # 限制分数在0-100之间 for key in ['completeness_score', 'consistency_score', 'diversity_score', - 'cooperative_score', 'temporal_score', 'structural_score']: + 'cooperative_score', 'temporal_score', 'structural_score', 'safety_score']: quality_metrics[key] = max(0, min(100, quality_metrics[key])) return quality_metrics @@ -792,12 +906,13 @@ def _calculate_quality_metrics(data_dir): def _calculate_overall_score(analysis): """计算总体评分(增强版)""" weights = { - 'completeness': 0.20, # 完整性 - 'consistency': 0.15, # 一致性 - 'demporal': 0.15, # 时间性 - 'structural': 0.10, # 结构性 - 'diversity': 0.15, # 多样性 - 'cooperative': 0.15, # 协同性 + 'completeness': 0.15, # 完整性 + 'consistency': 0.12, # 一致性 + 'temporal': 0.12, # 时间性 + 'structural': 0.08, # 结构性 + 'diversity': 0.12, # 多样性 + 'cooperative': 0.12, # 协同性 + 'safety': 0.19, # 安全性 'quality_bonus': 0.10 # 质量加成 } @@ -810,7 +925,8 @@ def _calculate_overall_score(analysis): quality['temporal_score'] * weights['temporal'] + quality['structural_score'] * weights['structural'] + quality['diversity_score'] * weights['diversity'] + - quality['cooperative_score'] * weights['cooperative'] + quality['cooperative_score'] * weights['cooperative'] + + quality['safety_score'] * weights['safety'] ) # 质量加成(基于问题数量) @@ -822,7 +938,8 @@ def _calculate_overall_score(analysis): # 额外加成(如果数据集特别优秀) if (quality['completeness_score'] >= 95 and quality['consistency_score'] >= 90 and - quality['diversity_score'] >= 85): + quality['diversity_score'] >= 85 and + quality['safety_score'] >= 90): total_score += 5 return round(min(total_score, 100), 1) @@ -852,6 +969,7 @@ def _save_analysis_report(data_dir, analysis): 'total_objects': analysis['object_statistics']['total_objects'], 'num_classes': len(analysis['object_statistics']['by_class']) }, + 'safety_data': analysis.get('safety_analysis', {}), 'analysis_metadata': analysis.get('metadata', {}) } @@ -919,6 +1037,20 @@ def _print_analysis_summary(analysis): print(f" 每帧物体数统计:") print(f" 最小: {stats['min']}, 最大: {stats['max']}, 平均: {stats['mean']}, 中位数: {stats['median']}") + # 安全数据分析 + if 'safety_analysis' in analysis: + safety = analysis['safety_analysis'] + print(f"\n🚸 安全数据分析:") + print(f" 安全评分: {safety.get('safety_score', 0)}/100") + print(f" 风险等级分布:") + print(f" 高风险: {safety.get('risk_levels', {}).get('high', 0)}") + print(f" 中风险: {safety.get('risk_levels', {}).get('medium', 0)}") + print(f" 低风险: {safety.get('risk_levels', {}).get('low', 0)}") + print(f" 行人交互次数: {safety.get('pedestrian_interactions', 0)}") + print(f" 平均距离: {safety.get('average_distance', 0):.2f}米") + print(f" 近距离事件: {safety.get('near_misses', 0)}") + print(f" 安全警告: {safety.get('safety_warnings', 0)}") + # 协同数据分析 cooperative = analysis['cooperative_data'] print(f"\n🤝 协同数据分析:") @@ -958,7 +1090,8 @@ def _print_analysis_summary(analysis): ('结构性', quality['structural_score']), ('时间性', quality['temporal_score']), ('多样性', quality['diversity_score']), - ('协同性', quality['cooperative_score']) + ('协同性', quality['cooperative_score']), + ('安全性', quality['safety_score']) ] for name, score in metrics: @@ -1015,7 +1148,8 @@ def generate_comparison_report(data_dirs, output_file=None): 'object_statistics': { 'total_objects': analysis['object_statistics']['total_objects'], 'num_classes': len(analysis['object_statistics']['by_class']) - } + }, + 'safety_analysis': analysis.get('safety_analysis', {}) } if output_file: diff --git a/src/enhance_pedestrian_safety/data_validator.py b/src/enhance_pedestrian_safety/data_validator.py index fa67f6425b..b472b40eb8 100644 --- a/src/enhance_pedestrian_safety/data_validator.py +++ b/src/enhance_pedestrian_safety/data_validator.py @@ -1,5 +1,5 @@ -import os import json +import os class DataValidator: @@ -16,7 +16,8 @@ def validate_dataset(data_dir): 'metadata': DataValidator._validate_metadata(data_dir), 'lidar_data': DataValidator._validate_lidar_data(data_dir), 'cooperative_data': DataValidator._validate_cooperative_data(data_dir), - 'fusion_data': DataValidator._validate_fusion_data(data_dir) + 'fusion_data': DataValidator._validate_fusion_data(data_dir), + 'safety_data': DataValidator._validate_safety_data(data_dir) } validation_results['overall_score'] = DataValidator._calculate_score(validation_results) @@ -39,18 +40,33 @@ def _check_directory_structure(data_dir): "fusion" ] + optional_dirs = [ + "lidar", + "calibration", + "annotations", + "safety_reports" + ] + missing_dirs = [] for dir_path in required_dirs: full_path = os.path.join(data_dir, dir_path) if not os.path.exists(full_path): missing_dirs.append(dir_path) + missing_optional = [] + for dir_path in optional_dirs: + full_path = os.path.join(data_dir, dir_path) + if not os.path.exists(full_path): + missing_optional.append(dir_path) + status = 'PASS' if len(missing_dirs) == 0 else 'FAIL' result = { 'status': status, 'missing_directories': missing_dirs, - 'required_directories': required_dirs + 'missing_optional_directories': missing_optional, + 'required_directories': required_dirs, + 'optional_directories': optional_dirs } return result @@ -376,17 +392,59 @@ def _validate_fusion_data(data_dir): 'errors': errors } + @staticmethod + def _validate_safety_data(data_dir): + """验证安全数据""" + safety_dir = os.path.join(data_dir, "safety_reports") + + if not os.path.exists(safety_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + json_files = [f for f in os.listdir(safety_dir) if f.endswith('.json')] + errors = [] + valid_files = 0 + + for json_file in json_files[:min(5, len(json_files))]: + json_path = os.path.join(safety_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + + # 检查必要字段 + required_keys = ['timestamp', 'total_interactions'] + for key in required_keys: + if key not in data: + errors.append(f"安全报告缺失字段 {key}: {json_file}") + + valid_files += 1 + except Exception as e: + errors.append(f"安全报告无效: {json_file} - {str(e)}") + + if len(errors) == 0 and valid_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': len(json_files), + 'errors': errors + } + @staticmethod def _calculate_score(results): weights = { 'directory_structure': 0.10, - 'raw_images': 0.20, - 'stitched_images': 0.10, - 'annotations': 0.10, - 'metadata': 0.10, - 'lidar_data': 0.15, - 'cooperative_data': 0.15, - 'fusion_data': 0.10 + 'raw_images': 0.15, + 'stitched_images': 0.05, + 'annotations': 0.08, + 'metadata': 0.08, + 'lidar_data': 0.12, + 'cooperative_data': 0.12, + 'fusion_data': 0.10, + 'safety_data': 0.20 } score = 0 @@ -459,6 +517,10 @@ def _print_validation_report(results): if 'json_files' in result: print(f" JSON文件: {result['json_files']}") + if key == 'safety_data' and isinstance(result, dict): + if 'count' in result: + print(f" 安全报告: {result['count']} 个") + if 'errors' in result and result['errors']: print(f" 错误 ({len(result['errors'])}):") for error in result['errors'][:3]: diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 6861758c1d..2626fe0a82 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -20,6 +20,7 @@ from data_analyzer import DataAnalyzer from lidar_processor import LidarProcessor, MultiSensorFusion from multi_vehicle_manager import MultiVehicleManager +from pedestrian_safety_monitor import PedestrianSafetyMonitor carla_egg_path, remaining_argv = setup_carla_path() carla = import_carla_module() @@ -143,6 +144,11 @@ def performance(msg): timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(f"[PERF][{timestamp}] {msg}") + @staticmethod + def safety(msg): + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + print(f"[SAFETY][{timestamp}] {msg}") + class WeatherSystem: WEATHER_PRESETS = { @@ -964,6 +970,7 @@ def __init__(self, config): self.sensor_managers = {} self.multi_vehicle_manager = None self.v2x_communication = None + self.safety_monitor = None self.start_time = None self.is_running = False @@ -994,7 +1001,8 @@ def setup_directories(self): "v2x_messages", "v2xformer_format", "kitti_format", - "metadata" + "metadata", + "safety_reports" ] for subdir in directories: @@ -1082,6 +1090,9 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) + # 初始化行人安全监控器 + self.safety_monitor = PedestrianSafetyMonitor(self.world, self.output_dir) + time.sleep(3.0) return True @@ -1114,6 +1125,7 @@ def collect_data(self): last_performance_sample = time.time() last_detailed_log = time.time() last_memory_check = time.time() + last_safety_check = time.time() memory_warning_issued = False early_stop_triggered = False @@ -1167,6 +1179,13 @@ def collect_data(self): self._share_perception_data() last_perception_share = current_time + # 行人安全检查 + if current_time - last_safety_check >= 1.0 and self.safety_monitor: + safety_report = self.safety_monitor.check_pedestrian_safety() + if safety_report['risk_distribution']['high'] > 0: + Log.safety(f"行人安全警告: {safety_report['high_risk_cases']}个高风险情况") + last_safety_check = current_time + if current_time - last_performance_sample >= 10.0: memory_info = self.performance_monitor.sample_memory() cpu_info = self.performance_monitor.sample_cpu() @@ -1228,6 +1247,12 @@ def collect_data(self): Log.info(f"平均帧率: {fps:.2f} FPS") Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + + # 生成行人安全报告 + if self.safety_monitor: + final_report = self.safety_monitor.generate_final_report() + Log.safety( + f"行人安全报告: {final_report['risk_distribution']['high']}高风险, {final_report['risk_distribution']['medium']}中风险") else: Log.warning("未收集到任何数据帧") @@ -1279,6 +1304,13 @@ def cleanup(self): except: pass + if self.safety_monitor: + try: + Log.info("保存行人安全数据...") + self.safety_monitor.save_data() + except: + pass + Log.info(f"清理 {len(self.sensor_managers)} 个传感器管理器...") for vehicle_id, sensor_manager in self.sensor_managers.items(): try: @@ -1328,6 +1360,7 @@ def cleanup(self): self.traffic_manager = None self.multi_vehicle_manager = None self.v2x_communication = None + self.safety_monitor = None self.scene_center = None gc.collect() @@ -1342,6 +1375,7 @@ def cleanup(self): self.traffic_manager = None self.multi_vehicle_manager = None self.v2x_communication = None + self.safety_monitor = None gc.collect() except: pass @@ -1527,6 +1561,9 @@ def _save_metadata(self): if self.multi_vehicle_manager: metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() + if self.safety_monitor: + metadata['safety_report'] = self.safety_monitor.generate_final_report() + meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: json.dump(metadata, f, indent=2, ensure_ascii=False) @@ -1565,6 +1602,11 @@ def _print_summary(self): [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") + safety_dir = os.path.join(self.output_dir, "safety_reports") + if os.path.exists(safety_dir): + safety_files = len([f for f in os.listdir(safety_dir) if f.endswith('.json')]) + print(f"安全报告: {safety_files} 个") + if self.output_format == 'v2xformer': v2x_dir = os.path.join(self.output_dir, "v2xformer_format") if os.path.exists(v2x_dir): @@ -1643,6 +1685,7 @@ def main(): parser.add_argument('--enable-cooperative', action='store_true', help='启用协同感知') parser.add_argument('--enable-enhancement', action='store_true', help='启用数据增强') parser.add_argument('--enable-annotations', action='store_true', help='启用自动标注') + parser.add_argument('--enable-safety-monitor', action='store_true', default=True, help='启用行人安全监控') parser.add_argument('--run-analysis', action='store_true', help='运行数据集分析') parser.add_argument('--skip-validation', action='store_true', help='跳过数据验证') @@ -1659,7 +1702,7 @@ def main(): config['output']['output_format'] = args.output_format print("\n" + "=" * 60) - print("CVIPS 性能优化数据收集系统") + print("CVIPS 性能优化数据收集系统 - 行人安全增强版") print("=" * 60) print(f"场景: {config['scenario']['name']}") @@ -1678,6 +1721,7 @@ def main(): print(f" V2X: {'启用' if config['v2x']['enabled'] else '禁用'}") print(f" 协同: {'启用' if config['output']['save_cooperative'] else '禁用'}") print(f" 增强: {'启用' if config['enhancement']['enabled'] else '禁用'}") + print(f" 安全监控: {'启用' if args.enable_safety_monitor else '禁用'}") print(f"性能:") print(f" 批处理大小: {config['performance']['batch_size']}") @@ -1717,4 +1761,4 @@ def main(): if __name__ == "__main__": - main() + main() \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/multi_vehicle_manager.py b/src/enhance_pedestrian_safety/multi_vehicle_manager.py index 4ed8890d91..62fcd37cf8 100644 --- a/src/enhance_pedestrian_safety/multi_vehicle_manager.py +++ b/src/enhance_pedestrian_safety/multi_vehicle_manager.py @@ -297,6 +297,34 @@ def share_traffic_warning(self, vehicle_id: int, warning_type: str, print(f"共享交通警告失败: {e}") return None + def share_pedestrian_warning(self, vehicle_id: int, pedestrian_location: Tuple[float, float, float], + distance: float, speed: float): + """共享行人警告""" + try: + warning_data = { + 'warning_type': 'pedestrian', + 'pedestrian_location': pedestrian_location, + 'distance': distance, + 'vehicle_speed': speed, + 'timestamp': time.time(), + 'source_vehicle': vehicle_id, + 'severity': 'high' if distance < 10.0 else 'medium' if distance < 20.0 else 'low' + } + + message = self.create_v2x_message( + vehicle_id, + 'warning', + warning_data, + priority=4 # 行人警告优先级最高 + ) + + recipients = self.broadcast_message(message) + + return message, recipients + except Exception as e: + print(f"共享行人警告失败: {e}") + return None, [] + def _fuse_shared_perception(self, source_id: int, objects: List[Dict], recipients: List[int]): """融合共享的感知数据""" fused_objects = [] diff --git a/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py b/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py new file mode 100644 index 0000000000..5ec545f100 --- /dev/null +++ b/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py @@ -0,0 +1,368 @@ +import json +import os +import time +import math +import numpy as np +from datetime import datetime +from typing import List, Dict, Tuple, Optional +import carla + + +class PedestrianSafetyMonitor: + """行人安全监控器""" + + def __init__(self, world, output_dir): + self.world = world + self.output_dir = output_dir + self.safety_dir = os.path.join(output_dir, "safety_reports") + os.makedirs(self.safety_dir, exist_ok=True) + + # 安全参数 + self.safety_thresholds = { + 'high_risk_distance': 5.0, # 高风险距离 (米) + 'medium_risk_distance': 10.0, # 中风险距离 (米) + 'low_risk_distance': 20.0, # 低风险距离 (米) + 'safe_speed_limit': 30.0, # 安全速度限制 (km/h) + 'reaction_time': 1.5, # 反应时间 (秒) + 'braking_deceleration': 6.0 # 制动减速度 (m/s²) + } + + # 统计数据 + self.stats = { + 'total_interactions': 0, + 'high_risk_cases': 0, + 'medium_risk_cases': 0, + 'low_risk_cases': 0, + 'safe_cases': 0, + 'near_misses': 0, + 'safety_warnings': 0, + 'average_distance': 0, + 'min_distance': float('inf'), + 'max_distance': 0, + 'interaction_times': [] + } + + # 详细记录 + self.interaction_records = [] + self.warning_logs = [] + + def check_pedestrian_safety(self) -> Dict: + """检查行人安全""" + vehicles = self._get_vehicles() + pedestrians = self._get_pedestrians() + + current_interactions = [] + + for vehicle in vehicles: + vehicle_location = vehicle.get_location() + vehicle_velocity = vehicle.get_velocity() + vehicle_speed = math.sqrt(vehicle_velocity.x ** 2 + vehicle_velocity.y ** 2 + vehicle_velocity.z ** 2) + + for pedestrian in pedestrians: + pedestrian_location = pedestrian.get_location() + + # 计算距离 + distance = vehicle_location.distance(pedestrian_location) + + # 计算相对速度 + pedestrian_velocity = pedestrian.get_velocity() + relative_speed = self._calculate_relative_speed(vehicle_velocity, pedestrian_velocity) + + # 计算碰撞时间 + time_to_collision = self._calculate_ttc(distance, relative_speed) + + # 评估风险 + risk_level = self._assess_risk(distance, vehicle_speed, time_to_collision) + + interaction = { + 'timestamp': time.time(), + 'vehicle_id': vehicle.id, + 'pedestrian_id': pedestrian.id, + 'distance': distance, + 'vehicle_speed': vehicle_speed * 3.6, # 转换为km/h + 'relative_speed': relative_speed * 3.6, + 'time_to_collision': time_to_collision if time_to_collision < 100 else None, + 'risk_level': risk_level, + 'vehicle_location': { + 'x': vehicle_location.x, + 'y': vehicle_location.y, + 'z': vehicle_location.z + }, + 'pedestrian_location': { + 'x': pedestrian_location.x, + 'y': pedestrian_location.y, + 'z': pedestrian_location.z + } + } + + current_interactions.append(interaction) + + # 更新统计 + self._update_stats(interaction) + + # 记录高风险情况 + if risk_level == 'high': + self._log_high_risk(interaction) + + # 保存当前检查结果 + if current_interactions: + self._save_interaction_report(current_interactions) + + return self._generate_safety_report() + + def _get_vehicles(self) -> List[carla.Actor]: + """获取所有车辆""" + return [actor for actor in self.world.get_actors() if 'vehicle' in actor.type_id] + + def _get_pedestrians(self) -> List[carla.Actor]: + """获取所有行人""" + return [actor for actor in self.world.get_actors() if 'walker' in actor.type_id] + + def _calculate_relative_speed(self, v1: carla.Vector3D, v2: carla.Vector3D) -> float: + """计算相对速度""" + return math.sqrt((v1.x - v2.x) ** 2 + (v1.y - v2.y) ** 2 + (v1.z - v2.z) ** 2) + + def _calculate_ttc(self, distance: float, relative_speed: float) -> float: + """计算碰撞时间 (Time to Collision)""" + if relative_speed > 0.1: # 避免除以零 + return distance / relative_speed + return float('inf') + + def _assess_risk(self, distance: float, speed: float, ttc: Optional[float]) -> str: + """评估风险等级""" + speed_kmh = speed * 3.6 + + # 基于距离的风险评估 + if distance < self.safety_thresholds['high_risk_distance']: + if ttc is not None and ttc < 2.0: + return 'high' + else: + return 'medium' + elif distance < self.safety_thresholds['medium_risk_distance']: + if speed_kmh > self.safety_thresholds['safe_speed_limit']: + return 'medium' + else: + return 'low' + elif distance < self.safety_thresholds['low_risk_distance']: + return 'low' + else: + return 'safe' + + def _update_stats(self, interaction: Dict): + """更新统计数据""" + self.stats['total_interactions'] += 1 + distance = interaction['distance'] + + # 更新距离统计 + self.stats['average_distance'] = ( + (self.stats['average_distance'] * (self.stats['total_interactions'] - 1) + distance) / + self.stats['total_interactions'] + ) + self.stats['min_distance'] = min(self.stats['min_distance'], distance) + self.stats['max_distance'] = max(self.stats['max_distance'], distance) + + # 更新风险统计 + risk_level = interaction['risk_level'] + if risk_level == 'high': + self.stats['high_risk_cases'] += 1 + self.stats['near_misses'] += 1 + self.stats['safety_warnings'] += 1 + elif risk_level == 'medium': + self.stats['medium_risk_cases'] += 1 + self.stats['safety_warnings'] += 1 + elif risk_level == 'low': + self.stats['low_risk_cases'] += 1 + else: + self.stats['safe_cases'] += 1 + + # 记录交互时间 + self.stats['interaction_times'].append(interaction['timestamp']) + + # 添加到详细记录 + self.interaction_records.append(interaction) + + # 限制记录数量 + if len(self.interaction_records) > 1000: + self.interaction_records = self.interaction_records[-1000:] + + def _log_high_risk(self, interaction: Dict): + """记录高风险情况""" + warning = { + 'timestamp': datetime.now().isoformat(), + 'interaction': interaction, + 'safety_measures': self._suggest_safety_measures(interaction) + } + self.warning_logs.append(warning) + + # 保存高风险警告 + if len(self.warning_logs) % 10 == 0: + self._save_warning_logs() + + def _suggest_safety_measures(self, interaction: Dict) -> List[str]: + """建议安全措施""" + measures = [] + + if interaction['risk_level'] == 'high': + measures.extend([ + "立即制动", + "鸣喇叭警告", + "准备紧急避让", + "向其他车辆发送警告" + ]) + elif interaction['risk_level'] == 'medium': + measures.extend([ + "减速行驶", + "保持警惕", + "准备制动", + "观察行人动向" + ]) + elif interaction['risk_level'] == 'low': + measures.extend([ + "保持安全距离", + "观察周围环境", + "准备应对突发情况" + ]) + + return measures + + def _save_interaction_report(self, interactions: List[Dict]): + """保存交互报告""" + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + report_file = os.path.join(self.safety_dir, f"interactions_{timestamp}.json") + + report = { + 'timestamp': datetime.now().isoformat(), + 'total_interactions': len(interactions), + 'interactions': interactions, + 'summary': { + 'high_risk': len([i for i in interactions if i['risk_level'] == 'high']), + 'medium_risk': len([i for i in interactions if i['risk_level'] == 'medium']), + 'low_risk': len([i for i in interactions if i['risk_level'] == 'low']), + 'safe': len([i for i in interactions if i['risk_level'] == 'safe']) + } + } + + with open(report_file, 'w', encoding='utf-8') as f: + json.dump(report, f, indent=2, ensure_ascii=False) + + def _save_warning_logs(self): + """保存警告日志""" + if not self.warning_logs: + return + + warning_file = os.path.join(self.safety_dir, "warning_logs.json") + with open(warning_file, 'w', encoding='utf-8') as f: + json.dump(self.warning_logs, f, indent=2, ensure_ascii=False) + + def _generate_safety_report(self) -> Dict: + """生成安全报告""" + report = { + 'timestamp': datetime.now().isoformat(), + 'statistics': self.stats.copy(), + 'safety_thresholds': self.safety_thresholds, + 'risk_distribution': { + 'high': self.stats['high_risk_cases'], + 'medium': self.stats['medium_risk_cases'], + 'low': self.stats['low_risk_cases'], + 'safe': self.stats['safe_cases'] + }, + 'safety_score': self._calculate_safety_score(), + 'recommendations': self._generate_recommendations() + } + + return report + + def _calculate_safety_score(self) -> float: + """计算安全评分""" + if self.stats['total_interactions'] == 0: + return 100.0 + + high_risk_ratio = self.stats['high_risk_cases'] / self.stats['total_interactions'] + medium_risk_ratio = self.stats['medium_risk_cases'] / self.stats['total_interactions'] + + # 评分公式:基础分减去风险比例 + score = 100 - (high_risk_ratio * 60 + medium_risk_ratio * 30) * 100 + + # 考虑平均距离 + if self.stats['average_distance'] > 15.0: + score += 10 + elif self.stats['average_distance'] < 5.0: + score -= 20 + + return max(0, min(100, score)) + + def _generate_recommendations(self) -> List[str]: + """生成改进建议""" + recommendations = [] + + if self.stats['high_risk_cases'] > 0: + recommendations.extend([ + "增加行人安全距离阈值", + "加强车辆行人检测系统", + "实施更严格的限速措施", + "增加行人警告系统" + ]) + + if self.stats['average_distance'] < 10.0: + recommendations.append("增加车辆与行人的平均距离") + + if self.stats['near_misses'] > 5: + recommendations.append("实施紧急制动系统") + + return recommendations + + def generate_final_report(self) -> Dict: + """生成最终报告""" + final_report = self._generate_safety_report() + + # 添加历史数据 + final_report['historical_data'] = { + 'total_interaction_records': len(self.interaction_records), + 'total_warning_logs': len(self.warning_logs), + 'analysis_period': self._get_analysis_period() + } + + # 保存最终报告 + final_file = os.path.join(self.safety_dir, "final_safety_report.json") + with open(final_file, 'w', encoding='utf-8') as f: + json.dump(final_report, f, indent=2, ensure_ascii=False) + + return final_report + + def _get_analysis_period(self) -> Dict: + """获取分析时间段""" + if not self.stats['interaction_times']: + return {'start': None, 'end': None, 'duration': 0} + + start_time = min(self.stats['interaction_times']) + end_time = max(self.stats['interaction_times']) + duration = end_time - start_time + + return { + 'start': datetime.fromtimestamp(start_time).isoformat(), + 'end': datetime.fromtimestamp(end_time).isoformat(), + 'duration_seconds': duration, + 'duration_minutes': duration / 60, + 'duration_hours': duration / 3600 + } + + def save_data(self): + """保存所有数据""" + # 保存统计数据 + stats_file = os.path.join(self.safety_dir, "safety_statistics.json") + with open(stats_file, 'w', encoding='utf-8') as f: + json.dump(self.stats, f, indent=2, ensure_ascii=False) + + # 保存详细记录 + if self.interaction_records: + records_file = os.path.join(self.safety_dir, "interaction_records.json") + with open(records_file, 'w', encoding='utf-8') as f: + json.dump(self.interaction_records, f, indent=2, ensure_ascii=False) + + # 保存警告日志 + self._save_warning_logs() + + # 生成并保存最终报告 + self.generate_final_report() + + print(f"行人安全数据已保存到: {self.safety_dir}") \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/scene_manager.py b/src/enhance_pedestrian_safety/scene_manager.py index dbe424d7d4..f7e081f9ed 100644 --- a/src/enhance_pedestrian_safety/scene_manager.py +++ b/src/enhance_pedestrian_safety/scene_manager.py @@ -45,6 +45,23 @@ class SceneManager: 'vehicle_density': 0.6, 'pedestrian_density': 0.5, 'weather_variations': ['rainy'] + }, + 'school_zone': { + 'description': '学校区域场景 - 行人安全重点', + 'pedestrian_behavior': ['crossing', 'walking', 'playing', 'running'], + 'vehicle_density': 0.4, + 'pedestrian_density': 0.9, + 'weather_variations': ['clear', 'cloudy'], + 'speed_limit': 20.0, + 'safety_zone_radius': 30.0 + }, + 'pedestrian_crossing': { + 'description': '人行横道场景', + 'pedestrian_behavior': ['crossing', 'waiting', 'walking'], + 'vehicle_density': 0.5, + 'pedestrian_density': 0.8, + 'weather_variations': ['clear', 'rainy'], + 'crossing_intensity': 'high' } } @@ -74,6 +91,10 @@ def setup_scene(world, config, scene_type='intersection_4way'): # 设置行人行为 config['traffic']['pedestrian_behaviors'] = scene_config['pedestrian_behavior'] + # 如果是学校区域,设置车速限制 + if scene_type == 'school_zone' and 'speed_limit' in scene_config: + config['traffic']['speed_limit'] = scene_config['speed_limit'] + # 应用场景特定设置 SceneManager._apply_scene_specifics(world, scene_type) @@ -102,9 +123,73 @@ def _apply_scene_specifics(world, scene_type): except: pass + elif scene_type == 'school_zone': + # 学校区域:设置车辆限速和行人保护区域 + for actor in world.get_actors(): + if 'vehicle' in actor.type_id: + try: + # 限制车速 + actor.enable_constant_velocity(carla.Vector3D(15, 0, 0)) + # 开启行人检测警告 + actor.set_light_state(carla.VehicleLightState.LowBeam) + except: + pass + + elif scene_type == 'pedestrian_crossing': + # 人行横道:增加可见性 + for actor in world.get_actors(): + if 'vehicle' in actor.type_id: + try: + actor.set_light_state(carla.VehicleLightState.LowBeam) + except: + pass + except Exception as e: print(f"场景特定设置失败: {e}") + @staticmethod + def spawn_pedestrian_safety_features(world, location, feature_type='crosswalk'): + """生成行人安全设施""" + blueprint_lib = world.get_blueprint_library() + features = [] + + try: + if feature_type == 'crosswalk': + # 生成人行横道标记 + for i in range(-4, 5): + line_location = carla.Location( + x=location.x + i * 0.8, + y=location.y, + z=location.z + 0.02 + ) + rotation = carla.Rotation(0, 0, 0) + + line_bp = blueprint_lib.find('static.prop.linepainting') + if line_bp: + line = world.spawn_actor(line_bp, carla.Transform(line_location, rotation)) + features.append(line) + + elif feature_type == 'speed_bump': + # 生成减速带 + bump_location = carla.Location(location.x, location.y, location.z + 0.1) + bump_bp = blueprint_lib.find('static.prop.speedbump') + if bump_bp: + bump = world.spawn_actor(bump_bp, carla.Transform(bump_location, carla.Rotation(0, 0, 0))) + features.append(bump) + + elif feature_type == 'warning_sign': + # 生成警告标志 + sign_location = carla.Location(location.x, location.y, location.z + 2.0) + sign_bp = blueprint_lib.find('static.prop.trafficsign') + if sign_bp: + sign = world.spawn_actor(sign_bp, carla.Transform(sign_location, carla.Rotation(0, 90, 0))) + features.append(sign) + + except Exception as e: + print(f"生成行人安全设施失败: {e}") + + return features + @staticmethod def spawn_traffic_cones(world, center_location, num_cones=10): """生成交通锥桶""" diff --git a/src/enhance_pedestrian_safety/sensor_enhancer.py b/src/enhance_pedestrian_safety/sensor_enhancer.py index b446c71bbe..3dba1d767b 100644 --- a/src/enhance_pedestrian_safety/sensor_enhancer.py +++ b/src/enhance_pedestrian_safety/sensor_enhancer.py @@ -778,6 +778,60 @@ def generate_enhancement_report(self, output_dir: str) -> Dict: return report + def _add_pedestrian_detection_markers(self, image: np.ndarray, pedestrians: List[Dict]) -> np.ndarray: + """添加行人检测标记""" + if not pedestrians: + return image + + # 创建副本 + marked_image = image.copy() + + for pedestrian in pedestrians: + # 模拟行人检测框 + x = random.randint(100, image.shape[1] - 100) + y = random.randint(100, image.shape[0] - 100) + width = random.randint(30, 80) + height = random.randint(80, 180) + + # 绘制检测框 + color = (0, 255, 0) # 绿色表示安全 + thickness = 2 + + cv2.rectangle(marked_image, (x, y), (x + width, y + height), color, thickness) + + # 添加标签 + label = f"Pedestrian {pedestrian.get('distance', 0):.1f}m" + cv2.putText(marked_image, label, (x, y - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, thickness) + + return marked_image + + def _simulate_safety_warnings(self, image: np.ndarray, warnings: List[Dict]) -> np.ndarray: + """模拟安全警告""" + if not warnings: + return image + + warning_image = image.copy() + + for warning in warnings[:2]: # 最多显示2个警告 + # 添加警告文本 + text = f"WARNING: {warning.get('type', 'Pedestrian')} {warning.get('distance', 0):.1f}m" + color = (0, 0, 255) # 红色表示警告 + thickness = 2 + + position = (50, 50 + warnings.index(warning) * 40) + cv2.putText(warning_image, text, position, + cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, thickness) + + # 添加警告图标 + icon_size = 30 + icon_position = (position[0] - icon_size - 10, position[1] - icon_size // 2) + cv2.rectangle(warning_image, icon_position, + (icon_position[0] + icon_size, icon_position[1] + icon_size), + color, -1) # 填充红色矩形 + + return warning_image + # 保持向后兼容的类 class SensorCalibrator: From aa12359073e2a6e66aebf0f3e887c419cb096c96 Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Thu, 25 Dec 2025 20:37:07 +0800 Subject: [PATCH 20/21] =?UTF-8?q?=E5=9C=BA=E6=99=AF=E7=AE=A1=E7=90=86?= =?UTF-8?q?=E5=A2=9E=E5=BC=BA,=E4=BC=A0=E6=84=9F=E5=99=A8=E5=A2=9E?= =?UTF-8?q?=E5=BC=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../annotation_generator.py | 59 +++- src/enhance_pedestrian_safety/carla_utils.py | 1 - .../config_manager.py | 87 +++-- src/enhance_pedestrian_safety/main.py | 72 +++- .../multi_vehicle_manager.py | 92 ++--- .../pedestrian_safety_monitor.py | 287 +++++++++++++--- .../scene_manager.py | 80 ++++- .../sensor_enhancer.py | 323 +++++++----------- .../v2x_communication.py | 69 ++-- 9 files changed, 682 insertions(+), 388 deletions(-) diff --git a/src/enhance_pedestrian_safety/annotation_generator.py b/src/enhance_pedestrian_safety/annotation_generator.py index d443854d96..734fa91616 100644 --- a/src/enhance_pedestrian_safety/annotation_generator.py +++ b/src/enhance_pedestrian_safety/annotation_generator.py @@ -21,7 +21,12 @@ def detect_objects(self, world, frame_num, timestamp): 'frame_id': frame_num, 'timestamp': timestamp, 'objects': [], - 'camera_info': {} + 'camera_info': {}, + 'safety_info': { + 'pedestrian_count': 0, + 'vehicle_count': 0, + 'high_risk_interactions': 0 + } } try: @@ -36,6 +41,16 @@ def detect_objects(self, world, frame_num, timestamp): annotations['objects'].append(obj_info) self.object_counter += 1 + # 更新安全统计 + if 'walker' in obj_type: + annotations['safety_info']['pedestrian_count'] += 1 + elif 'vehicle' in obj_type: + annotations['safety_info']['vehicle_count'] += 1 + + # 检测高风险交互 + annotations['safety_info']['high_risk_interactions'] = self._detect_high_risk_interactions( + annotations['objects']) + self._save_annotations(frame_num, annotations) return annotations @@ -110,6 +125,30 @@ def _get_object_class(self, type_id): else: return 'unknown' + def _detect_high_risk_interactions(self, objects): + """检测高风险交互""" + high_risk_count = 0 + pedestrians = [obj for obj in objects if obj['class'] == 'pedestrian'] + vehicles = [obj for obj in objects if obj['class'] in ['car', 'vehicle']] + + for pedestrian in pedestrians: + for vehicle in vehicles: + # 计算距离 + p_loc = pedestrian['location'] + v_loc = vehicle['location'] + + distance = np.sqrt( + (p_loc['x'] - v_loc['x']) ** 2 + + (p_loc['y'] - v_loc['y']) ** 2 + + (p_loc['z'] - v_loc['z']) ** 2 + ) + + # 如果距离小于5米,认为是高风险交互 + if distance < 5.0: + high_risk_count += 1 + + return high_risk_count + def _save_annotations(self, frame_num, annotations): """保存标注到文件""" filename = f"frame_{frame_num:06d}.json" @@ -130,7 +169,13 @@ def _update_master_annotation(self): 'total_frames': len(self.frame_annotations), 'total_objects': self.object_counter, 'frames': list(self.frame_annotations.keys()), - 'created': datetime.now().isoformat() + 'created': datetime.now().isoformat(), + 'safety_summary': { + 'total_pedestrians': sum(f['safety_info']['pedestrian_count'] for f in self.frame_annotations.values()), + 'total_vehicles': sum(f['safety_info']['vehicle_count'] for f in self.frame_annotations.values()), + 'total_high_risk': sum( + f['safety_info']['high_risk_interactions'] for f in self.frame_annotations.values()) + } } with open(master_file, 'w', encoding='utf-8') as f: @@ -141,6 +186,7 @@ def generate_summary(self): vehicle_count = 0 pedestrian_count = 0 other_count = 0 + high_risk_count = 0 for frame_data in self.frame_annotations.values(): for obj in frame_data.get('objects', []): @@ -151,14 +197,21 @@ def generate_summary(self): else: other_count += 1 + high_risk_count += frame_data['safety_info']['high_risk_interactions'] + summary = { 'total_frames': len(self.frame_annotations), 'total_objects': self.object_counter, 'vehicles': vehicle_count, 'pedestrians': pedestrian_count, 'other_objects': other_count, + 'high_risk_interactions': high_risk_count, 'average_objects_per_frame': self.object_counter / len( - self.frame_annotations) if self.frame_annotations else 0 + self.frame_annotations) if self.frame_annotations else 0, + 'safety_metrics': { + 'pedestrian_to_vehicle_ratio': pedestrian_count / max(1, vehicle_count), + 'high_risk_percentage': high_risk_count / max(1, self.object_counter) * 100 + } } summary_file = os.path.join(self.annotations_dir, "summary.json") diff --git a/src/enhance_pedestrian_safety/carla_utils.py b/src/enhance_pedestrian_safety/carla_utils.py index 0fd30ef025..349f4e7c78 100644 --- a/src/enhance_pedestrian_safety/carla_utils.py +++ b/src/enhance_pedestrian_safety/carla_utils.py @@ -1,7 +1,6 @@ """ CARLA 工具模块 - 用于自动查找和配置 CARLA 路径 """ -# carla_utils.py import sys import os import glob diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index aa07724783..7276b09a15 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -6,6 +6,7 @@ try: import yaml + YAML_AVAILABLE = True except ImportError: YAML_AVAILABLE = False @@ -65,6 +66,13 @@ def suggest_optimizations(config: Dict[str, Any]) -> List[str]: if len(enabled_outputs) > 5: suggestions.append(f"启用的输出类型过多({len(enabled_outputs)}),可能影响性能,建议只启用必要的输出") + # 行人安全相关建议 + if config.get('traffic', {}).get('pedestrians', 0) < 5: + suggestions.append("行人数量较少,建议增加行人数量以更好地测试行人安全") + + if not config.get('v2x', {}).get('enabled', False): + suggestions.append("V2X通信未启用,建议启用以支持行人安全预警") + return suggestions @@ -193,7 +201,8 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'walker.pedestrian.0002', 'walker.pedestrian.0003', 'walker.pedestrian.0004' - ] + ], + 'speed_limit': 30.0 # 添加车速限制 }) # 优化传感器配置以更好地检测行人 @@ -225,7 +234,9 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: v2x.update({ 'enabled': True, 'communication_range': 300.0, - 'update_interval': 1.0 # 更频繁地更新 + 'update_interval': 1.0, # 更频繁地更新 + 'enable_safety_warnings': True, + 'pedestrian_warning_threshold': 10.0 # 行人警告距离阈值 }) coop = optimized.setdefault('cooperative', {}) @@ -233,6 +244,7 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'num_coop_vehicles': 2, 'enable_shared_perception': True, 'enable_traffic_warnings': True, + 'enable_pedestrian_warnings': True, # 启用行人警告 'enable_maneuver_coordination': False, 'data_fusion_interval': 0.5, # 更频繁地融合 'max_shared_objects': 100, @@ -247,7 +259,8 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'compression_level': 3, 'enable_memory_cache': True, 'max_cache_size': 40, - 'frame_rate_limit': 8.0 + 'frame_rate_limit': 8.0, + 'safety_monitoring_interval': 1.0 # 安全监控间隔 }) # 输出配置 @@ -260,16 +273,33 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'save_fusion': True, 'save_cooperative': True, 'save_enhanced': True, + 'save_safety_reports': True, # 保存安全报告 'validate_data': True, 'run_analysis': True, - 'run_quality_check': True + 'run_quality_check': True, + 'generate_safety_summary': True # 生成安全摘要 + }) + + # 增强配置 + enhanced = optimized.setdefault('enhancement', {}) + enhanced.update({ + 'enabled': True, + 'enable_random': True, + 'quality_check': True, + 'save_original': True, + 'save_enhanced': True, + 'calibration_generation': True, + 'enhanced_dir_name': 'enhanced', + 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', 'safety_warning'], + 'weather_effects': True, + 'augmentation_level': 'medium', + 'pedestrian_safety_mode': True # 启用行人安全模式 }) return optimized class ConfigManager: - PRESET_CONFIGS = { 'balanced': { 'description': '平衡配置 - 兼顾性能和质量', @@ -338,8 +368,8 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) def _get_default_config() -> Dict[str, Any]: return { 'scenario': { - 'name': 'multi_sensor_scene', - 'description': '多传感器协同数据采集场景', + 'name': 'pedestrian_safety', + 'description': '行人安全增强数据采集场景', 'town': 'Town10HD', 'weather': 'clear', 'time_of_day': 'noon', @@ -351,7 +381,7 @@ def _get_default_config() -> Dict[str, Any]: 'traffic': { 'ego_vehicles': 1, 'background_vehicles': 8, - 'pedestrians': 6, + 'pedestrians': 12, # 增加默认行人数量 'traffic_lights': True, 'batch_spawn': True, 'max_spawn_attempts': 5, @@ -363,8 +393,11 @@ def _get_default_config() -> Dict[str, Any]: ], 'pedestrian_types': [ 'walker.pedestrian.0001', - 'walker.pedestrian.0002' - ] + 'walker.pedestrian.0002', + 'walker.pedestrian.0003', + 'walker.pedestrian.0004' + ], + 'speed_limit': 30.0 }, 'sensors': { 'vehicle_cameras': 4, @@ -406,16 +439,19 @@ def _get_default_config() -> Dict[str, Any]: 'latency_mean': 0.05, 'latency_std': 0.01, 'packet_loss_rate': 0.01, - 'message_types': ['bsm', 'spat', 'map', 'rsm', 'perception', 'warning'], + 'message_types': ['bsm', 'spat', 'map', 'rsm', 'perception', 'warning', 'pedestrian_warning'], 'update_interval': 2.0, 'security_enabled': False, 'encryption_level': 'none', - 'qos_policy': 'best_effort' + 'qos_policy': 'best_effort', + 'enable_safety_warnings': True, + 'pedestrian_warning_threshold': 10.0 }, 'cooperative': { 'num_coop_vehicles': 2, 'enable_shared_perception': True, 'enable_traffic_warnings': True, + 'enable_pedestrian_warnings': True, 'enable_maneuver_coordination': False, 'data_fusion_interval': 1.0, 'max_shared_objects': 50, @@ -431,9 +467,10 @@ def _get_default_config() -> Dict[str, Any]: 'save_enhanced': True, 'calibration_generation': True, 'enhanced_dir_name': 'enhanced', - 'methods': ['normalize', 'contrast', 'brightness'], + 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', 'safety_warning'], 'weather_effects': True, - 'augmentation_level': 'medium' + 'augmentation_level': 'medium', + 'pedestrian_safety_mode': True }, 'performance': { 'batch_size': 5, @@ -468,6 +505,7 @@ def _get_default_config() -> Dict[str, Any]: }, 'sensor_cleanup_timeout': 0.5, 'frame_rate_limit': 5.0, + 'safety_monitoring_interval': 1.0, 'memory_management': { 'gc_interval': 50, 'max_memory_mb': 500, @@ -479,16 +517,18 @@ def _get_default_config() -> Dict[str, Any]: 'output_format': 'standard', 'save_raw': True, 'save_stitched': True, - 'save_annotations': False, + 'save_annotations': True, 'save_lidar': True, 'save_fusion': True, 'save_cooperative': True, 'save_v2x_messages': True, 'save_enhanced': True, + 'save_safety_reports': True, 'validate_data': True, - 'run_analysis': False, + 'run_analysis': True, 'run_quality_check': True, 'generate_summary': True, + 'generate_safety_summary': True, 'compression_enabled': True, 'file_naming': 'sequential', 'backup_original': False @@ -501,7 +541,9 @@ def _get_default_config() -> Dict[str, Any]: 'performance_log_interval': 10.0, 'enable_progress_bar': True, 'enable_real_time_stats': True, - 'stats_update_interval': 5.0 + 'stats_update_interval': 5.0, + 'enable_safety_monitor': True, + 'safety_log_interval': 2.0 }, 'debug': { 'enable_debug_mode': False, @@ -514,7 +556,7 @@ def _get_default_config() -> Dict[str, Any]: 'metadata': { 'version': '1.0.0', 'author': 'CVIPS System', - 'description': '多传感器协同数据采集配置', + 'description': '行人安全增强数据采集配置', 'created': '', 'modified': '' } @@ -686,6 +728,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 主车: {traffic['ego_vehicles']}") print(f" 背景车辆: {traffic['background_vehicles']}") print(f" 行人: {traffic['pedestrians']}") + print(f" 车速限制: {traffic.get('speed_limit', '无')} km/h") print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") sensors = config['sensors'] @@ -702,12 +745,13 @@ def print_config_summary(config: Dict[str, Any]): if v2x['enabled']: print(f" 通信范围: {v2x['communication_range']}米") print(f" 更新间隔: {v2x['update_interval']}秒") + print(f" 安全警告: {'启用' if v2x.get('enable_safety_warnings', False) else '禁用'}") coop = config['cooperative'] print(f"\n🤝 协同感知:") print(f" 协同车辆: {coop['num_coop_vehicles']}") print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") - print(f" 交通警告: {'启用' if coop['enable_traffic_warnings'] else '禁用'}") + print(f" 行人警告: {'启用' if coop.get('enable_pedestrian_warnings', False) else '禁用'}") perf = config['performance'] print(f"\n⚡ 性能:") @@ -715,6 +759,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 压缩: {'启用' if perf['enable_compression'] else '禁用'}") print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") print(f" 帧率限制: {perf['frame_rate_limit']} FPS") + print(f" 安全监控间隔: {perf.get('safety_monitoring_interval', 1.0)}秒") output = config['output'] print(f"\n💾 输出:") @@ -724,6 +769,10 @@ def print_config_summary(config: Dict[str, Any]): if isinstance(v, bool) and v and k.startswith('save_')] print(f" 启用输出: {', '.join(enabled_outputs)}") + print(f"\n🛡️ 行人安全:") + print(f" 安全监控: {'启用' if config['monitoring'].get('enable_safety_monitor', False) else '禁用'}") + print(f" 增强安全模式: {'启用' if config['enhancement'].get('pedestrian_safety_mode', False) else '禁用'}") + print("=" * 60) @staticmethod diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index 2626fe0a82..bfd920d8f4 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python3 +# !/usr/bin/env python3 import sys import os import time @@ -17,7 +17,6 @@ from config_manager import ConfigManager from annotation_generator import AnnotationGenerator from data_validator import DataValidator -from data_analyzer import DataAnalyzer from lidar_processor import LidarProcessor, MultiSensorFusion from multi_vehicle_manager import MultiVehicleManager from pedestrian_safety_monitor import PedestrianSafetyMonitor @@ -488,7 +487,7 @@ def _spawn_vehicles(self): def _spawn_pedestrians(self, center_location): blueprint_lib = self.world.get_blueprint_library() - num_peds = min(self.config['traffic']['pedestrians'], 8) + num_peds = min(self.config['traffic']['pedestrians'], 12) # 增加行人数量 spawned = 0 for _ in range(num_peds): @@ -499,8 +498,13 @@ def _spawn_pedestrians(self, center_location): ped_bp = random.choice(ped_bps) - angle = random.uniform(0, 2 * math.pi) - distance = random.uniform(5.0, 12.0) + # 在学校区域或人行横道场景中,行人更集中 + if self.config.get('scenario', {}).get('name', '').lower() in ['school_zone', 'pedestrian_crossing']: + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(3.0, 8.0) # 更靠近中心 + else: + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(5.0, 15.0) location = carla.Location( x=center_location.x + distance * math.cos(angle), @@ -1090,7 +1094,6 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) - # 初始化行人安全监控器 self.safety_monitor = PedestrianSafetyMonitor(self.world, self.output_dir) time.sleep(3.0) @@ -1183,7 +1186,9 @@ def collect_data(self): if current_time - last_safety_check >= 1.0 and self.safety_monitor: safety_report = self.safety_monitor.check_pedestrian_safety() if safety_report['risk_distribution']['high'] > 0: - Log.safety(f"行人安全警告: {safety_report['high_risk_cases']}个高风险情况") + Log.safety(f"行人安全警告: {safety_report['risk_distribution']['high']}个高风险情况") + # 广播行人警告 + self._broadcast_pedestrian_warnings(safety_report) last_safety_check = current_time if current_time - last_performance_sample >= 10.0: @@ -1253,6 +1258,7 @@ def collect_data(self): final_report = self.safety_monitor.generate_final_report() Log.safety( f"行人安全报告: {final_report['risk_distribution']['high']}高风险, {final_report['risk_distribution']['medium']}中风险") + Log.safety(f"行人安全评分: {final_report['safety_score']:.1f}/100") else: Log.warning("未收集到任何数据帧") @@ -1262,6 +1268,44 @@ def collect_data(self): if self.output_format != 'standard': self._convert_to_target_format() + def _broadcast_pedestrian_warnings(self, safety_report): + """广播行人警告""" + if not self.multi_vehicle_manager: + return + + # 检查高风险交互 + if safety_report.get('risk_distribution', {}).get('high', 0) > 0: + for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: + continue + + try: + location = vehicle.get_location() + velocity = vehicle.get_velocity() + speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) + + # 模拟行人位置(实际应用中应从感知系统获取) + pedestrian_location = ( + location.x + random.uniform(-5, 5), + location.y + random.uniform(-5, 5), + location.z + ) + + distance = math.sqrt( + (location.x - pedestrian_location[0]) ** 2 + + (location.y - pedestrian_location[1]) ** 2 + ) + + if distance < 20.0: # 只广播近距离行人 + self.multi_vehicle_manager.share_pedestrian_warning( + vehicle.id, + pedestrian_location, + distance, + speed + ) + except: + pass + def _force_memory_cleanup(self): Log.info("执行强制内存清理...") @@ -1646,17 +1690,12 @@ def run_validation(self): Log.info("运行数据验证...") DataValidator.validate_dataset(self.output_dir) - def run_analysis(self): - if self.config['output'].get('run_analysis', False) and self.collected_frames > 0: - Log.info("运行数据分析...") - DataAnalyzer.analyze_dataset(self.output_dir) - def main(): - parser = argparse.ArgumentParser(description='CVIPS 性能优化数据收集系统') + parser = argparse.ArgumentParser(description='CVIPS 行人安全增强数据收集系统') parser.add_argument('--config', type=str, help='配置文件路径') - parser.add_argument('--scenario', type=str, default='performance_optimized', help='场景名称') + parser.add_argument('--scenario', type=str, default='pedestrian_safety', help='场景名称') parser.add_argument('--town', type=str, default='Town10HD', choices=['Town03', 'Town04', 'Town05', 'Town10HD'], help='地图') parser.add_argument('--weather', type=str, default='clear', @@ -1665,7 +1704,7 @@ def main(): choices=['noon', 'sunset', 'night'], help='时间') parser.add_argument('--num-vehicles', type=int, default=8, help='背景车辆数') - parser.add_argument('--num-pedestrians', type=int, default=6, help='行人数') + parser.add_argument('--num-pedestrians', type=int, default=12, help='行人数') parser.add_argument('--num-coop-vehicles', type=int, default=2, help='协同车辆数') parser.add_argument('--duration', type=int, default=60, help='收集时长(秒)') @@ -1702,7 +1741,7 @@ def main(): config['output']['output_format'] = args.output_format print("\n" + "=" * 60) - print("CVIPS 性能优化数据收集系统 - 行人安全增强版") + print("CVIPS 行人安全增强数据收集系统") print("=" * 60) print(f"场景: {config['scenario']['name']}") @@ -1747,7 +1786,6 @@ def main(): collector.collect_data() - collector.run_analysis() collector.run_validation() except KeyboardInterrupt: diff --git a/src/enhance_pedestrian_safety/multi_vehicle_manager.py b/src/enhance_pedestrian_safety/multi_vehicle_manager.py index 62fcd37cf8..bb9edaafb5 100644 --- a/src/enhance_pedestrian_safety/multi_vehicle_manager.py +++ b/src/enhance_pedestrian_safety/multi_vehicle_manager.py @@ -40,7 +40,7 @@ def __init__(self, world, config, output_dir): self.config = config self.output_dir = output_dir - # 创建协同数据目录 - 确保所有子目录都创建 + # 创建协同数据目录 self.coop_dir = os.path.join(output_dir, "cooperative") os.makedirs(self.coop_dir, exist_ok=True) @@ -59,8 +59,8 @@ def __init__(self, world, config, output_dir): # V2X通信 self.v2x_messages = [] - self.communication_range = config.get('v2x', {}).get('communication_range', 300.0) # 通信范围 - self.message_buffer = defaultdict(list) # 车辆ID -> 接收的消息列表 + self.communication_range = config.get('v2x', {}).get('communication_range', 300.0) + self.message_buffer = defaultdict(list) # 协同感知 self.shared_objects = [] # 共享的感知对象 @@ -71,7 +71,9 @@ def __init__(self, world, config, output_dir): 'total_messages': 0, 'successful_transmissions': 0, 'collaborative_detections': 0, - 'data_exchange_mb': 0.0 + 'data_exchange_mb': 0.0, + 'pedestrian_warnings_sent': 0, + 'safety_alerts': 0 } def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor]: @@ -83,7 +85,6 @@ def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor] print("警告:无生成点") return [] - # 车辆类型 vehicle_types = [ 'vehicle.tesla.model3', 'vehicle.audi.tt', @@ -96,17 +97,13 @@ def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor] for i in range(min(num_vehicles, len(spawn_points))): try: - # 选择车辆类型 vtype = random.choice(vehicle_types) vehicle_bp = random.choice(blueprint_lib.filter(vtype)) - # 设置车辆属性 vehicle_bp.set_attribute('role_name', f'coop_vehicle_{i}') - # 选择生成点 spawn_point = spawn_points[i % len(spawn_points)] - # 调整位置,使车辆不在同一位置 offset_x = random.uniform(-5.0, 5.0) offset_y = random.uniform(-5.0, 5.0) location = carla.Location( @@ -115,7 +112,6 @@ def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor] z=spawn_point.location.z ) - # 轻微调整朝向 rotation = carla.Rotation( pitch=spawn_point.rotation.pitch, yaw=spawn_point.rotation.yaw + random.uniform(-15, 15), @@ -124,17 +120,12 @@ def spawn_cooperative_vehicles(self, num_vehicles: int = 3) -> List[carla.Actor] transform = carla.Transform(location, rotation) - # 生成车辆 vehicle = self.world.spawn_actor(vehicle_bp, transform) - - # 设置自动驾驶 vehicle.set_autopilot(True) - # 添加到列表 self.cooperative_vehicles.append(vehicle) spawned_vehicles.append(vehicle) - # 初始化车辆状态 self.vehicle_states[vehicle.id] = VehicleState( vehicle_id=vehicle.id, type_id=vehicle.type_id, @@ -183,7 +174,7 @@ def create_v2x_message(self, sender_id: int, message_type: str, data: Dict, message_type=message_type, data=data, timestamp=time.time(), - ttl=5.0, # 5秒生存时间 + ttl=5.0, priority=priority ) @@ -202,13 +193,11 @@ def broadcast_message(self, message: V2XMessage): recipients = [] - # 检查所有车辆是否在通信范围内 for vehicle in self.ego_vehicles + self.cooperative_vehicles: if vehicle.id != message.sender_id and vehicle.id in self.vehicle_states: receiver_state = self.vehicle_states[vehicle.id] receiver_pos = receiver_state.position - # 计算距离 distance = math.sqrt( (sender_pos[0] - receiver_pos[0]) ** 2 + (sender_pos[1] - receiver_pos[1]) ** 2 + @@ -218,7 +207,6 @@ def broadcast_message(self, message: V2XMessage): if distance <= self.communication_range: recipients.append(vehicle.id) - # 添加到接收者消息缓冲区 self.message_buffer[vehicle.id].append({ 'message': message, 'receive_time': time.time(), @@ -228,7 +216,6 @@ def broadcast_message(self, message: V2XMessage): if recipients: self.stats['successful_transmissions'] += len(recipients) - # 保存消息 try: self._save_v2x_message(message, recipients) except Exception as e: @@ -242,7 +229,6 @@ def share_perception_data(self, vehicle_id: int, detected_objects: List[Dict]): return None try: - # 创建感知消息 perception_data = { 'vehicle_id': vehicle_id, 'timestamp': time.time(), @@ -255,13 +241,11 @@ def share_perception_data(self, vehicle_id: int, detected_objects: List[Dict]): vehicle_id, 'perception', perception_data, - priority=2 # 感知数据优先级较高 + priority=2 ) - # 广播消息 recipients = self.broadcast_message(message) - # 融合共享的感知数据 if recipients: self._fuse_shared_perception(vehicle_id, detected_objects, recipients) @@ -276,7 +260,7 @@ def share_traffic_warning(self, vehicle_id: int, warning_type: str, """共享交通警告""" try: warning_data = { - 'warning_type': warning_type, # 'accident', 'congestion', 'hazard', 'construction' + 'warning_type': warning_type, 'location': location, 'severity': severity, 'timestamp': time.time(), @@ -287,7 +271,7 @@ def share_traffic_warning(self, vehicle_id: int, warning_type: str, vehicle_id, 'warning', warning_data, - priority=3 # 警告消息优先级最高 + priority=3 ) self.broadcast_message(message) @@ -298,9 +282,19 @@ def share_traffic_warning(self, vehicle_id: int, warning_type: str, return None def share_pedestrian_warning(self, vehicle_id: int, pedestrian_location: Tuple[float, float, float], - distance: float, speed: float): + distance: float, speed: float, pedestrian_id: Optional[int] = None): """共享行人警告""" try: + # 风险评估 + if distance < 5.0: + severity = 'critical' + elif distance < 10.0: + severity = 'high' + elif distance < 20.0: + severity = 'medium' + else: + severity = 'low' + warning_data = { 'warning_type': 'pedestrian', 'pedestrian_location': pedestrian_location, @@ -308,7 +302,9 @@ def share_pedestrian_warning(self, vehicle_id: int, pedestrian_location: Tuple[f 'vehicle_speed': speed, 'timestamp': time.time(), 'source_vehicle': vehicle_id, - 'severity': 'high' if distance < 10.0 else 'medium' if distance < 20.0 else 'low' + 'pedestrian_id': pedestrian_id, + 'severity': severity, + 'recommended_action': self._get_recommended_action(distance, speed, severity) } message = self.create_v2x_message( @@ -320,27 +316,39 @@ def share_pedestrian_warning(self, vehicle_id: int, pedestrian_location: Tuple[f recipients = self.broadcast_message(message) + # 更新统计 + self.stats['pedestrian_warnings_sent'] += 1 + if severity in ['critical', 'high']: + self.stats['safety_alerts'] += 1 + return message, recipients except Exception as e: print(f"共享行人警告失败: {e}") return None, [] + def _get_recommended_action(self, distance: float, speed: float, severity: str) -> str: + """获取推荐的安全措施""" + if severity == 'critical': + return "立即紧急制动,准备避让" + elif severity == 'high': + return "减速至20km/h以下,准备制动" + elif severity == 'medium': + return "减速至30km/h,保持警惕" + else: + return "保持当前速度,注意观察" + def _fuse_shared_perception(self, source_id: int, objects: List[Dict], recipients: List[int]): """融合共享的感知数据""" fused_objects = [] for obj in objects: - # 转换为全局坐标系(简化处理,实际需要坐标变换) global_obj = obj.copy() global_obj['source_vehicles'] = [source_id] - global_obj['confidence'] = obj.get('confidence', 0.8) # 降低置信度 + global_obj['confidence'] = obj.get('confidence', 0.8) - # 检查是否已有类似对象 matched = False for existing_obj in self.shared_objects: - # 简单的对象匹配(基于位置) if self._objects_match(global_obj, existing_obj): - # 更新现有对象 existing_obj['source_vehicles'].append(source_id) existing_obj['confidence'] = min(1.0, existing_obj.get('confidence', 0) + 0.1) existing_obj['update_time'] = time.time() @@ -353,11 +361,10 @@ def _fuse_shared_perception(self, source_id: int, objects: List[Dict], recipient self.shared_objects.extend(fused_objects) - # 清理旧对象 current_time = time.time() self.shared_objects = [ obj for obj in self.shared_objects - if current_time - obj.get('detection_time', 0) < 10.0 # 保留10秒内的对象 + if current_time - obj.get('detection_time', 0) < 10.0 ] if fused_objects: @@ -368,7 +375,6 @@ def _objects_match(self, obj1: Dict, obj2: Dict, distance_threshold: float = 5.0 if obj1.get('class') != obj2.get('class'): return False - # 计算位置距离 pos1 = obj1.get('position', {'x': 0, 'y': 0, 'z': 0}) pos2 = obj2.get('position', {'x': 0, 'y': 0, 'z': 0}) @@ -385,23 +391,20 @@ def get_shared_perception_for_vehicle(self, vehicle_id: int) -> List[Dict]: shared_data = [] for obj in self.shared_objects: - # 检查对象是否在车辆视野内(简化) shared_data.append(obj) return shared_data def coordinate_maneuvers(self, maneuvers: List[Dict]): """协调多车辆机动""" - # 分配优先级和时序 coordinated = [] for i, maneuver in enumerate(maneuvers): coordinated_maneuver = maneuver.copy() coordinated_maneuver['sequence'] = i - coordinated_maneuver['start_time'] = time.time() + i * 2.0 # 间隔2秒 + coordinated_maneuver['start_time'] = time.time() + i * 2.0 coordinated.append(coordinated_maneuver) - # 发送协调消息 message = self.create_v2x_message( maneuver.get('vehicle_id', 0), 'coordination', @@ -421,7 +424,6 @@ def _save_v2x_message(self, message: V2XMessage, recipients: List[int]): 'transmission_time': time.time() } - # 确保目录存在 v2x_messages_dir = os.path.join(self.coop_dir, "v2x_messages") os.makedirs(v2x_messages_dir, exist_ok=True) @@ -446,7 +448,6 @@ def save_shared_perception(self, frame_num: int): 'stats': self.stats } - # 确保目录存在 shared_perception_dir = os.path.join(self.coop_dir, "shared_perception") os.makedirs(shared_perception_dir, exist_ok=True) @@ -467,7 +468,12 @@ def generate_summary(self): 'shared_objects_count': len(self.shared_objects), 'communication_range': self.communication_range, 'average_messages_per_vehicle': self.stats['total_messages'] / max(1, len(self.ego_vehicles) + len( - self.cooperative_vehicles)) + self.cooperative_vehicles)), + 'safety_metrics': { + 'pedestrian_warnings': self.stats['pedestrian_warnings_sent'], + 'safety_alerts': self.stats['safety_alerts'], + 'collaborative_detections': self.stats['collaborative_detections'] + } } filepath = os.path.join(self.coop_dir, "cooperative_summary.json") diff --git a/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py b/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py index 5ec545f100..c5513fa9c4 100644 --- a/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py +++ b/src/enhance_pedestrian_safety/pedestrian_safety_monitor.py @@ -19,17 +19,22 @@ def __init__(self, world, output_dir): # 安全参数 self.safety_thresholds = { + 'critical_distance': 2.0, # 临界距离 (米) 'high_risk_distance': 5.0, # 高风险距离 (米) 'medium_risk_distance': 10.0, # 中风险距离 (米) 'low_risk_distance': 20.0, # 低风险距离 (米) 'safe_speed_limit': 30.0, # 安全速度限制 (km/h) 'reaction_time': 1.5, # 反应时间 (秒) - 'braking_deceleration': 6.0 # 制动减速度 (m/s²) + 'braking_deceleration': 6.0, # 制动减速度 (m/s²) + 'ttc_critical': 1.0, # 临界碰撞时间 (秒) + 'ttc_high': 2.0, # 高风险碰撞时间 (秒) + 'ttc_medium': 3.0 # 中风险碰撞时间 (秒) } # 统计数据 self.stats = { 'total_interactions': 0, + 'critical_cases': 0, 'high_risk_cases': 0, 'medium_risk_cases': 0, 'low_risk_cases': 0, @@ -39,12 +44,17 @@ def __init__(self, world, output_dir): 'average_distance': 0, 'min_distance': float('inf'), 'max_distance': 0, - 'interaction_times': [] + 'average_ttc': 0, + 'min_ttc': float('inf'), + 'interaction_times': [], + 'vehicle_speeds': [], + 'pedestrian_speeds': [] } # 详细记录 self.interaction_records = [] self.warning_logs = [] + self.critical_events = [] def check_pedestrian_safety(self) -> Dict: """检查行人安全""" @@ -60,19 +70,19 @@ def check_pedestrian_safety(self) -> Dict: for pedestrian in pedestrians: pedestrian_location = pedestrian.get_location() + pedestrian_velocity = pedestrian.get_velocity() # 计算距离 distance = vehicle_location.distance(pedestrian_location) # 计算相对速度 - pedestrian_velocity = pedestrian.get_velocity() relative_speed = self._calculate_relative_speed(vehicle_velocity, pedestrian_velocity) # 计算碰撞时间 time_to_collision = self._calculate_ttc(distance, relative_speed) # 评估风险 - risk_level = self._assess_risk(distance, vehicle_speed, time_to_collision) + risk_level = self._assess_risk(distance, vehicle_speed, time_to_collision, relative_speed) interaction = { 'timestamp': time.time(), @@ -80,6 +90,7 @@ def check_pedestrian_safety(self) -> Dict: 'pedestrian_id': pedestrian.id, 'distance': distance, 'vehicle_speed': vehicle_speed * 3.6, # 转换为km/h + 'pedestrian_speed': math.sqrt(pedestrian_velocity.x ** 2 + pedestrian_velocity.y ** 2) * 3.6, 'relative_speed': relative_speed * 3.6, 'time_to_collision': time_to_collision if time_to_collision < 100 else None, 'risk_level': risk_level, @@ -92,7 +103,9 @@ def check_pedestrian_safety(self) -> Dict: 'x': pedestrian_location.x, 'y': pedestrian_location.y, 'z': pedestrian_location.z - } + }, + 'safety_measures': self._suggest_safety_measures(distance, vehicle_speed, time_to_collision, + risk_level) } current_interactions.append(interaction) @@ -100,9 +113,9 @@ def check_pedestrian_safety(self) -> Dict: # 更新统计 self._update_stats(interaction) - # 记录高风险情况 - if risk_level == 'high': - self._log_high_risk(interaction) + # 记录高风险和临界情况 + if risk_level in ['critical', 'high']: + self._log_risk_event(interaction) # 保存当前检查结果 if current_interactions: @@ -124,22 +137,33 @@ def _calculate_relative_speed(self, v1: carla.Vector3D, v2: carla.Vector3D) -> f def _calculate_ttc(self, distance: float, relative_speed: float) -> float: """计算碰撞时间 (Time to Collision)""" - if relative_speed > 0.1: # 避免除以零 + if relative_speed > 0.1: return distance / relative_speed return float('inf') - def _assess_risk(self, distance: float, speed: float, ttc: Optional[float]) -> str: + def _assess_risk(self, distance: float, speed: float, ttc: Optional[float], relative_speed: float) -> str: """评估风险等级""" speed_kmh = speed * 3.6 + # 基于碰撞时间的风险评估 + if ttc is not None: + if ttc < self.safety_thresholds['ttc_critical']: + return 'critical' + elif ttc < self.safety_thresholds['ttc_high']: + return 'high' + elif ttc < self.safety_thresholds['ttc_medium']: + return 'medium' + # 基于距离的风险评估 - if distance < self.safety_thresholds['high_risk_distance']: - if ttc is not None and ttc < 2.0: + if distance < self.safety_thresholds['critical_distance']: + return 'critical' + elif distance < self.safety_thresholds['high_risk_distance']: + if speed_kmh > self.safety_thresholds['safe_speed_limit']: return 'high' else: return 'medium' elif distance < self.safety_thresholds['medium_risk_distance']: - if speed_kmh > self.safety_thresholds['safe_speed_limit']: + if speed_kmh > self.safety_thresholds['safe_speed_limit'] * 1.5: return 'medium' else: return 'low' @@ -148,10 +172,65 @@ def _assess_risk(self, distance: float, speed: float, ttc: Optional[float]) -> s else: return 'safe' + def _suggest_safety_measures(self, distance: float, speed: float, ttc: Optional[float], risk_level: str) -> List[ + str]: + """建议安全措施""" + measures = [] + speed_kmh = speed * 3.6 + + if risk_level == 'critical': + measures.extend([ + "立即紧急制动", + "鸣喇叭警告行人", + "准备紧急避让", + "向其他车辆发送紧急警告", + "记录事故数据" + ]) + elif risk_level == 'high': + measures.extend([ + "立即减速至20km/h以下", + "保持警惕,准备制动", + "观察行人动向", + "准备避让", + "向附近车辆发送警告" + ]) + elif risk_level == 'medium': + measures.extend([ + "减速至安全速度", + "保持安全距离", + "观察周围环境", + "准备应对突发情况", + "评估避让路径" + ]) + elif risk_level == 'low': + measures.extend([ + "保持当前速度", + "注意观察", + "准备减速", + "保持安全车距" + ]) + else: + measures.append("正常行驶,保持警惕") + + # 添加基于距离的额外建议 + if distance < 3.0: + measures.append("保持极端警惕,准备紧急操作") + elif distance < 5.0: + measures.append("准备随时制动") + + # 添加基于车速的额外建议 + if speed_kmh > 50.0: + measures.append("车速过快,建议减速") + elif speed_kmh > 30.0: + measures.append("注意控制车速") + + return measures + def _update_stats(self, interaction: Dict): """更新统计数据""" self.stats['total_interactions'] += 1 distance = interaction['distance'] + ttc = interaction.get('time_to_collision') # 更新距离统计 self.stats['average_distance'] = ( @@ -161,9 +240,25 @@ def _update_stats(self, interaction: Dict): self.stats['min_distance'] = min(self.stats['min_distance'], distance) self.stats['max_distance'] = max(self.stats['max_distance'], distance) + # 更新碰撞时间统计 + if ttc is not None and ttc < 100: + self.stats['average_ttc'] = ( + (self.stats['average_ttc'] * (self.stats['total_interactions'] - 1) + ttc) / + self.stats['total_interactions'] + ) + self.stats['min_ttc'] = min(self.stats['min_ttc'], ttc) + + # 更新速度统计 + self.stats['vehicle_speeds'].append(interaction['vehicle_speed']) + self.stats['pedestrian_speeds'].append(interaction['pedestrian_speed']) + # 更新风险统计 risk_level = interaction['risk_level'] - if risk_level == 'high': + if risk_level == 'critical': + self.stats['critical_cases'] += 1 + self.stats['near_misses'] += 1 + self.stats['safety_warnings'] += 1 + elif risk_level == 'high': self.stats['high_risk_cases'] += 1 self.stats['near_misses'] += 1 self.stats['safety_warnings'] += 1 @@ -185,45 +280,44 @@ def _update_stats(self, interaction: Dict): if len(self.interaction_records) > 1000: self.interaction_records = self.interaction_records[-1000:] - def _log_high_risk(self, interaction: Dict): - """记录高风险情况""" - warning = { + def _log_risk_event(self, interaction: Dict): + """记录风险事件""" + event_type = 'critical' if interaction['risk_level'] == 'critical' else 'high_risk' + + event = { 'timestamp': datetime.now().isoformat(), + 'event_type': event_type, 'interaction': interaction, - 'safety_measures': self._suggest_safety_measures(interaction) + 'safety_measures': interaction.get('safety_measures', []), + 'environment': { + 'weather': str(self.world.get_weather()), + 'time_of_day': self._get_time_of_day() + } } - self.warning_logs.append(warning) - # 保存高风险警告 + if event_type == 'critical': + self.critical_events.append(event) + # 保存临界事件 + if len(self.critical_events) % 5 == 0: + self._save_critical_events() + else: + self.warning_logs.append(event) + + # 保存警告日志 if len(self.warning_logs) % 10 == 0: self._save_warning_logs() - def _suggest_safety_measures(self, interaction: Dict) -> List[str]: - """建议安全措施""" - measures = [] - - if interaction['risk_level'] == 'high': - measures.extend([ - "立即制动", - "鸣喇叭警告", - "准备紧急避让", - "向其他车辆发送警告" - ]) - elif interaction['risk_level'] == 'medium': - measures.extend([ - "减速行驶", - "保持警惕", - "准备制动", - "观察行人动向" - ]) - elif interaction['risk_level'] == 'low': - measures.extend([ - "保持安全距离", - "观察周围环境", - "准备应对突发情况" - ]) + def _get_time_of_day(self) -> str: + """获取当前时间""" + weather = self.world.get_weather() + sun_altitude = weather.sun_altitude_angle - return measures + if sun_altitude > 45: + return 'day' + elif sun_altitude > 0: + return 'sunset' + else: + return 'night' def _save_interaction_report(self, interactions: List[Dict]): """保存交互报告""" @@ -235,10 +329,15 @@ def _save_interaction_report(self, interactions: List[Dict]): 'total_interactions': len(interactions), 'interactions': interactions, 'summary': { + 'critical': len([i for i in interactions if i['risk_level'] == 'critical']), 'high_risk': len([i for i in interactions if i['risk_level'] == 'high']), 'medium_risk': len([i for i in interactions if i['risk_level'] == 'medium']), 'low_risk': len([i for i in interactions if i['risk_level'] == 'low']), 'safe': len([i for i in interactions if i['risk_level'] == 'safe']) + }, + 'environment': { + 'weather': str(self.world.get_weather()), + 'time_of_day': self._get_time_of_day() } } @@ -254,6 +353,15 @@ def _save_warning_logs(self): with open(warning_file, 'w', encoding='utf-8') as f: json.dump(self.warning_logs, f, indent=2, ensure_ascii=False) + def _save_critical_events(self): + """保存临界事件""" + if not self.critical_events: + return + + critical_file = os.path.join(self.safety_dir, "critical_events.json") + with open(critical_file, 'w', encoding='utf-8') as f: + json.dump(self.critical_events, f, indent=2, ensure_ascii=False) + def _generate_safety_report(self) -> Dict: """生成安全报告""" report = { @@ -261,13 +369,22 @@ def _generate_safety_report(self) -> Dict: 'statistics': self.stats.copy(), 'safety_thresholds': self.safety_thresholds, 'risk_distribution': { + 'critical': self.stats['critical_cases'], 'high': self.stats['high_risk_cases'], 'medium': self.stats['medium_risk_cases'], 'low': self.stats['low_risk_cases'], 'safe': self.stats['safe_cases'] }, 'safety_score': self._calculate_safety_score(), - 'recommendations': self._generate_recommendations() + 'recommendations': self._generate_recommendations(), + 'performance_metrics': { + 'average_vehicle_speed': np.mean(self.stats['vehicle_speeds']) if self.stats['vehicle_speeds'] else 0, + 'average_pedestrian_speed': np.mean(self.stats['pedestrian_speeds']) if self.stats[ + 'pedestrian_speeds'] else 0, + 'max_vehicle_speed': max(self.stats['vehicle_speeds']) if self.stats['vehicle_speeds'] else 0, + 'interaction_frequency': len(self.stats['interaction_times']) / max(1, ( + time.time() - min(self.stats['interaction_times']) if self.stats['interaction_times'] else 1)) + } } return report @@ -277,17 +394,30 @@ def _calculate_safety_score(self) -> float: if self.stats['total_interactions'] == 0: return 100.0 + critical_ratio = self.stats['critical_cases'] / self.stats['total_interactions'] high_risk_ratio = self.stats['high_risk_cases'] / self.stats['total_interactions'] medium_risk_ratio = self.stats['medium_risk_cases'] / self.stats['total_interactions'] - # 评分公式:基础分减去风险比例 - score = 100 - (high_risk_ratio * 60 + medium_risk_ratio * 30) * 100 + # 评分公式:基础分减去风险比例加权 + score = 100 - (critical_ratio * 80 + high_risk_ratio * 50 + medium_risk_ratio * 20) * 100 # 考虑平均距离 if self.stats['average_distance'] > 15.0: score += 10 elif self.stats['average_distance'] < 5.0: score -= 20 + elif self.stats['average_distance'] < 2.0: + score -= 40 + + # 考虑平均车速 + if self.stats['vehicle_speeds']: + avg_speed = np.mean(self.stats['vehicle_speeds']) + if avg_speed > 50.0: + score -= 15 + elif avg_speed > 30.0: + score -= 5 + elif avg_speed < 20.0: + score += 10 return max(0, min(100, score)) @@ -295,19 +425,37 @@ def _generate_recommendations(self) -> List[str]: """生成改进建议""" recommendations = [] - if self.stats['high_risk_cases'] > 0: + if self.stats['critical_cases'] > 0: + recommendations.extend([ + "立即改进行人检测系统", + "增加紧急制动系统", + "实施更严格的限速措施", + "增加行人预警系统", + "记录和分析所有临界事件" + ]) + + if self.stats['high_risk_cases'] > 5: recommendations.extend([ "增加行人安全距离阈值", "加强车辆行人检测系统", - "实施更严格的限速措施", - "增加行人警告系统" + "实施自动减速系统", + "增加行人警告频率" ]) if self.stats['average_distance'] < 10.0: recommendations.append("增加车辆与行人的平均距离") - if self.stats['near_misses'] > 5: - recommendations.append("实施紧急制动系统") + if self.stats['near_misses'] > 3: + recommendations.append("实施紧急避让系统") + + if self.stats['vehicle_speeds']: + avg_speed = np.mean(self.stats['vehicle_speeds']) + if avg_speed > 40.0: + recommendations.append("降低平均车速,特别是在行人密集区域") + + # 基于碰撞时间的建议 + if self.stats['min_ttc'] < 2.0: + recommendations.append("改进碰撞时间预测算法") return recommendations @@ -319,9 +467,32 @@ def generate_final_report(self) -> Dict: final_report['historical_data'] = { 'total_interaction_records': len(self.interaction_records), 'total_warning_logs': len(self.warning_logs), + 'total_critical_events': len(self.critical_events), 'analysis_period': self._get_analysis_period() } + # 添加详细分析 + final_report['detailed_analysis'] = { + 'distance_analysis': { + 'average': self.stats['average_distance'], + 'min': self.stats['min_distance'], + 'max': self.stats['max_distance'], + 'std': np.std([r['distance'] for r in self.interaction_records]) if self.interaction_records else 0 + }, + 'speed_analysis': { + 'vehicle_avg': np.mean(self.stats['vehicle_speeds']) if self.stats['vehicle_speeds'] else 0, + 'pedestrian_avg': np.mean(self.stats['pedestrian_speeds']) if self.stats['pedestrian_speeds'] else 0, + 'vehicle_std': np.std(self.stats['vehicle_speeds']) if self.stats['vehicle_speeds'] else 0 + }, + 'ttc_analysis': { + 'average': self.stats['average_ttc'], + 'min': self.stats['min_ttc'], + 'percentage_below_2s': len( + [r for r in self.interaction_records if r.get('time_to_collision', 100) < 2.0]) / max(1, + len(self.interaction_records)) * 100 + } + } + # 保存最终报告 final_file = os.path.join(self.safety_dir, "final_safety_report.json") with open(final_file, 'w', encoding='utf-8') as f: @@ -359,10 +530,14 @@ def save_data(self): with open(records_file, 'w', encoding='utf-8') as f: json.dump(self.interaction_records, f, indent=2, ensure_ascii=False) - # 保存警告日志 + # 保存警告日志和临界事件 self._save_warning_logs() + self._save_critical_events() # 生成并保存最终报告 - self.generate_final_report() + final_report = self.generate_final_report() - print(f"行人安全数据已保存到: {self.safety_dir}") \ No newline at end of file + print(f"行人安全数据已保存到: {self.safety_dir}") + print(f"安全评分: {final_report['safety_score']:.1f}/100") + print(f"高风险事件: {final_report['risk_distribution']['high']}次") + print(f"临界事件: {final_report['risk_distribution']['critical']}次") \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/scene_manager.py b/src/enhance_pedestrian_safety/scene_manager.py index f7e081f9ed..f43601c4fd 100644 --- a/src/enhance_pedestrian_safety/scene_manager.py +++ b/src/enhance_pedestrian_safety/scene_manager.py @@ -52,8 +52,8 @@ class SceneManager: 'vehicle_density': 0.4, 'pedestrian_density': 0.9, 'weather_variations': ['clear', 'cloudy'], - 'speed_limit': 20.0, - 'safety_zone_radius': 30.0 + 'speed_limit': 15.0, # 降低限速 + 'safety_zone_radius': 50.0 # 扩大安全区域 }, 'pedestrian_crossing': { 'description': '人行横道场景', @@ -94,14 +94,16 @@ def setup_scene(world, config, scene_type='intersection_4way'): # 如果是学校区域,设置车速限制 if scene_type == 'school_zone' and 'speed_limit' in scene_config: config['traffic']['speed_limit'] = scene_config['speed_limit'] + # 添加行人安全区域标记 + SceneManager._add_safety_zone_markers(world, config) # 应用场景特定设置 - SceneManager._apply_scene_specifics(world, scene_type) + SceneManager._apply_scene_specifics(world, scene_type, config) return config @staticmethod - def _apply_scene_specifics(world, scene_type): + def _apply_scene_specifics(world, scene_type, config): """应用场景特定的设置""" try: if scene_type == 'highway': @@ -134,6 +136,8 @@ def _apply_scene_specifics(world, scene_type): actor.set_light_state(carla.VehicleLightState.LowBeam) except: pass + # 添加学校区域警告标志 + SceneManager._add_school_zone_signs(world) elif scene_type == 'pedestrian_crossing': # 人行横道:增加可见性 @@ -143,10 +147,71 @@ def _apply_scene_specifics(world, scene_type): actor.set_light_state(carla.VehicleLightState.LowBeam) except: pass + # 添加人行横道标记 + SceneManager._add_crosswalk_markings(world) except Exception as e: print(f"场景特定设置失败: {e}") + @staticmethod + def _add_safety_zone_markers(world, config): + """添加安全区域标记""" + try: + blueprint_lib = world.get_blueprint_library() + + # 在学校区域周围添加安全锥 + spawn_points = world.get_map().get_spawn_points() + if spawn_points: + center_point = spawn_points[len(spawn_points) // 2].location + SceneManager.spawn_traffic_cones(world, center_point, num_cones=15) + + # 添加警告标志 + warning_sign_bp = blueprint_lib.find('static.prop.trafficsign') + if warning_sign_bp: + sign_location = carla.Location(center_point.x, center_point.y, center_point.z + 2.0) + world.spawn_actor(warning_sign_bp, carla.Transform(sign_location, carla.Rotation(0, 90, 0))) + + except Exception as e: + print(f"添加安全区域标记失败: {e}") + + @staticmethod + def _add_school_zone_signs(world): + """添加学校区域标志""" + try: + blueprint_lib = world.get_blueprint_library() + + # 查找学校区域标志蓝图 + school_sign_bp = None + for bp in blueprint_lib.filter('static.prop.*'): + if 'school' in bp.id.lower() or 'warning' in bp.id.lower(): + school_sign_bp = bp + break + + if school_sign_bp: + # 在学校区域周围放置标志 + spawn_points = world.get_map().get_spawn_points() + if spawn_points: + for i in range(min(4, len(spawn_points))): + location = spawn_points[i].location + sign_location = carla.Location(location.x, location.y, location.z + 2.0) + world.spawn_actor(school_sign_bp, + carla.Transform(sign_location, carla.Rotation(0, i * 90, 0))) + + except Exception as e: + print(f"添加学校区域标志失败: {e}") + + @staticmethod + def _add_crosswalk_markings(world): + """添加人行横道标记""" + try: + spawn_points = world.get_map().get_spawn_points() + if spawn_points: + center_point = spawn_points[len(spawn_points) // 2].location + SceneManager.spawn_pedestrian_safety_features(world, center_point, 'crosswalk') + + except Exception as e: + print(f"添加人行横道标记失败: {e}") + @staticmethod def spawn_pedestrian_safety_features(world, location, feature_type='crosswalk'): """生成行人安全设施""" @@ -315,7 +380,12 @@ def save_scene_description(output_dir, scene_type, config, extra_info=None): 'description': SceneManager.SCENES.get(scene_type, {}).get('description', '未知场景'), 'config': config, 'created': SceneManager._get_timestamp(), - 'extra_info': extra_info or {} + 'extra_info': extra_info or {}, + 'safety_features': { + 'has_crosswalk': scene_type in ['school_zone', 'pedestrian_crossing', 'intersection_4way'], + 'has_traffic_cones': scene_type in ['school_zone', 'construction_zone'], + 'has_warning_signs': scene_type in ['school_zone', 'pedestrian_crossing'] + } } scene_file = os.path.join(output_dir, "metadata", "scene_description.json") diff --git a/src/enhance_pedestrian_safety/sensor_enhancer.py b/src/enhance_pedestrian_safety/sensor_enhancer.py index 3dba1d767b..4f2d2b8f27 100644 --- a/src/enhance_pedestrian_safety/sensor_enhancer.py +++ b/src/enhance_pedestrian_safety/sensor_enhancer.py @@ -1,5 +1,5 @@ """ -传感器数据增强模块 - 提高数据质量和多样性(优化版) +传感器数据增强模块 - 提高数据质量和多样性(行人安全优化版) """ import numpy as np @@ -7,7 +7,6 @@ import random import os import json -from PIL import Image, ImageEnhance, ImageFilter from datetime import datetime from typing import Dict, List, Tuple, Optional, Union, Callable import concurrent.futures @@ -46,6 +45,8 @@ class EnhancementMethod(Enum): COLOR_TEMP = "color_temperature" JPEG_COMPRESSION = "jpeg_compression" COLOR_JITTER = "color_jitter" + PEDESTRIAN_HIGHLIGHT = "pedestrian_highlight" # 新增:行人高亮 + SAFETY_WARNING = "safety_warning" # 新增:安全警告 @dataclass @@ -61,6 +62,7 @@ class EnhancementConfig: save_enhanced: bool = True output_format: str = "jpg" compression_quality: int = 90 + pedestrian_safety_mode: bool = True # 新增:行人安全模式 def __post_init__(self): if self.enabled_methods is None: @@ -69,6 +71,12 @@ def __post_init__(self): EnhancementMethod.CONTRAST, EnhancementMethod.BRIGHTNESS ] + # 如果启用行人安全模式,添加相关方法 + if self.pedestrian_safety_mode: + if EnhancementMethod.PEDESTRIAN_HIGHLIGHT not in self.enabled_methods: + self.enabled_methods.append(EnhancementMethod.PEDESTRIAN_HIGHLIGHT) + if EnhancementMethod.SAFETY_WARNING not in self.enabled_methods: + self.enabled_methods.append(EnhancementMethod.SAFETY_WARNING) class BatchEnhancer: @@ -193,7 +201,7 @@ def get_stats(self) -> Dict: class SensorDataEnhancer: - """传感器数据增强器(优化版)""" + """传感器数据增强器(行人安全优化版)""" def __init__(self, config: Union[EnhancementConfig, Dict]): if isinstance(config, dict): @@ -210,9 +218,13 @@ def __init__(self, config: Union[EnhancementConfig, Dict]): 'method_times': {} } + # 行人检测模拟数据 + self.pedestrian_detections = [] + self.safety_warnings = [] + def _setup_method_registry(self) -> Dict[EnhancementMethod, Callable]: """设置方法注册表""" - return { + registry = { EnhancementMethod.NORMALIZE: self._normalize_image, EnhancementMethod.BRIGHTNESS: self._adjust_brightness, EnhancementMethod.CONTRAST: self._adjust_contrast, @@ -228,8 +240,11 @@ def _setup_method_registry(self) -> Dict[EnhancementMethod, Callable]: EnhancementMethod.VIGNETTE: self._add_vignette, EnhancementMethod.COLOR_TEMP: self._adjust_color_temperature, EnhancementMethod.JPEG_COMPRESSION: self._simulate_jpeg_compression, - EnhancementMethod.COLOR_JITTER: self._color_jitter + EnhancementMethod.COLOR_JITTER: self._color_jitter, + EnhancementMethod.PEDESTRIAN_HIGHLIGHT: self._highlight_pedestrians, # 新增 + EnhancementMethod.SAFETY_WARNING: self._add_safety_warnings # 新增 } + return registry def _setup_weather_methods(self) -> Dict[WeatherType, List[EnhancementMethod]]: """设置天气相关方法""" @@ -262,7 +277,8 @@ def _setup_weather_methods(self) -> Dict[WeatherType, List[EnhancementMethod]]: EnhancementMethod.BRIGHTNESS, EnhancementMethod.CONTRAST, EnhancementMethod.NOISE, - EnhancementMethod.VIGNETTE + EnhancementMethod.VIGNETTE, + EnhancementMethod.PEDESTRIAN_HIGHLIGHT # 夜间特别关注行人 ], WeatherType.SUNSET: [ EnhancementMethod.NORMALIZE, @@ -276,7 +292,7 @@ def enhance_image(self, image_data: np.ndarray, sensor_type: str = 'camera', return_methods: bool = False) -> Union[np.ndarray, Tuple]: """ - 增强图像数据(优化版) + 增强图像数据(行人安全优化版) Args: image_data: 原始图像数据 (H, W, C) @@ -404,11 +420,10 @@ def get_performance_stats(self) -> Dict: stats['avg_time_per_call'] = stats['total_time'] / stats['calls'] return stats - # ========== 增强方法实现(优化版)========== + # ========== 增强方法实现(行人安全优化版)========== def _normalize_image(self, image: np.ndarray) -> np.ndarray: """图像归一化(优化版)""" - # 使用OpenCV加速 if image.dtype != np.uint8: normalized = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX) return normalized.astype(np.uint8) @@ -418,9 +433,7 @@ def _adjust_brightness(self, image: np.ndarray) -> np.ndarray: """调整亮度(优化版)""" factor = random.uniform(*self.config.intensity_range) - # 使用NumPy向量化操作 if factor != 1.0: - # 转换为浮点数进行计算 img_float = image.astype(np.float32) * factor return np.clip(img_float, 0, 255).astype(np.uint8) return image @@ -430,9 +443,7 @@ def _adjust_contrast(self, image: np.ndarray) -> np.ndarray: factor = random.uniform(*self.config.intensity_range) if factor != 1.0: - # 计算平均值 mean = np.mean(image, axis=(0, 1), keepdims=True) - # 应用对比度调整 contrasted = mean + factor * (image.astype(np.float32) - mean) return np.clip(contrasted, 0, 255).astype(np.uint8) return image @@ -442,18 +453,14 @@ def _adjust_saturation(self, image: np.ndarray) -> np.ndarray: factor = random.uniform(*self.config.intensity_range) if factor != 1.0: - # 转换为HSV空间 hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV).astype(np.float32) - # 调整饱和度通道 hsv[:, :, 1] = np.clip(hsv[:, :, 1] * factor, 0, 255) - # 转换回RGB saturated = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2RGB) return saturated return image def _enhance_sharpness(self, image: np.ndarray) -> np.ndarray: """增强锐度(优化版)""" - # 使用拉普拉斯算子增强边缘 kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) @@ -464,7 +471,6 @@ def _gamma_correction(self, image: np.ndarray) -> np.ndarray: """伽马校正(优化版)""" gamma = random.uniform(0.5, 2.0) - # 使用LUT加速 table = np.array([((i / 255.0) ** gamma) * 255 for i in range(256)]).astype(np.uint8) corrected = cv2.LUT(image, table) return corrected @@ -474,7 +480,6 @@ def _add_noise(self, image: np.ndarray) -> np.ndarray: noise_type = random.choice(['gaussian', 'salt_pepper']) if noise_type == 'gaussian': - # 高斯噪声 mean = 0 var = random.uniform(0.001, 0.005) sigma = var ** 0.5 @@ -483,18 +488,15 @@ def _add_noise(self, image: np.ndarray) -> np.ndarray: return np.clip(noisy, 0, 255).astype(np.uint8) else: # salt_pepper - # 椒盐噪声 amount = random.uniform(0.001, 0.005) s_vs_p = random.uniform(0.3, 0.7) noisy = image.copy() - # 盐噪声 num_salt = np.ceil(amount * image.size * s_vs_p / 3) coords = [np.random.randint(0, i, int(num_salt)) for i in image.shape] noisy[coords[0], coords[1], :] = 255 - # 椒噪声 num_pepper = np.ceil(amount * image.size * (1.0 - s_vs_p) / 3) coords = [np.random.randint(0, i, int(num_pepper)) for i in image.shape] noisy[coords[0], coords[1], :] = 0 @@ -513,7 +515,6 @@ def _apply_motion_blur(self, image: np.ndarray) -> np.ndarray: kernel_size = random.choice([7, 9, 11]) direction = random.choice(['horizontal', 'vertical', 'diagonal']) - # 创建运动模糊核 kernel = np.zeros((kernel_size, kernel_size)) if direction == 'horizontal': @@ -526,7 +527,6 @@ def _apply_motion_blur(self, image: np.ndarray) -> np.ndarray: blurred = cv2.filter2D(image, -1, kernel) - # 混合原图和模糊图 alpha = random.uniform(0.3, 0.7) result = cv2.addWeighted(image, 1 - alpha, blurred, alpha, 0) return result.astype(np.uint8) @@ -535,10 +535,8 @@ def _add_rain_effect(self, image: np.ndarray) -> np.ndarray: """添加雨滴效果(优化版)""" h, w = image.shape[:2] - # 创建雨滴层 rain_layer = np.zeros((h, w), dtype=np.float32) - # 生成随机雨滴 num_drops = random.randint(200, 800) drop_length = random.randint(8, 15) @@ -547,15 +545,12 @@ def _add_rain_effect(self, image: np.ndarray) -> np.ndarray: y = random.randint(0, h - 1) brightness = random.uniform(0.3, 0.6) - # 绘制雨滴线 for i in range(drop_length): if y + i < h and x + i < w: rain_layer[y + i, x + i] += brightness - # 模糊雨滴层 rain_layer = cv2.GaussianBlur(rain_layer, (3, 3), 0) - # 叠加到原图 rain_layer_3d = np.stack([rain_layer] * 3, axis=2) enhanced = image.astype(np.float32) * 0.9 + rain_layer_3d * 0.1 * 255 return np.clip(enhanced, 0, 255).astype(np.uint8) @@ -564,17 +559,14 @@ def _add_fog_effect(self, image: np.ndarray) -> np.ndarray: """添加雾效(优化版)""" h, w = image.shape[:2] - # 创建深度图(简化版,假设中心最近) center_y, center_x = h // 2, w // 2 y_coords, x_coords = np.ogrid[:h, :w] distance = np.sqrt((x_coords - center_x) ** 2 + (y_coords - center_y) ** 2) distance = distance / np.max(distance) - # 雾效强度 fog_intensity = random.uniform(0.2, 0.5) fog_color = random.choice([200, 210, 220]) - # 应用雾效 fog_strength = distance * fog_intensity fog_strength_3d = np.stack([fog_strength] * 3, axis=2) fog_layer = np.ones_like(image) * fog_color @@ -586,19 +578,15 @@ def _add_fog_effect(self, image: np.ndarray) -> np.ndarray: def _add_cloud_effect(self, image: np.ndarray) -> np.ndarray: """添加云层效果(优化版)""" - # 降低饱和度和对比度,模拟多云天气 hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV).astype(np.float32) - # 调整饱和度 hsv[:, :, 1] *= random.uniform(0.7, 0.9) - # 调整亮度和对比度 brightness_factor = random.uniform(0.9, 1.1) contrast_factor = random.uniform(0.8, 0.95) hsv[:, :, 2] = np.clip(hsv[:, :, 2] * brightness_factor, 0, 255) - # 应用对比度调整 mean = np.mean(hsv[:, :, 2]) hsv[:, :, 2] = mean + contrast_factor * (hsv[:, :, 2] - mean) hsv[:, :, 2] = np.clip(hsv[:, :, 2], 0, 255) @@ -610,21 +598,17 @@ def _add_vignette(self, image: np.ndarray) -> np.ndarray: """添加暗角效果(优化版)""" h, w = image.shape[:2] - # 创建暗角蒙版 center_y, center_x = h // 2, w // 2 y_coords, x_coords = np.ogrid[:h, :w] - # 计算距离(使用椭圆形状) y_dist = (y_coords - center_y) / (h / 2) x_dist = (x_coords - center_x) / (w / 2) distance = np.sqrt(x_dist ** 2 + y_dist ** 2) - # 创建暗角 vignette_intensity = random.uniform(0.2, 0.4) vignette = 1 - distance * vignette_intensity vignette = np.clip(vignette, 0.6, 1.0) - # 应用暗角 vignette_3d = np.stack([vignette] * 3, axis=2) enhanced = image.astype(np.float32) * vignette_3d @@ -634,16 +618,13 @@ def _adjust_color_temperature(self, image: np.ndarray) -> np.ndarray: """调整色温(优化版)""" temp_type = random.choice(['warm', 'cool']) - # 转换为浮点数 img_float = image.astype(np.float32) if temp_type == 'warm': - # 暖色调:增加红色和黄色 img_float[:, :, 0] *= random.uniform(1.0, 1.15) # 红色 img_float[:, :, 1] *= random.uniform(1.0, 1.1) # 绿色 img_float[:, :, 2] *= random.uniform(0.9, 1.0) # 蓝色 else: - # 冷色调:增加蓝色 img_float[:, :, 0] *= random.uniform(0.9, 1.0) # 红色 img_float[:, :, 1] *= random.uniform(0.95, 1.0) # 绿色 img_float[:, :, 2] *= random.uniform(1.0, 1.15) # 蓝色 @@ -653,15 +634,12 @@ def _adjust_color_temperature(self, image: np.ndarray) -> np.ndarray: def _simulate_jpeg_compression(self, image: np.ndarray) -> np.ndarray: """模拟JPEG压缩(优化版)""" - # 使用OpenCV的JPEG编码/解码模拟压缩 quality = random.randint(70, 95) - # 编码为JPEG encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), quality] result, encoded = cv2.imencode('.jpg', cv2.cvtColor(image, cv2.COLOR_RGB2BGR), encode_param) if result: - # 解码 decoded = cv2.imdecode(encoded, cv2.IMREAD_COLOR) return cv2.cvtColor(decoded, cv2.COLOR_BGR2RGB) @@ -669,57 +647,124 @@ def _simulate_jpeg_compression(self, image: np.ndarray) -> np.ndarray: def _color_jitter(self, image: np.ndarray) -> np.ndarray: """颜色抖动(优化版)""" - # 随机应用多种颜色变换 transforms = [] - # 亮度调整 if random.random() > 0.5: brightness = random.uniform(0.8, 1.2) transforms.append(lambda img: self._adjust_brightness(img, brightness)) - # 对比度调整 if random.random() > 0.5: contrast = random.uniform(0.8, 1.2) transforms.append(lambda img: self._adjust_contrast(img, contrast)) - # 饱和度调整 if random.random() > 0.5: saturation = random.uniform(0.8, 1.2) transforms.append(lambda img: self._adjust_saturation(img, saturation)) - # 随机应用变换 if transforms: random.shuffle(transforms) - for transform in transforms[:2]: # 最多应用2个变换 + for transform in transforms[:2]: image = transform(image) return image + def _highlight_pedestrians(self, image: np.ndarray) -> np.ndarray: + """高亮行人(新增方法)""" + if not self.config.pedestrian_safety_mode: + return image + + h, w = image.shape[:2] + highlighted = image.copy() + + # 模拟行人检测(随机位置) + num_pedestrians = random.randint(1, 3) + + for i in range(num_pedestrians): + # 随机位置 + x = random.randint(50, w - 150) + y = random.randint(50, h - 200) + + # 随机大小 + width = random.randint(30, 70) + height = random.randint(80, 180) + + # 根据距离设置颜色(模拟风险评估) + distance = random.uniform(5.0, 50.0) + if distance < 10.0: + color = (0, 0, 255) # 红色:高风险 + thickness = 3 + elif distance < 20.0: + color = (0, 165, 255) # 橙色:中风险 + thickness = 2 + else: + color = (0, 255, 0) # 绿色:低风险 + thickness = 1 + + # 绘制边界框 + cv2.rectangle(highlighted, (x, y), (x + width, y + height), color, thickness) + + # 添加标签 + label = f"Pedestrian {distance:.1f}m" + cv2.putText(highlighted, label, (x, y - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, thickness) + + # 记录检测 + self.pedestrian_detections.append({ + 'position': (x, y, width, height), + 'distance': distance, + 'risk_level': 'high' if distance < 10.0 else 'medium' if distance < 20.0 else 'low' + }) + + return highlighted + + def _add_safety_warnings(self, image: np.ndarray) -> np.ndarray: + """添加安全警告(新增方法)""" + if not self.config.pedestrian_safety_mode: + return image + + warned = image.copy() + + # 检查是否有高风险行人 + high_risk = [d for d in self.pedestrian_detections if d['risk_level'] == 'high'] + + if high_risk: + # 在图像顶部添加警告条 + warning_height = 40 + warning_bar = np.zeros((warning_height, image.shape[1], 3), dtype=np.uint8) + warning_bar[:] = (0, 0, 255) # 红色背景 + + # 添加警告文本 + warning_text = f"WARNING: {len(high_risk)} high-risk pedestrians detected!" + cv2.putText(warning_bar, warning_text, (10, 25), + cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2) + + # 将警告条添加到图像顶部 + warned = np.vstack([warning_bar, warned]) + + # 记录警告 + self.safety_warnings.append({ + 'timestamp': time.time(), + 'high_risk_count': len(high_risk), + 'message': warning_text + }) + + return warned + def _enhance_non_rgb_image(self, image_data: np.ndarray, sensor_type: str) -> np.ndarray: """增强非RGB图像(深度、语义分割)""" if sensor_type == 'depth': - # 深度图增强:归一化和去噪 if image_data.dtype != np.uint8: - # 归一化到0-255 normalized = cv2.normalize(image_data, None, 0, 255, cv2.NORM_MINMAX) else: normalized = image_data - # 应用中值滤波去除噪声 enhanced = cv2.medianBlur(normalized, 3) return enhanced.astype(np.uint8) elif sensor_type == 'semantic': - # 语义分割图增强:保持类别不变,只做边界平滑 kernel = np.ones((3, 3), np.uint8) - - # 形态学操作:先腐蚀再膨胀(闭运算)填充小孔 enhanced = cv2.morphologyEx(image_data, cv2.MORPH_CLOSE, kernel) - - # 高斯模糊平滑边界 enhanced = cv2.GaussianBlur(enhanced, (3, 3), 0.5) - - # 恢复类别值 enhanced = np.round(enhanced).astype(image_data.dtype) return enhanced @@ -727,19 +772,15 @@ def _enhance_non_rgb_image(self, image_data: np.ndarray, sensor_type: str) -> np def save_enhanced_image(self, image_data: np.ndarray, output_path: str, metadata: Optional[Dict] = None): - """保存增强后的图像和元数据(优化版)""" + """保存增强后的图像和元数据""" try: - # 确保目录存在 os.makedirs(os.path.dirname(output_path), exist_ok=True) - # 保存图像 if output_path.lower().endswith(('.png', '.jpg', '.jpeg')): cv2.imwrite(output_path, cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) else: - # 默认保存为PNG cv2.imwrite(output_path + '.png', cv2.cvtColor(image_data, cv2.COLOR_RGB2BGR)) - # 保存元数据 if metadata: meta_path = output_path.rsplit('.', 1)[0] + '_meta.json' with open(meta_path, 'w', encoding='utf-8') as f: @@ -750,7 +791,7 @@ def save_enhanced_image(self, image_data: np.ndarray, output_path: str, raise def generate_enhancement_report(self, output_dir: str) -> Dict: - """生成增强报告(优化版)""" + """生成增强报告""" report = { 'timestamp': datetime.now().isoformat(), 'config': { @@ -758,7 +799,8 @@ def generate_enhancement_report(self, output_dir: str) -> Dict: 'time_of_day': self.config.time_of_day, 'enabled_methods': [m.value for m in self.config.enabled_methods], 'intensity_range': self.config.intensity_range, - 'probability': self.config.probability + 'probability': self.config.probability, + 'pedestrian_safety_mode': self.config.pedestrian_safety_mode }, 'performance_stats': self.get_performance_stats(), 'method_usage': { @@ -768,153 +810,20 @@ def generate_enhancement_report(self, output_dir: str) -> Dict: 'cache_info': { 'cache_size': len(self.method_cache), 'cache_hits': self.perf_stats.get('cache_hit_calls', 0) + }, + 'safety_statistics': { + 'pedestrian_detections': len(self.pedestrian_detections), + 'safety_warnings': len(self.safety_warnings), + 'high_risk_cases': len([d for d in self.pedestrian_detections if d['risk_level'] == 'high']) } } - # 保存报告 report_path = os.path.join(output_dir, 'enhancement_report.json') with open(report_path, 'w', encoding='utf-8') as f: json.dump(report, f, indent=2, ensure_ascii=False) return report - def _add_pedestrian_detection_markers(self, image: np.ndarray, pedestrians: List[Dict]) -> np.ndarray: - """添加行人检测标记""" - if not pedestrians: - return image - - # 创建副本 - marked_image = image.copy() - - for pedestrian in pedestrians: - # 模拟行人检测框 - x = random.randint(100, image.shape[1] - 100) - y = random.randint(100, image.shape[0] - 100) - width = random.randint(30, 80) - height = random.randint(80, 180) - - # 绘制检测框 - color = (0, 255, 0) # 绿色表示安全 - thickness = 2 - - cv2.rectangle(marked_image, (x, y), (x + width, y + height), color, thickness) - - # 添加标签 - label = f"Pedestrian {pedestrian.get('distance', 0):.1f}m" - cv2.putText(marked_image, label, (x, y - 10), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, thickness) - - return marked_image - - def _simulate_safety_warnings(self, image: np.ndarray, warnings: List[Dict]) -> np.ndarray: - """模拟安全警告""" - if not warnings: - return image - - warning_image = image.copy() - - for warning in warnings[:2]: # 最多显示2个警告 - # 添加警告文本 - text = f"WARNING: {warning.get('type', 'Pedestrian')} {warning.get('distance', 0):.1f}m" - color = (0, 0, 255) # 红色表示警告 - thickness = 2 - - position = (50, 50 + warnings.index(warning) * 40) - cv2.putText(warning_image, text, position, - cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, thickness) - - # 添加警告图标 - icon_size = 30 - icon_position = (position[0] - icon_size - 10, position[1] - icon_size // 2) - cv2.rectangle(warning_image, icon_position, - (icon_position[0] + icon_size, icon_position[1] + icon_size), - color, -1) # 填充红色矩形 - - return warning_image - - -# 保持向后兼容的类 -class SensorCalibrator: - """传感器校准模块(优化版)""" - - def __init__(self, config: Dict): - self.config = config - self.calibration_data = {} - - def generate_calibration_files(self, output_dir: str, - vehicle_locations: List[Dict], - camera_positions: List[Dict]): - """生成传感器校准文件(优化版)""" - calib_dir = os.path.join(output_dir, "calibration") - os.makedirs(calib_dir, exist_ok=True) - - # 1. 生成相机内参 - self._generate_camera_intrinsics(calib_dir) - - # 2. 生成外参(相机到车辆) - self._generate_extrinsics(calib_dir, vehicle_locations, camera_positions) - - # 3. 生成传感器间标定 - self._generate_sensor_calibration(calib_dir) - - # 4. 生成时间同步校准 - self._generate_temporal_calibration(calib_dir) - - # 5. 生成验证数据 - self._generate_validation_data(calib_dir) - - print(f"校准文件已生成到: {calib_dir}") - return calib_dir - - def _generate_camera_intrinsics(self, calib_dir: str): - """生成相机内参(优化版)""" - image_size = self.config.get('sensors', {}).get('image_size', [1280, 720]) - width, height = image_size[0], image_size[1] - - # 为不同相机生成不同的内参 - camera_types = [ - ('front_wide', 100.0), # 前视广角 - ('front_narrow', 60.0), # 前视窄角 - ('side', 90.0), # 侧视 - ('rear', 120.0), # 后视 - ('infrastructure', 120.0) # 基础设施 - ] - - for camera_name, fov in camera_types: - # 内参矩阵 [fx, 0, cx; 0, fy, cy; 0, 0, 1] - fx = width / (2 * np.tan(np.radians(fov / 2))) - fy = fx - cx = width / 2.0 - cy = height / 2.0 - - intrinsics = { - 'camera_name': camera_name, - 'camera_matrix': [ - [float(fx), 0.0, float(cx)], - [0.0, float(fy), float(cy)], - [0.0, 0.0, 1.0] - ], - 'distortion_coefficients': [ - random.uniform(-0.1, 0.1), # k1 - random.uniform(-0.01, 0.01), # k2 - 0.0, # p1 - 0.0, # p2 - random.uniform(-0.001, 0.001) # k3 - ], - 'image_size': [int(width), int(height)], - 'fov': float(fov), - 'pixel_size': [0.003, 0.003], # 假设像素大小 - 'sensor_type': 'pinhole', - 'calibration_date': datetime.now().isoformat(), - 'accuracy': random.uniform(0.5, 1.0) # 标定精度(像素) - } - - file_path = os.path.join(calib_dir, f'{camera_name}_intrinsic.json') - with open(file_path, 'w', encoding='utf-8') as f: - json.dump(intrinsics, f, indent=2, ensure_ascii=False) - - # ... 其他方法保持不变,但可以添加更多优化 ... - # 兼容旧版本接口 def enhance_image(image_data, sensor_type='camera'): diff --git a/src/enhance_pedestrian_safety/v2x_communication.py b/src/enhance_pedestrian_safety/v2x_communication.py index 63079cc46a..937c00d15e 100644 --- a/src/enhance_pedestrian_safety/v2x_communication.py +++ b/src/enhance_pedestrian_safety/v2x_communication.py @@ -29,32 +29,29 @@ def __init__(self, config: Dict): self.config = config self.enabled = config.get('enabled', True) - # 通信参数 - self.communication_range = config.get('communication_range', 300.0) # 通信范围(米) - self.bandwidth = config.get('bandwidth', 10.0) # 带宽(Mbps) - self.latency_mean = config.get('latency_mean', 0.05) # 平均延迟(秒) - self.latency_std = config.get('latency_std', 0.01) # 延迟标准差 - self.packet_loss_rate = config.get('packet_loss_rate', 0.01) # 丢包率 - - # 消息管理 + self.communication_range = config.get('communication_range', 300.0) + self.bandwidth = config.get('bandwidth', 10.0) + self.latency_mean = config.get('latency_mean', 0.05) + self.latency_std = config.get('latency_std', 0.01) + self.packet_loss_rate = config.get('packet_loss_rate', 0.01) + self.message_queue = queue.PriorityQueue() self.received_messages = [] self.message_counter = 0 - # 网络模拟 - self.network_nodes = {} # 节点ID -> 节点信息 - self.connections = {} # 连接状态 + self.network_nodes = {} + self.connections = {} - # 统计信息 self.stats = { 'messages_sent': 0, 'messages_received': 0, 'messages_dropped': 0, 'total_latency': 0.0, - 'bandwidth_used': 0.0 + 'bandwidth_used': 0.0, + 'pedestrian_warnings': 0, + 'safety_alerts': 0 } - # 启动消息处理线程 if self.enabled: self.running = True self.processor_thread = threading.Thread(target=self._message_processor, daemon=True) @@ -79,17 +76,14 @@ def send_message(self, message: V2XMessage) -> bool: if not self.enabled: return False - # 模拟网络延迟和丢包 if np.random.random() < self.packet_loss_rate: self.stats['messages_dropped'] += 1 return False - # 添加延迟 latency = np.random.normal(self.latency_mean, self.latency_std) delivery_time = time.time() + max(0, latency) - # 添加到消息队列(按优先级和发送时间排序) - priority = -message.priority # 负号因为PriorityQueue是小顶堆 + priority = -message.priority self.message_queue.put((priority, delivery_time, message)) self.stats['messages_sent'] += 1 @@ -162,7 +156,7 @@ def broadcast_map_data(self, map_id: str, map_data: Dict) -> Optional[V2XMessage message_type='map', data=map_data, timestamp=time.time(), - ttl=30.0, # 地图数据TTL较长 + ttl=30.0, priority=1, position=map_data.get('reference_point') ) @@ -183,13 +177,18 @@ def broadcast_roadside_safety_message(self, rsu_id: str, warning_data: Dict) -> data=warning_data, timestamp=time.time(), ttl=3.0, - priority=3, # 安全消息优先级高 + priority=3, position=warning_data.get('event_position') ) self.message_counter += 1 if self.send_message(message): + # 更新安全统计 + if warning_data.get('type') == 'pedestrian': + self.stats['pedestrian_warnings'] += 1 + if warning_data.get('severity') in ['high', 'critical']: + self.stats['safety_alerts'] += 1 return message return None @@ -202,13 +201,11 @@ def get_reachable_nodes(self, sender_id: str, sender_position: tuple) -> List[st if node_id == sender_id: continue - # 计算距离 distance = self._calculate_distance(sender_position, node_info['position']) if distance <= self.communication_range: - # 模拟信号衰减 signal_strength = 1.0 - (distance / self.communication_range) - if signal_strength > 0.3: # 最小信号强度阈值 + if signal_strength > 0.3: reachable.append(node_id) return reachable @@ -228,19 +225,16 @@ def _message_processor(self): """消息处理线程""" while self.running: try: - # 获取下一个要传递的消息 if not self.message_queue.empty(): priority, delivery_time, message = self.message_queue.get_nowait() current_time = time.time() if current_time >= delivery_time: - # 消息已到传递时间 self._deliver_message(message) else: - # 重新放回队列 self.message_queue.put((priority, delivery_time, message)) - time.sleep(0.001) # 短暂休眠 + time.sleep(0.001) else: time.sleep(0.01) @@ -254,18 +248,15 @@ def _deliver_message(self, message: V2XMessage): if not message.position: return - # 获取可达节点 reachable_nodes = self.get_reachable_nodes(message.sender_id, message.position) - # 模拟带宽限制 - message_size = len(json.dumps(asdict(message)).encode('utf-8')) / 1024 / 1024 # MB - bandwidth_required = message_size * 8 * len(reachable_nodes) # Mbps + message_size = len(json.dumps(asdict(message)).encode('utf-8')) / 1024 / 1024 + bandwidth_required = message_size * 8 * len(reachable_nodes) - if bandwidth_required > self.bandwidth * 0.8: # 带宽超过80%时随机丢包 + if bandwidth_required > self.bandwidth * 0.8: drop_probability = min(1.0, bandwidth_required / self.bandwidth - 0.8) reachable_nodes = [n for n in reachable_nodes if np.random.random() > drop_probability] - # 添加到接收消息列表 for node_id in reachable_nodes: received_msg = { 'message': asdict(message), @@ -278,7 +269,6 @@ def _deliver_message(self, message: V2XMessage): self.received_messages.append(received_msg) self.stats['messages_received'] += 1 - # 更新带宽使用统计 self.stats['bandwidth_used'] += bandwidth_required def get_messages_for_node(self, node_id: str, message_types: List[str] = None) -> List[Dict]: @@ -291,7 +281,6 @@ def get_messages_for_node(self, node_id: str, message_types: List[str] = None) - if not message_types or message['message_type'] in message_types: messages.append(msg_record) - # 清理已处理的消息 self.received_messages = [ msg for msg in self.received_messages if msg['receiver_id'] != node_id or @@ -308,7 +297,11 @@ def get_network_status(self) -> Dict: 'bandwidth_utilization': (self.stats['bandwidth_used'] / ( self.bandwidth * time.time())) * 100 if time.time() > 0 else 0, 'message_delivery_rate': self.stats['messages_received'] / max(1, self.stats['messages_sent']), - 'average_latency': self.stats['total_latency'] / max(1, self.stats['messages_sent']) + 'average_latency': self.stats['total_latency'] / max(1, self.stats['messages_sent']), + 'safety_metrics': { + 'pedestrian_warnings': self.stats['pedestrian_warnings'], + 'safety_alerts': self.stats['safety_alerts'] + } } def reset_stats(self): @@ -318,7 +311,9 @@ def reset_stats(self): 'messages_received': 0, 'messages_dropped': 0, 'total_latency': 0.0, - 'bandwidth_used': 0.0 + 'bandwidth_used': 0.0, + 'pedestrian_warnings': 0, + 'safety_alerts': 0 } def stop(self): From 070f80a5d1c6fc8b95e410cb220962fe7526273d Mon Sep 17 00:00:00 2001 From: Z-w-7799 <1011069369@qq.com> Date: Fri, 26 Dec 2025 21:27:40 +0800 Subject: [PATCH 21/21] =?UTF-8?q?=E5=A2=9E=E5=BC=BA=E8=A1=8C=E4=BA=BA?= =?UTF-8?q?=E5=AE=89=E5=85=A8=E6=A8=A1=E5=9D=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../annotation_generator.py | 327 ++- src/enhance_pedestrian_safety/carla_utils.py | 343 ++- .../config_manager.py | 864 ++++-- .../data_validator.py | 656 ++++- .../lidar_processor.py | 916 +++++-- src/enhance_pedestrian_safety/main.py | 2338 +++++++++++++---- 6 files changed, 4353 insertions(+), 1091 deletions(-) diff --git a/src/enhance_pedestrian_safety/annotation_generator.py b/src/enhance_pedestrian_safety/annotation_generator.py index 734fa91616..3df7e12e87 100644 --- a/src/enhance_pedestrian_safety/annotation_generator.py +++ b/src/enhance_pedestrian_safety/annotation_generator.py @@ -2,10 +2,11 @@ import os import numpy as np from datetime import datetime +import threading class AnnotationGenerator: - """标注生成器""" + """标注生成器(行人安全增强版)""" def __init__(self, output_dir): self.output_dir = output_dir @@ -14,9 +15,21 @@ def __init__(self, output_dir): self.frame_annotations = {} self.object_counter = 0 + self.lock = threading.RLock() + + # 行人安全相关统计 + self.safety_stats = { + 'near_misses': 0, + 'critical_interactions': 0, + 'pedestrian_trajectories': {}, + 'risk_zones': [] + } + + # 高风险区域定义 + self.high_risk_zones = [] # 学校、人行横道等区域 def detect_objects(self, world, frame_num, timestamp): - """检测场景中的物体""" + """检测场景中的物体(行人安全增强)""" annotations = { 'frame_id': frame_num, 'timestamp': timestamp, @@ -25,12 +38,17 @@ def detect_objects(self, world, frame_num, timestamp): 'safety_info': { 'pedestrian_count': 0, 'vehicle_count': 0, - 'high_risk_interactions': 0 + 'high_risk_interactions': 0, + 'near_miss_count': 0, + 'pedestrian_distances': [], + 'risk_level': 'low' } } try: actors = world.get_actors() + pedestrians = [] + vehicles = [] for actor in actors: obj_type = actor.type_id @@ -41,15 +59,36 @@ def detect_objects(self, world, frame_num, timestamp): annotations['objects'].append(obj_info) self.object_counter += 1 - # 更新安全统计 + # 分类统计 if 'walker' in obj_type: annotations['safety_info']['pedestrian_count'] += 1 + pedestrians.append({ + 'id': actor.id, + 'location': obj_info['location'], + 'velocity': obj_info['velocity'] + }) elif 'vehicle' in obj_type: annotations['safety_info']['vehicle_count'] += 1 - - # 检测高风险交互 - annotations['safety_info']['high_risk_interactions'] = self._detect_high_risk_interactions( - annotations['objects']) + vehicles.append({ + 'id': actor.id, + 'location': obj_info['location'], + 'velocity': obj_info['velocity'], + 'type': obj_info['class'] + }) + + # 检测高风险交互和近碰撞 + risk_analysis = self._analyze_pedestrian_risk(pedestrians, vehicles) + annotations['safety_info']['high_risk_interactions'] = risk_analysis['high_risk_count'] + annotations['safety_info']['near_miss_count'] = risk_analysis['near_miss_count'] + annotations['safety_info']['pedestrian_distances'] = risk_analysis['distances'] + annotations['safety_info']['risk_level'] = risk_analysis['risk_level'] + + # 跟踪行人轨迹 + self._track_pedestrian_trajectories(frame_num, pedestrians) + + # 检测高风险区域 + risk_zones = self._detect_risk_zones(pedestrians, vehicles) + annotations['safety_info']['risk_zones'] = risk_zones self._save_annotations(frame_num, annotations) return annotations @@ -59,11 +98,15 @@ def detect_objects(self, world, frame_num, timestamp): return annotations def _extract_object_info(self, actor): - """提取物体信息""" + """提取物体信息(增强版)""" try: bbox = actor.bounding_box location = actor.get_location() velocity = actor.get_velocity() + transform = actor.get_transform() + + # 计算速度大小 + speed = np.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) * 3.6 # 转换为km/h obj_info = { 'id': actor.id, @@ -77,8 +120,10 @@ def _extract_object_info(self, actor): 'velocity': { 'x': float(velocity.x), 'y': float(velocity.y), - 'z': float(velocity.z) + 'z': float(velocity.z), + 'speed_kmh': float(speed) }, + 'heading': float(transform.rotation.yaw), 'bounding_box': { 'extent': { 'x': float(bbox.extent.x), @@ -87,7 +132,8 @@ def _extract_object_info(self, actor): } }, 'attributes': { - 'is_alive': actor.is_alive + 'is_alive': actor.is_alive, + 'is_stationary': speed < 1.0 } } @@ -97,7 +143,7 @@ def _extract_object_info(self, actor): return None def _get_object_class(self, type_id): - """获取物体类别""" + """获取物体类别(增强版)""" type_lower = type_id.lower() if 'vehicle' in type_lower: @@ -113,6 +159,10 @@ def _get_object_class(self, type_id): return 'car' elif 'bmw' in type_lower: return 'car' + elif 'truck' in type_lower: + return 'truck' + elif 'bus' in type_lower: + return 'bus' else: return 'vehicle' @@ -122,16 +172,25 @@ def _get_object_class(self, type_id): elif 'traffic' in type_lower: return 'traffic_light' + elif 'bike' in type_lower or 'bicycle' in type_lower: + return 'bicycle' + + elif 'motorcycle' in type_lower: + return 'motorcycle' + else: return 'unknown' - def _detect_high_risk_interactions(self, objects): - """检测高风险交互""" + def _analyze_pedestrian_risk(self, pedestrians, vehicles): + """分析行人风险(增强版)""" high_risk_count = 0 - pedestrians = [obj for obj in objects if obj['class'] == 'pedestrian'] - vehicles = [obj for obj in objects if obj['class'] in ['car', 'vehicle']] + near_miss_count = 0 + distances = [] for pedestrian in pedestrians: + min_distance = float('inf') + min_vehicle = None + for vehicle in vehicles: # 计算距离 p_loc = pedestrian['location'] @@ -139,15 +198,118 @@ def _detect_high_risk_interactions(self, objects): distance = np.sqrt( (p_loc['x'] - v_loc['x']) ** 2 + - (p_loc['y'] - v_loc['y']) ** 2 + - (p_loc['z'] - v_loc['z']) ** 2 + (p_loc['y'] - v_loc['y']) ** 2 ) - # 如果距离小于5米,认为是高风险交互 - if distance < 5.0: - high_risk_count += 1 + # 考虑车辆速度和类型 + vehicle_speed = vehicle['velocity'].get('speed_kmh', 0) + vehicle_type = vehicle.get('type', 'car') + + # 调整风险阈值(卡车和公交车需要更大的安全距离) + safe_distance = 5.0 + if vehicle_type in ['truck', 'bus']: + safe_distance = 7.0 + + # 考虑速度因素 + if vehicle_speed > 30: + safe_distance *= (1 + (vehicle_speed - 30) / 50) + + distances.append({ + 'pedestrian_id': pedestrian['id'], + 'vehicle_id': vehicle['id'], + 'distance': distance, + 'vehicle_speed': vehicle_speed, + 'vehicle_type': vehicle_type, + 'safe_distance': safe_distance + }) + + if distance < safe_distance: + if distance < safe_distance * 0.5: + high_risk_count += 1 + else: + near_miss_count += 1 + + # 评估整体风险级别 + risk_level = 'low' + if high_risk_count > 3: + risk_level = 'critical' + elif high_risk_count > 1: + risk_level = 'high' + elif near_miss_count > 3: + risk_level = 'medium' + + return { + 'high_risk_count': high_risk_count, + 'near_miss_count': near_miss_count, + 'distances': distances, + 'risk_level': risk_level + } - return high_risk_count + def _track_pedestrian_trajectories(self, frame_num, pedestrians): + """跟踪行人轨迹""" + for pedestrian in pedestrians: + ped_id = pedestrian['id'] + if ped_id not in self.safety_stats['pedestrian_trajectories']: + self.safety_stats['pedestrian_trajectories'][ped_id] = [] + + self.safety_stats['pedestrian_trajectories'][ped_id].append({ + 'frame': frame_num, + 'location': pedestrian['location'], + 'velocity': pedestrian['velocity'] + }) + + # 只保留最近100帧的轨迹 + if len(self.safety_stats['pedestrian_trajectories'][ped_id]) > 100: + self.safety_stats['pedestrian_trajectories'][ped_id].pop(0) + + def _detect_risk_zones(self, pedestrians, vehicles): + """检测高风险区域""" + risk_zones = [] + + # 行人密集区域 + if len(pedestrians) >= 3: + # 计算行人质心 + locations = np.array([[p['location']['x'], p['location']['y']] for p in pedestrians]) + centroid = np.mean(locations, axis=0) + + # 计算区域半径 + distances = np.sqrt(np.sum((locations - centroid) ** 2, axis=1)) + radius = np.max(distances) + 5.0 + + risk_zones.append({ + 'type': 'pedestrian_crowd', + 'center': {'x': float(centroid[0]), 'y': float(centroid[1])}, + 'radius': float(radius), + 'pedestrian_count': len(pedestrians), + 'risk_level': 'high' if len(pedestrians) > 5 else 'medium' + }) + + # 车辆行人交互区域 + for vehicle in vehicles: + if vehicle['velocity'].get('speed_kmh', 0) > 30: + v_loc = vehicle['location'] + nearby_pedestrians = 0 + + for pedestrian in pedestrians: + p_loc = pedestrian['location'] + distance = np.sqrt( + (p_loc['x'] - v_loc['x']) ** 2 + + (p_loc['y'] - v_loc['y']) ** 2 + ) + + if distance < 20: + nearby_pedestrians += 1 + + if nearby_pedestrians >= 2: + risk_zones.append({ + 'type': 'vehicle_pedestrian_interaction', + 'location': v_loc, + 'vehicle_speed': vehicle['velocity'].get('speed_kmh', 0), + 'pedestrian_count': nearby_pedestrians, + 'risk_level': 'high' if vehicle['velocity'].get('speed_kmh', 0) > 50 else 'medium' + }) + + return risk_zones def _save_annotations(self, frame_num, annotations): """保存标注到文件""" @@ -158,13 +320,29 @@ def _save_annotations(self, frame_num, annotations): json.dump(annotations, f, indent=2, ensure_ascii=False) # 同时更新总标注文件 - self.frame_annotations[frame_num] = annotations - self._update_master_annotation() + with self.lock: + self.frame_annotations[frame_num] = annotations + self._update_master_annotation() def _update_master_annotation(self): """更新主标注文件""" master_file = os.path.join(self.annotations_dir, "annotations.json") + # 计算安全统计 + total_high_risk = 0 + total_near_miss = 0 + max_risk_level = 'low' + + for frame_data in self.frame_annotations.values(): + total_high_risk += frame_data['safety_info']['high_risk_interactions'] + total_near_miss += frame_data['safety_info']['near_miss_count'] + + # 更新最高风险级别 + risk_level = frame_data['safety_info']['risk_level'] + risk_weights = {'low': 0, 'medium': 1, 'high': 2, 'critical': 3} + if risk_weights[risk_level] > risk_weights[max_risk_level]: + max_risk_level = risk_level + master_data = { 'total_frames': len(self.frame_annotations), 'total_objects': self.object_counter, @@ -173,8 +351,10 @@ def _update_master_annotation(self): 'safety_summary': { 'total_pedestrians': sum(f['safety_info']['pedestrian_count'] for f in self.frame_annotations.values()), 'total_vehicles': sum(f['safety_info']['vehicle_count'] for f in self.frame_annotations.values()), - 'total_high_risk': sum( - f['safety_info']['high_risk_interactions'] for f in self.frame_annotations.values()) + 'total_high_risk': total_high_risk, + 'total_near_misses': total_near_miss, + 'max_risk_level': max_risk_level, + 'pedestrian_trajectories': len(self.safety_stats['pedestrian_trajectories']) } } @@ -182,35 +362,58 @@ def _update_master_annotation(self): json.dump(master_data, f, indent=2, ensure_ascii=False) def generate_summary(self): - """生成标注摘要""" + """生成标注摘要(增强版)""" vehicle_count = 0 pedestrian_count = 0 + bicycle_count = 0 other_count = 0 high_risk_count = 0 + near_miss_count = 0 for frame_data in self.frame_annotations.values(): for obj in frame_data.get('objects', []): - if obj['class'] in ['car', 'vehicle']: + if obj['class'] in ['car', 'vehicle', 'truck', 'bus']: vehicle_count += 1 elif obj['class'] == 'pedestrian': pedestrian_count += 1 + elif obj['class'] == 'bicycle': + bicycle_count += 1 else: other_count += 1 high_risk_count += frame_data['safety_info']['high_risk_interactions'] + near_miss_count += frame_data['safety_info']['near_miss_count'] + + # 计算安全指标 + total_interactions = high_risk_count + near_miss_count + safety_score = 100 + if total_interactions > 0: + risk_ratio = high_risk_count / total_interactions + safety_score = max(0, 100 - risk_ratio * 100) summary = { 'total_frames': len(self.frame_annotations), 'total_objects': self.object_counter, 'vehicles': vehicle_count, 'pedestrians': pedestrian_count, + 'bicycles': bicycle_count, 'other_objects': other_count, 'high_risk_interactions': high_risk_count, + 'near_miss_interactions': near_miss_count, 'average_objects_per_frame': self.object_counter / len( self.frame_annotations) if self.frame_annotations else 0, 'safety_metrics': { + 'safety_score': safety_score, 'pedestrian_to_vehicle_ratio': pedestrian_count / max(1, vehicle_count), - 'high_risk_percentage': high_risk_count / max(1, self.object_counter) * 100 + 'high_risk_percentage': high_risk_count / max(1, total_interactions) * 100, + 'interaction_frequency': total_interactions / len( + self.frame_annotations) if self.frame_annotations else 0 + }, + 'trajectory_analysis': { + 'unique_pedestrians': len(self.safety_stats['pedestrian_trajectories']), + 'average_trajectory_length': np.mean( + [len(t) for t in self.safety_stats['pedestrian_trajectories'].values()]) if self.safety_stats[ + 'pedestrian_trajectories'] else 0 } } @@ -218,4 +421,68 @@ def generate_summary(self): with open(summary_file, 'w', encoding='utf-8') as f: json.dump(summary, f, indent=2, ensure_ascii=False) - return summary \ No newline at end of file + return summary + + def generate_safety_report(self): + """生成详细安全报告""" + report = { + 'timestamp': datetime.now().isoformat(), + 'frames_analyzed': len(self.frame_annotations), + 'safety_statistics': self.safety_stats, + 'risk_analysis': self._analyze_risk_patterns(), + 'recommendations': self._generate_safety_recommendations() + } + + report_file = os.path.join(self.annotations_dir, "safety_report.json") + with open(report_file, 'w', encoding='utf-8') as f: + json.dump(report, f, indent=2, ensure_ascii=False) + + return report + + def _analyze_risk_patterns(self): + """分析风险模式""" + risk_patterns = { + 'high_risk_frames': [], + 'time_of_day_patterns': {}, + 'location_patterns': {}, + 'speed_patterns': {} + } + + # 分析高风险帧的模式 + for frame_num, frame_data in self.frame_annotations.items(): + if frame_data['safety_info']['high_risk_interactions'] > 0: + risk_patterns['high_risk_frames'].append({ + 'frame': frame_num, + 'high_risk_count': frame_data['safety_info']['high_risk_interactions'], + 'risk_level': frame_data['safety_info']['risk_level'] + }) + + return risk_patterns + + def _generate_safety_recommendations(self): + """生成安全建议""" + recommendations = [] + + # 基于统计数据的建议 + total_high_risk = sum(f['safety_info']['high_risk_interactions'] for f in self.frame_annotations.values()) + + if total_high_risk > 10: + recommendations.append("建议增加行人安全监控频率") + recommendations.append("考虑降低高风险区域的车辆速度限制") + + if self.safety_stats['near_misses'] > 20: + recommendations.append("建议实施主动行人检测和预警系统") + recommendations.append("考虑增加人行横道和行人信号灯") + + # 基于轨迹分析的建议 + if len(self.safety_stats['pedestrian_trajectories']) > 0: + avg_speed = np.mean([ + np.sqrt(p['velocity']['x'] ** 2 + p['velocity']['y'] ** 2) + for traj in self.safety_stats['pedestrian_trajectories'].values() + for p in traj + ]) + + if avg_speed > 2.0: # 米/秒 + recommendations.append("行人移动速度较快,建议加强行人流量管理") + + return recommendations \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/carla_utils.py b/src/enhance_pedestrian_safety/carla_utils.py index 349f4e7c78..dae031b8fe 100644 --- a/src/enhance_pedestrian_safety/carla_utils.py +++ b/src/enhance_pedestrian_safety/carla_utils.py @@ -1,14 +1,16 @@ """ -CARLA 工具模块 - 用于自动查找和配置 CARLA 路径 +CARLA 工具模块 - 用于自动查找和配置 CARLA 路径(增强版) """ import sys import os import glob import argparse +import subprocess +import time def find_carla_egg(): - """自动查找CARLA的egg文件""" + """自动查找CARLA的egg文件(增强版)""" common_paths = [ os.path.expanduser("~/carla/*"), os.path.expanduser("~/Desktop/carla/*"), @@ -16,87 +18,338 @@ def find_carla_egg(): "/opt/carla/*", "C:/carla/*", "D:/carla/*", + "E:/carla/*", os.path.dirname(os.path.abspath(__file__)), os.path.join(os.path.dirname(os.path.abspath(__file__)), "carla"), + os.getcwd(), + os.path.join(os.getcwd(), "carla"), ] + # 添加环境变量路径 + if os.getenv("CARLA_ROOT"): + common_paths.insert(0, os.getenv("CARLA_ROOT")) + + egg_files = [] + for path in common_paths: - egg_pattern = os.path.join(path, "PythonAPI", "carla", "dist", "carla-*.egg") - egg_files = glob.glob(egg_pattern, recursive=True) - if egg_files: - return egg_files[0] - egg_pattern = os.path.join(path, "dist", "carla-*.egg") - egg_files = glob.glob(egg_pattern, recursive=True) - if egg_files: - return egg_files[0] - return None + # 检查路径是否存在 + if not os.path.exists(path.replace("*", "")): + continue + + # 搜索.egg文件 + egg_patterns = [ + os.path.join(path, "PythonAPI", "carla", "dist", "carla-*.egg"), + os.path.join(path, "PythonAPI", "carla", "dist", "carla-*%d*.egg" % sys.version_info.major), + os.path.join(path, "dist", "carla-*.egg"), + os.path.join(path, "dist", "carla-*%d*.egg" % sys.version_info.major), + os.path.join(path, "carla-*.egg"), + os.path.join(path, "PythonAPI", "dist", "carla-*.egg"), + ] + + for pattern in egg_patterns: + found = glob.glob(pattern, recursive=True) + if found: + egg_files.extend(found) + + # 去重并排序(最新的优先) + egg_files = list(set(egg_files)) + egg_files.sort(key=os.path.getmtime, reverse=True) + + return egg_files[0] if egg_files else None + + +def check_carla_server(): + """检查CARLA服务器是否运行""" + try: + import socket + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.settimeout(2) + result = sock.connect_ex(('localhost', 2000)) + sock.close() + return result == 0 + except: + return False + + +def start_carla_server(carla_path=None): + """启动CARLA服务器""" + if check_carla_server(): + print("CARLA服务器已在运行") + return True + + print("正在启动CARLA服务器...") + + # 查找CarlaUE4可执行文件 + carla_binaries = [] + + if carla_path: + search_paths = [carla_path] + else: + search_paths = [ + os.path.expanduser("~/carla"), + "/opt/carla", + "C:/carla", + "D:/carla", + "E:/carla", + ] + + for path in search_paths: + if os.path.exists(path): + # Linux + linux_bin = os.path.join(path, "CarlaUE4", "Binaries", "Linux", "CarlaUE4-Linux-Shipping") + if os.path.exists(linux_bin): + carla_binaries.append(linux_bin) + + # Windows + win_bin = os.path.join(path, "CarlaUE4.exe") + if os.path.exists(win_bin): + carla_binaries.append(win_bin) + + if not carla_binaries: + print("未找到CARLA可执行文件") + return False + + # 启动服务器 + try: + cmd = [carla_binaries[0], "-quality-level=Low", "-fps=10"] + if os.name == 'posix': # Linux/Unix + subprocess.Popen(cmd, start_new_session=True) + else: # Windows + subprocess.Popen(cmd, creationflags=subprocess.CREATE_NEW_PROCESS_GROUP) + + # 等待服务器启动 + print("等待CARLA服务器启动...") + for i in range(30): # 等待30秒 + if check_carla_server(): + print("CARLA服务器启动成功") + time.sleep(2) # 额外等待2秒确保完全启动 + return True + time.sleep(1) + + print("CARLA服务器启动超时") + return False + + except Exception as e: + print(f"启动CARLA服务器失败: {e}") + return False def setup_carla_path(): - """设置CARLA路径并返回配置信息""" - print("\n[1/6] 初始化CARLA环境...") + """设置CARLA路径并返回配置信息(增强版)""" + print("\n" + "=" * 50) + print("[1/6] 初始化CARLA环境...") + print("=" * 50) path_parser = argparse.ArgumentParser(add_help=False) - path_parser.add_argument('--carla-path', type=str, help='CARLA的egg文件路径或dist目录路径') + path_parser.add_argument('--carla-path', type=str, help='CARLA的egg文件路径或CARLA根目录路径') + path_parser.add_argument('--start-server', action='store_true', help='自动启动CARLA服务器') + path_parser.add_argument('--server-timeout', type=int, default=30, help='服务器启动超时时间(秒)') args_path, remaining_argv = path_parser.parse_known_args() carla_egg_path = None + # 1. 首先检查命令行参数 if args_path.carla_path: + print(f"使用命令行指定的CARLA路径: {args_path.carla_path}") + if os.path.isfile(args_path.carla_path) and args_path.carla_path.endswith('.egg'): carla_egg_path = args_path.carla_path + egg_dir = os.path.dirname(carla_egg_path) + if egg_dir not in sys.path: + sys.path.append(egg_dir) + print(f"✓ 添加egg文件目录到系统路径: {egg_dir}") + elif os.path.isdir(args_path.carla_path): - egg_files = glob.glob(os.path.join(args_path.carla_path, "carla-*.egg")) - if egg_files: + # 搜索.egg文件 + egg_files = glob.glob(os.path.join(args_path.carla_path, "**", "carla-*.egg"), recursive=True) + + # 优先选择与Python版本匹配的egg + py_version = f"{sys.version_info.major}{sys.version_info.minor}" + version_matched = [f for f in egg_files if py_version in f] + + if version_matched: + carla_egg_path = version_matched[0] + elif egg_files: carla_egg_path = egg_files[0] - if carla_egg_path: - sys.path.append(os.path.dirname(carla_egg_path)) - print(f"✓ 通过命令行参数加载CARLA egg文件: {carla_egg_path}") - return carla_egg_path, remaining_argv - else: - print(f"✗ 命令行参数指定的路径中未找到CARLA egg文件: {args_path.carla_path}") - sys.exit(1) + if carla_egg_path: + egg_dir = os.path.dirname(carla_egg_path) + if egg_dir not in sys.path: + sys.path.append(egg_dir) + print(f"✓ 添加egg文件目录到系统路径: {egg_dir}") + else: + # 如果目录下没有.egg文件,尝试将其添加到Python路径 + pythonapi_path = os.path.join(args_path.carla_path, "PythonAPI") + if os.path.exists(pythonapi_path): + sys.path.append(pythonapi_path) + print(f"✓ 添加PythonAPI目录到系统路径: {pythonapi_path}") + else: + sys.path.append(args_path.carla_path) + print(f"✓ 添加CARLA目录到系统路径: {args_path.carla_path}") - elif os.getenv("CARLA_PYTHON_PATH"): + # 2. 检查环境变量 + if not carla_egg_path and os.getenv("CARLA_PYTHON_PATH"): env_carla_path = os.getenv("CARLA_PYTHON_PATH") + print(f"使用环境变量CARLA_PYTHON_PATH: {env_carla_path}") + if os.path.isfile(env_carla_path) and env_carla_path.endswith('.egg'): carla_egg_path = env_carla_path + egg_dir = os.path.dirname(carla_egg_path) + if egg_dir not in sys.path: + sys.path.append(egg_dir) + print(f"✓ 通过环境变量添加egg文件目录: {egg_dir}") + elif os.path.isdir(env_carla_path): - egg_files = glob.glob(os.path.join(env_carla_path, "carla-*.egg")) + egg_files = glob.glob(os.path.join(env_carla_path, "**", "carla-*.egg"), recursive=True) if egg_files: carla_egg_path = egg_files[0] + egg_dir = os.path.dirname(carla_egg_path) + if egg_dir not in sys.path: + sys.path.append(egg_dir) + print(f"✓ 通过环境变量添加egg文件目录: {egg_dir}") + else: + # 将目录添加到Python路径 + sys.path.append(env_carla_path) + print(f"✓ 通过环境变量添加目录到系统路径: {env_carla_path}") - if carla_egg_path: - sys.path.append(os.path.dirname(carla_egg_path)) - print(f"✓ 通过环境变量加载CARLA egg文件: {carla_egg_path}") - return carla_egg_path, remaining_argv - else: - print(f"✗ 环境变量CARLA_PYTHON_PATH中未找到CARLA egg文件: {env_carla_path}") - sys.exit(1) - - else: + # 3. 自动查找 + if not carla_egg_path: + print("正在自动查找CARLA egg文件...") carla_egg_path = find_carla_egg() + if carla_egg_path: - sys.path.append(os.path.dirname(carla_egg_path)) - print(f"✓ 自动找到CARLA egg文件: {carla_egg_path}") - return carla_egg_path, remaining_argv + egg_dir = os.path.dirname(carla_egg_path) + if egg_dir not in sys.path: + sys.path.append(egg_dir) + print(f"✓ 自动找到并添加CARLA egg文件目录: {egg_dir}") else: - print("✗ 未找到CARLA egg文件!") - print("提示:请通过以下方式之一配置CARLA路径:") - print(" 1. 命令行参数:--carla-path ") - print(" 2. 环境变量:设置CARLA_PYTHON_PATH=") - print(" 3. 将CARLA放在用户目录carla/、桌面carla/或/opt/carla/(自动查找)") - sys.exit(1) + print("⚠ 未找到CARLA egg文件,尝试继续...") + + # 4. 检查CARLA模块是否可导入 + print("\n[2/6] 检查CARLA模块...") + try: + import carla + print("✓ CARLA模块导入成功") + + # 检查服务器连接 + print("\n[3/6] 检查CARLA服务器连接...") + if args_path.start_server: + if not start_carla_server(args_path.carla_path): + print("✗ CARLA服务器启动失败") + print("提示:请手动启动CARLA服务器后再运行程序") + sys.exit(1) + elif not check_carla_server(): + print("⚠ CARLA服务器未运行") + print("提示:请启动CARLA服务器或使用 --start-server 参数") + # 不退出,让用户选择是否继续 + + return carla_egg_path, remaining_argv + + except ImportError as e: + print(f"✗ CARLA模块导入失败: {e}") + print("\n" + "=" * 50) + print("CARLA配置指南:") + print("=" * 50) + print("请通过以下方式之一配置CARLA路径:") + print("\n1. 命令行参数(推荐):") + print(" python main.py --carla-path ") + print("\n2. 环境变量:") + print(" export CARLA_PYTHON_PATH=/PythonAPI") + print("\n3. 自动查找(将CARLA放在以下目录之一):") + print(" ~/carla/") + print(" ~/Desktop/carla/") + print(" /opt/carla/") + print(" C:/carla/") + print("\n4. 启动CARLA服务器:") + print(" python main.py --start-server") + print("\n提示:确保CARLA版本与Python版本匹配") + print("=" * 50) + sys.exit(1) def import_carla_module(): """导入CARLA模块""" - print("\n[2/6] 导入CARLA模块...") + print("\n[4/6] 导入CARLA模块...") try: import carla print("✓ CARLA模块导入成功") + + # 打印CARLA版本信息 + if hasattr(carla, '__version__'): + print(f" CARLA版本: {carla.__version__}") + else: + print(" CARLA版本: 未知") + + # 测试基本功能 + try: + client = carla.Client('localhost', 2000) + client.set_timeout(5.0) + world = client.get_world() + print(f" CARLA服务器: 已连接 ({world.get_map().name})") + client.reload_world(False) # 重置但不重新生成交通 + except Exception as e: + print(f" CARLA服务器连接: 失败 ({str(e)[:50]})") + print(" 提示:确保CARLA服务器正在运行") + return carla except ImportError as e: print(f"✗ 导入失败: {e}") - sys.exit(1) \ No newline at end of file + sys.exit(1) + + +def setup_carla_environment(): + """设置完整的CARLA环境""" + print("\n" + "=" * 50) + print("CARLA环境设置") + print("=" * 50) + + # 1. 设置路径 + carla_egg_path, remaining_argv = setup_carla_path() + + # 2. 导入模块 + carla_module = import_carla_module() + + # 3. 验证环境 + print("\n[5/6] 验证环境配置...") + + # 检查Python版本兼容性 + py_version = f"{sys.version_info.major}.{sys.version_info.minor}" + print(f" Python版本: {py_version}") + + # 检查必要依赖 + required_modules = ['numpy', 'PIL', 'opencv-python'] + for module in required_modules: + try: + __import__(module.replace('-', '_')) + print(f" {module}: ✓") + except ImportError: + print(f" {module}: ✗ (建议安装: pip install {module})") + + # 4. 最终状态 + print("\n[6/6] 环境设置完成") + print("-" * 30) + print("状态汇总:") + print(f" CARLA路径: {carla_egg_path or '使用系统路径'}") + print(f" 剩余参数: {remaining_argv}") + print("=" * 50) + print() + + return carla_module, remaining_argv + + +def cleanup_carla(): + """清理CARLA资源""" + print("\n清理CARLA环境...") + try: + import carla + # 这里可以添加自定义的清理逻辑 + print("✓ CARLA环境清理完成") + except: + print("⚠ CARLA环境清理跳过") + + +if __name__ == "__main__": + # 测试函数 + carla_module, args = setup_carla_environment() + print(f"CARLA模块: {carla_module}") + print(f"剩余参数: {args}") \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/config_manager.py b/src/enhance_pedestrian_safety/config_manager.py index 7276b09a15..c30e39fb5d 100644 --- a/src/enhance_pedestrian_safety/config_manager.py +++ b/src/enhance_pedestrian_safety/config_manager.py @@ -3,6 +3,7 @@ import argparse import copy from typing import Dict, Any, Optional, List, Tuple +from datetime import datetime try: import yaml @@ -13,129 +14,222 @@ class ConfigValidator: + """配置验证器(增强版)""" @staticmethod def validate_config(config: Dict[str, Any]) -> Tuple[bool, List[str]]: errors = [] + warnings = [] + # 基本结构验证 required_sections = ['scenario', 'sensors', 'output'] for section in required_sections: if section not in config: errors.append(f"缺失必要配置节: {section}") + # 场景配置验证 if 'scenario' in config: scenario = config['scenario'] - if 'duration' in scenario and scenario['duration'] <= 0: - errors.append("场景时长必须大于0") + if 'duration' in scenario: + if scenario['duration'] <= 0: + errors.append("场景时长必须大于0") + elif scenario['duration'] > 3600: + warnings.append("场景时长超过1小时,可能导致内存不足") if 'town' not in scenario: errors.append("场景配置中缺失地图名称") + if 'pedestrian_safety_mode' not in scenario: + warnings.append("建议启用行人安全模式以增强数据收集") + # 传感器配置验证 if 'sensors' in config: sensors = config['sensors'] - if 'capture_interval' in sensors and sensors['capture_interval'] <= 0: - errors.append("采集间隔必须大于0") + if 'capture_interval' in sensors: + if sensors['capture_interval'] <= 0: + errors.append("采集间隔必须大于0") + elif sensors['capture_interval'] < 0.5: + warnings.append("采集间隔过小可能导致性能问题") if 'image_size' in sensors: if len(sensors['image_size']) != 2: errors.append("图像尺寸必须为[宽度, 高度]格式") elif any(dim <= 0 for dim in sensors['image_size']): errors.append("图像尺寸必须大于0") - + elif sensors['image_size'][0] > 1920 or sensors['image_size'][1] > 1080: + warnings.append("图像尺寸较大,可能影响处理速度") + + # 行人安全配置验证 + if 'traffic' in config: + traffic = config['traffic'] + if 'pedestrians' in traffic: + if traffic['pedestrians'] < 0: + errors.append("行人数量不能为负数") + elif traffic['pedestrians'] > 50: + warnings.append("行人数量过多,可能导致场景混乱") + if 'speed_limit' in traffic: + if traffic['speed_limit'] > 120: + warnings.append("车速限制过高,影响行人安全评估") + + # 性能配置验证 if 'performance' in config: perf = config['performance'] - if 'batch_size' in perf and perf['batch_size'] <= 0: - errors.append("批处理大小必须大于0") - - return len(errors) == 0, errors + if 'batch_size' in perf: + if perf['batch_size'] <= 0: + errors.append("批处理大小必须大于0") + elif perf['batch_size'] > 100: + warnings.append("批处理大小过大,可能导致内存溢出") + if 'frame_rate_limit' in perf: + if perf['frame_rate_limit'] > 60: + warnings.append("帧率限制过高,可能导致性能问题") + + # V2X配置验证 + if 'v2x' in config and config['v2x'].get('enabled', False): + v2x = config['v2x'] + if 'communication_range' in v2x and v2x['communication_range'] > 1000: + warnings.append("V2X通信范围过大,可能导致不切实际的模拟") + if 'update_interval' in v2x and v2x['update_interval'] < 0.1: + warnings.append("V2X更新间隔过小,可能导致通信拥塞") + + return len(errors) == 0, errors, warnings @staticmethod def suggest_optimizations(config: Dict[str, Any]) -> List[str]: suggestions = [] + # LiDAR优化建议 if config.get('sensors', {}).get('lidar_sensors', 0) > 0: lidar_config = config['sensors'].get('lidar_config', {}) max_points = lidar_config.get('max_points_per_frame', 50000) if max_points > 50000: suggestions.append(f"LiDAR最大点数({max_points})较高,建议降低到50000以下以减少内存使用") + channels = lidar_config.get('channels', 32) + if channels > 64: + suggestions.append(f"LiDAR通道数({channels})较高,建议降低到64以下以提高性能") + + # 采集间隔建议 capture_interval = config['sensors'].get('capture_interval', 2.0) - if capture_interval < 1.0: - suggestions.append(f"采集间隔({capture_interval}s)较短,可能导致高负载,建议增加到1.0s以上") + if capture_interval < 0.5: + suggestions.append(f"采集间隔({capture_interval}s)过短,可能导致高负载,建议增加到0.5s以上") + elif capture_interval > 5.0: + suggestions.append(f"采集间隔({capture_interval}s)较长,可能丢失重要数据,建议降低到5.0s以下") + # 输出配置建议 output = config.get('output', {}) enabled_outputs = [k for k, v in output.items() if isinstance(v, bool) and v] - if len(enabled_outputs) > 5: + if len(enabled_outputs) > 8: suggestions.append(f"启用的输出类型过多({len(enabled_outputs)}),可能影响性能,建议只启用必要的输出") - # 行人安全相关建议 - if config.get('traffic', {}).get('pedestrians', 0) < 5: + # 行人安全建议 + pedestrians = config.get('traffic', {}).get('pedestrians', 0) + if pedestrians < 5: suggestions.append("行人数量较少,建议增加行人数量以更好地测试行人安全") + elif pedestrians > 30: + suggestions.append("行人数量较多,建议减少以保持场景清晰度") if not config.get('v2x', {}).get('enabled', False): suggestions.append("V2X通信未启用,建议启用以支持行人安全预警") + # 协同感知建议 + if config.get('cooperative', {}).get('num_coop_vehicles', 0) > 5: + suggestions.append("协同车辆数量过多,建议减少到5辆以下以降低复杂度") + return suggestions class ConfigOptimizer: + """配置优化器(增强版)""" @staticmethod def optimize_for_memory(config: Dict[str, Any]) -> Dict[str, Any]: + """内存优化配置""" optimized = copy.deepcopy(config) - if optimized['sensors'].get('lidar_sensors', 0) > 0: - lidar_config = optimized['sensors'].setdefault('lidar_config', {}) - lidar_config.update({ - 'max_points_per_frame': 30000, - 'downsample_ratio': 0.4, - 'memory_warning_threshold': 200, - 'max_batch_memory_mb': 30 - }) + # 传感器优化 + optimized['sensors'].update({ + 'image_size': [640, 480], + 'capture_interval': 3.0, + 'lidar_sensors': 0, + 'radar_sensors': 0, + 'infrastructure_cameras': 2 + }) + # 性能优化 perf = optimized.setdefault('performance', {}) perf.update({ - 'batch_size': 3, + 'batch_size': 2, 'enable_compression': True, - 'compression_level': 4, + 'compression_level': 6, 'enable_memory_cache': True, - 'max_cache_size': 30, - 'frame_rate_limit': 3.0 + 'max_cache_size': 20, + 'frame_rate_limit': 2.0, + 'enable_async_processing': False, + 'max_workers': 1, + 'memory_management': { + 'gc_interval': 20, + 'max_memory_mb': 200, + 'early_stop_threshold': 180 + } }) - perf['image_processing'] = { - 'compress_images': True, - 'compression_quality': 80, - 'resize_images': False - } + # 输出优化 + output = optimized['output'] + output.update({ + 'save_raw': True, + 'save_stitched': False, + 'save_annotations': True, + 'save_lidar': False, + 'save_fusion': False, + 'save_cooperative': False, + 'save_v2x_messages': False, + 'save_enhanced': False, + 'save_safety_reports': True, + 'compression_enabled': True + }) return optimized @staticmethod def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: + """质量优化配置""" optimized = copy.deepcopy(config) + # 传感器优化 sensors = optimized['sensors'] sensors.update({ 'image_size': [1920, 1080], - 'capture_interval': 1.0, - 'lidar_sensors': 1, - 'lidar_config': { - 'channels': 64, - 'range': 150.0, - 'points_per_second': 120000, - 'max_points_per_frame': 100000, - 'downsample_ratio': 0.1 - } + 'capture_interval': 0.5, + 'lidar_sensors': 2, + 'radar_sensors': 1, + 'infrastructure_cameras': 6, + 'vehicle_cameras': 4 }) + # LiDAR配置 + sensors['lidar_config'].update({ + 'channels': 64, + 'range': 200.0, + 'points_per_second': 200000, + 'max_points_per_frame': 120000, + 'downsample_ratio': 0.05 + }) + + # 输出配置 output = optimized['output'] output.update({ + 'save_raw': True, + 'save_stitched': True, 'save_annotations': True, + 'save_lidar': True, 'save_fusion': True, 'save_cooperative': True, + 'save_v2x_messages': True, 'save_enhanced': True, - 'run_quality_check': True + 'save_safety_reports': True, + 'run_quality_check': True, + 'validate_data': True, + 'generate_safety_summary': True }) + # 增强配置 enhanced = optimized.setdefault('enhancement', {}) enhanced.update({ 'enabled': True, @@ -144,37 +238,50 @@ def optimize_for_quality(config: Dict[str, Any]) -> Dict[str, Any]: 'save_original': True, 'save_enhanced': True, 'calibration_generation': True, - 'enhanced_dir_name': 'enhanced', - 'methods': ['normalize', 'contrast', 'brightness'], + 'enhanced_dir_name': 'enhanced_quality', + 'methods': ['normalize', 'contrast', 'brightness', 'sharpness', 'noise'], 'weather_effects': True, - 'augmentation_level': 'medium' + 'augmentation_level': 'high', + 'pedestrian_safety_mode': True }) return optimized @staticmethod def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: + """速度优化配置""" optimized = copy.deepcopy(config) + # 传感器优化 sensors = optimized['sensors'] sensors.update({ - 'image_size': [640, 480], - 'capture_interval': 3.0, + 'image_size': [640, 360], + 'capture_interval': 5.0, 'lidar_sensors': 0, - 'radar_sensors': 0 + 'radar_sensors': 0, + 'infrastructure_cameras': 2, + 'vehicle_cameras': 2 }) + # 性能优化 perf = optimized.setdefault('performance', {}) perf.update({ - 'batch_size': 10, + 'batch_size': 20, 'enable_compression': True, 'compression_level': 1, - 'enable_downsampling': True, + 'enable_memory_cache': False, + 'max_cache_size': 10, + 'frame_rate_limit': 15.0, 'enable_async_processing': True, - 'max_cache_size': 20, - 'frame_rate_limit': 10.0 + 'max_workers': 4, + 'memory_management': { + 'gc_interval': 100, + 'max_memory_mb': 300, + 'early_stop_threshold': 280 + } }) + # 输出优化 output = optimized['output'] output.update({ 'save_raw': True, @@ -182,85 +289,113 @@ def optimize_for_speed(config: Dict[str, Any]) -> Dict[str, Any]: 'save_annotations': False, 'save_lidar': False, 'save_fusion': False, - 'save_cooperative': False + 'save_cooperative': False, + 'save_v2x_messages': False, + 'save_enhanced': False, + 'save_safety_reports': True, + 'compression_enabled': True }) return optimized @staticmethod def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: - """优化配置以增强行人安全""" + """行人安全优化配置(增强版)""" optimized = copy.deepcopy(config) - # 增加行人密度 + # 增加行人密度和多样性 traffic = optimized['traffic'] traffic.update({ - 'pedestrians': 12, # 增加行人数量 + 'pedestrians': 20, # 增加行人数量 'pedestrian_types': [ 'walker.pedestrian.0001', 'walker.pedestrian.0002', 'walker.pedestrian.0003', - 'walker.pedestrian.0004' + 'walker.pedestrian.0004', + 'walker.pedestrian.0005', + 'walker.pedestrian.0006', + 'walker.pedestrian.0007', + 'walker.pedestrian.0008' ], - 'speed_limit': 30.0 # 添加车速限制 + 'pedestrian_behaviors': ['walking', 'crossing', 'waiting', 'running', 'jogging'], + 'speed_limit': 30.0, + 'pedestrian_safety_zones': True, + 'crosswalk_density': 'high' }) # 优化传感器配置以更好地检测行人 sensors = optimized['sensors'] sensors.update({ - 'image_size': [1280, 720], - 'capture_interval': 1.5, # 更频繁地捕获 + 'image_size': [1920, 1080], + 'capture_interval': 1.0, # 更频繁地捕获 'vehicle_cameras': 4, + 'infrastructure_cameras': 6, 'camera_config': { - 'fov': 100.0, # 更宽的视野 - 'post_processing': 'default', + 'fov': 120.0, # 更宽的视野 + 'post_processing': 'semantic', # 语义分割 'exposure_mode': 'auto', - 'motion_blur': 0.0 + 'motion_blur': 0.0, + 'pedestrian_detection_mode': True } }) # 启用LiDAR以检测行人 - sensors['lidar_sensors'] = 1 + sensors['lidar_sensors'] = 2 sensors['lidar_config'].update({ 'channels': 64, # 更多通道以检测行人 - 'range': 120.0, - 'points_per_second': 100000, - 'max_points_per_frame': 80000, - 'downsample_ratio': 0.2 + 'range': 150.0, + 'points_per_second': 150000, + 'max_points_per_frame': 100000, + 'downsample_ratio': 0.1, + 'pedestrian_detection': True, + 'height_filter': [-0.5, 2.5] # 过滤地面和过高点 }) # 启用V2X和协同感知 v2x = optimized.setdefault('v2x', {}) v2x.update({ 'enabled': True, - 'communication_range': 300.0, - 'update_interval': 1.0, # 更频繁地更新 + 'communication_range': 500.0, + 'update_interval': 0.5, # 更频繁地更新 'enable_safety_warnings': True, - 'pedestrian_warning_threshold': 10.0 # 行人警告距离阈值 + 'pedestrian_warning_threshold': 15.0, + 'emergency_brake_warning': True, + 'collision_prediction': True, + 'vulnerable_road_user_protection': True }) + # 协同感知配置 coop = optimized.setdefault('cooperative', {}) coop.update({ - 'num_coop_vehicles': 2, + 'num_coop_vehicles': 3, 'enable_shared_perception': True, 'enable_traffic_warnings': True, - 'enable_pedestrian_warnings': True, # 启用行人警告 - 'enable_maneuver_coordination': False, - 'data_fusion_interval': 0.5, # 更频繁地融合 - 'max_shared_objects': 100, - 'object_matching_threshold': 3.0 # 更严格的对象匹配 + 'enable_pedestrian_warnings': True, + 'enable_emergency_brake_assist': True, + 'enable_maneuver_coordination': True, + 'data_fusion_interval': 0.3, # 更频繁地融合 + 'max_shared_objects': 200, + 'object_matching_threshold': 2.0, # 更严格的对象匹配 + 'pedestrian_tracking': True, + 'intention_prediction': True }) # 性能优化 perf = optimized.setdefault('performance', {}) perf.update({ - 'batch_size': 5, + 'batch_size': 8, 'enable_compression': True, - 'compression_level': 3, + 'compression_level': 4, 'enable_memory_cache': True, - 'max_cache_size': 40, - 'frame_rate_limit': 8.0, - 'safety_monitoring_interval': 1.0 # 安全监控间隔 + 'max_cache_size': 60, + 'frame_rate_limit': 10.0, + 'safety_monitoring_interval': 0.5, # 安全监控间隔 + 'emergency_response_time': 0.1, + 'memory_management': { + 'gc_interval': 30, + 'max_memory_mb': 600, + 'early_stop_threshold': 550 + } }) # 输出配置 @@ -272,12 +407,17 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'save_lidar': True, 'save_fusion': True, 'save_cooperative': True, + 'save_v2x_messages': True, 'save_enhanced': True, - 'save_safety_reports': True, # 保存安全报告 + 'save_safety_reports': True, + 'save_risk_maps': True, + 'save_emergency_events': True, 'validate_data': True, 'run_analysis': True, 'run_quality_check': True, - 'generate_safety_summary': True # 生成安全摘要 + 'generate_summary': True, + 'generate_safety_summary': True, + 'generate_risk_assessment': True }) # 增强配置 @@ -289,21 +429,77 @@ def optimize_for_safety(config: Dict[str, Any]) -> Dict[str, Any]: 'save_original': True, 'save_enhanced': True, 'calibration_generation': True, - 'enhanced_dir_name': 'enhanced', - 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', 'safety_warning'], + 'enhanced_dir_name': 'enhanced_safety', + 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', + 'safety_warning', 'risk_visualization', 'attention_heatmap'], 'weather_effects': True, - 'augmentation_level': 'medium', - 'pedestrian_safety_mode': True # 启用行人安全模式 + 'augmentation_level': 'high', + 'pedestrian_safety_mode': True, + 'vulnerable_user_protection': True, + 'emergency_scenario_simulation': True + }) + + # 场景配置 + scenario = optimized['scenario'] + scenario.update({ + 'pedestrian_safety_mode': True, + 'emergency_scenarios': ['crosswalk', 'school_zone', 'blind_spot'], + 'risk_assessment': True, + 'safety_metrics_collection': True + }) + + return optimized + + @staticmethod + def optimize_for_research(config: Dict[str, Any]) -> Dict[str, Any]: + """研究优化配置""" + optimized = copy.deepcopy(config) + + # 增加数据多样性 + optimized['scenario'].update({ + 'weather_variations': ['clear', 'rainy', 'cloudy', 'foggy', 'wet'], + 'time_variations': ['noon', 'sunset', 'night', 'dawn'], + 'random_seed': -1, # 随机种子 + 'scenario_variations': 10 + }) + + # 传感器配置 + sensors = optimized['sensors'] + sensors.update({ + 'image_size': [1280, 720], + 'capture_interval': 1.0, + 'lidar_sensors': 1, + 'radar_sensors': 1, + 'vehicle_cameras': 3, + 'infrastructure_cameras': 4 + }) + + # 输出配置 + output = optimized['output'] + output.update({ + 'save_raw': True, + 'save_stitched': True, + 'save_annotations': True, + 'save_lidar': True, + 'save_fusion': True, + 'save_cooperative': True, + 'save_v2x_messages': True, + 'save_enhanced': True, + 'save_safety_reports': True, + 'save_metadata': True, + 'save_calibration': True }) return optimized class ConfigManager: + """配置管理器(增强版)""" + PRESET_CONFIGS = { 'balanced': { 'description': '平衡配置 - 兼顾性能和质量', - 'optimization': 'memory' + 'optimization': 'balanced' }, 'high_quality': { 'description': '高质量配置 - 优先数据质量', @@ -314,15 +510,23 @@ class ConfigManager: 'optimization': 'speed' }, 'pedestrian_safety': { - 'description': '行人安全配置 - 优化行人检测和安全评估', + 'description': '行人安全配置 - 优化行人检测和安全评估(增强版)', 'optimization': 'safety' }, + 'memory_efficient': { + 'description': '内存高效配置 - 优化内存使用', + 'optimization': 'memory' + }, + 'research_ready': { + 'description': '研究就绪配置 - 适用于学术研究', + 'optimization': 'research' + }, 'v2x_focused': { 'description': 'V2X重点配置 - 优化协同数据采集', 'optimization': 'custom', 'settings': { - 'v2x': {'enabled': True, 'update_interval': 1.0}, - 'cooperative': {'num_coop_vehicles': 3, 'enable_shared_perception': True}, + 'v2x': {'enabled': True, 'update_interval': 0.5}, + 'cooperative': {'num_coop_vehicles': 4, 'enable_shared_perception': True}, 'output': {'save_cooperative': True, 'save_v2x_messages': True} } }, @@ -333,11 +537,35 @@ class ConfigManager: 'sensors': {'lidar_sensors': 2, 'lidar_config': {'channels': 64, 'range': 200}}, 'output': {'save_lidar': True, 'save_fusion': True} } + }, + 'urban_testing': { + 'description': '城市测试配置 - 针对城市环境', + 'optimization': 'custom', + 'settings': { + 'traffic': {'pedestrians': 25, 'background_vehicles': 15}, + 'scenario': {'town': 'Town10HD'} + } + }, + 'emergency_testing': { + 'description': '紧急情况测试 - 测试安全系统响应', + 'optimization': 'custom', + 'settings': { + 'scenario': {'emergency_scenarios': ['pedestrian_crossing', 'child_darting']}, + 'v2x': {'emergency_brake_warning': True}, + 'performance': {'emergency_response_time': 0.05} + } } } @staticmethod - def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) -> Dict[str, Any]: + def load_config(config_file: Optional[str] = None, + preset: Optional[str] = None, + validate: bool = True) -> Dict[str, Any]: + """加载配置(增强版)""" + print("\n" + "=" * 50) + print("加载配置") + print("=" * 50) + config = ConfigManager._get_default_config() if preset: @@ -346,118 +574,180 @@ def load_config(config_file: Optional[str] = None, preset: Optional[str] = None) if config_file: if os.path.exists(config_file): config = ConfigManager._load_config_file(config_file, config) + print(f"✓ 从文件加载配置: {config_file}") else: - print(f"警告: 配置文件不存在: {config_file}") - - is_valid, errors = ConfigValidator.validate_config(config) - if not is_valid: - print("配置验证错误:") - for error in errors: - print(f" - {error}") - raise ValueError("配置验证失败") + print(f"⚠ 配置文件不存在: {config_file}") + # 尝试在预设目录中查找 + preset_dirs = ['configs', 'config', 'presets'] + for preset_dir in preset_dirs: + preset_path = os.path.join(preset_dir, config_file) + if os.path.exists(preset_path): + config = ConfigManager._load_config_file(preset_path, config) + print(f"✓ 从预设目录加载配置: {preset_path}") + break + + if validate: + is_valid, errors, warnings = ConfigValidator.validate_config(config) + + if warnings: + print("\n配置警告:") + for warning in warnings: + print(f" ⚠ {warning}") + + if not is_valid: + print("\n配置验证错误:") + for error in errors: + print(f" ✗ {error}") + raise ValueError("配置验证失败") + else: + print("✓ 配置验证通过") suggestions = ConfigValidator.suggest_optimizations(config) if suggestions: - print("配置优化建议:") + print("\n配置优化建议:") for suggestion in suggestions: - print(f" ⚡ {suggestion}") + print(f" 💡 {suggestion}") + + # 确保必要目录存在 + config['output']['data_dir'] = os.path.abspath(config['output']['data_dir']) + os.makedirs(config['output']['data_dir'], exist_ok=True) + + print(f"输出目录: {config['output']['data_dir']}") + print("=" * 50) return config @staticmethod def _get_default_config() -> Dict[str, Any]: + """获取默认配置(增强版)""" return { 'scenario': { - 'name': 'pedestrian_safety', + 'name': 'pedestrian_safety_enhanced', 'description': '行人安全增强数据采集场景', 'town': 'Town10HD', 'weather': 'clear', 'time_of_day': 'noon', - 'duration': 60, + 'duration': 120, 'seed': 42, - 'timeout': 300, - 'retry_attempts': 3 + 'timeout': 600, + 'retry_attempts': 5, + 'pedestrian_safety_mode': True, + 'emergency_scenarios': ['crosswalk', 'school_zone'], + 'risk_assessment': True, + 'safety_metrics_collection': True }, 'traffic': { 'ego_vehicles': 1, - 'background_vehicles': 8, - 'pedestrians': 12, # 增加默认行人数量 + 'background_vehicles': 12, + 'pedestrians': 15, + 'bicycles': 3, + 'motorcycles': 2, 'traffic_lights': True, 'batch_spawn': True, - 'max_spawn_attempts': 5, + 'max_spawn_attempts': 10, 'vehicle_types': [ 'vehicle.tesla.model3', 'vehicle.audi.tt', 'vehicle.nissan.patrol', - 'vehicle.bmw.grandtourer' + 'vehicle.bmw.grandtourer', + 'vehicle.mercedes.coupe', + 'vehicle.ford.mustang', + 'vehicle.lincoln.mkz2017', + 'vehicle.chevrolet.impala' ], 'pedestrian_types': [ 'walker.pedestrian.0001', 'walker.pedestrian.0002', 'walker.pedestrian.0003', - 'walker.pedestrian.0004' + 'walker.pedestrian.0004', + 'walker.pedestrian.0005', + 'walker.pedestrian.0006', + 'walker.pedestrian.0007', + 'walker.pedestrian.0008' ], - 'speed_limit': 30.0 + 'pedestrian_behaviors': ['walking', 'crossing', 'waiting', 'running'], + 'speed_limit': 40.0, + 'pedestrian_safety_zones': True, + 'crosswalk_density': 'medium', + 'vulnerable_user_protection': True }, 'sensors': { 'vehicle_cameras': 4, 'infrastructure_cameras': 4, 'lidar_sensors': 1, 'radar_sensors': 0, - 'gps_sensors': 0, - 'imu_sensors': 0, + 'gps_sensors': 1, + 'imu_sensors': 1, 'image_size': [1280, 720], 'capture_interval': 2.0, - 'sensor_placement': 'default', + 'sensor_placement': 'optimized', 'lidar_config': { 'channels': 32, - 'range': 100.0, - 'points_per_second': 56000, + 'range': 120.0, + 'points_per_second': 100000, 'rotation_frequency': 10.0, 'horizontal_fov': 360.0, 'vertical_fov': 30.0, - 'upper_fov': 10.0, - 'lower_fov': -20.0, - 'max_points_per_frame': 50000, + 'upper_fov': 15.0, + 'lower_fov': -25.0, + 'max_points_per_frame': 60000, 'downsample_ratio': 0.3, - 'memory_warning_threshold': 300, - 'max_batch_memory_mb': 50, + 'memory_warning_threshold': 400, + 'max_batch_memory_mb': 60, 'v2x_save_interval': 5, - 'compression_format': 'bin' + 'compression_format': 'bin', + 'pedestrian_detection': True, + 'height_filter': [-0.5, 2.5] }, 'camera_config': { 'fov': 90.0, - 'post_processing': 'default', + 'post_processing': 'semantic', 'exposure_mode': 'auto', - 'motion_blur': 0.0 + 'motion_blur': 0.0, + 'pedestrian_detection_mode': True, + 'dynamic_range': 'high' + }, + 'radar_config': { + 'range': 200.0, + 'points_per_second': 2000, + 'horizontal_fov': 60.0, + 'vertical_fov': 20.0 } }, 'v2x': { 'enabled': True, 'communication_range': 300.0, - 'bandwidth': 10.0, - 'latency_mean': 0.05, - 'latency_std': 0.01, - 'packet_loss_rate': 0.01, - 'message_types': ['bsm', 'spat', 'map', 'rsm', 'perception', 'warning', 'pedestrian_warning'], - 'update_interval': 2.0, - 'security_enabled': False, - 'encryption_level': 'none', - 'qos_policy': 'best_effort', + 'bandwidth': 20.0, + 'latency_mean': 0.02, + 'latency_std': 0.005, + 'packet_loss_rate': 0.005, + 'message_types': ['bsm', 'spat', 'map', 'rsm', 'perception', + 'warning', 'pedestrian_warning', 'emergency_brake'], + 'update_interval': 1.0, + 'security_enabled': True, + 'encryption_level': 'basic', + 'qos_policy': 'priority_based', 'enable_safety_warnings': True, - 'pedestrian_warning_threshold': 10.0 + 'pedestrian_warning_threshold': 10.0, + 'emergency_brake_warning': True, + 'collision_prediction': True, + 'vulnerable_road_user_protection': True }, 'cooperative': { 'num_coop_vehicles': 2, 'enable_shared_perception': True, 'enable_traffic_warnings': True, 'enable_pedestrian_warnings': True, - 'enable_maneuver_coordination': False, + 'enable_emergency_brake_assist': True, + 'enable_maneuver_coordination': True, 'data_fusion_interval': 1.0, - 'max_shared_objects': 50, - 'object_matching_threshold': 5.0, - 'data_retention_time': 10.0, - 'consensus_method': 'simple' + 'max_shared_objects': 100, + 'object_matching_threshold': 3.0, + 'data_retention_time': 15.0, + 'consensus_method': 'weighted', + 'pedestrian_tracking': True, + 'intention_prediction': True, + 'risk_assessment': True }, 'enhancement': { 'enabled': True, @@ -467,53 +757,62 @@ def _get_default_config() -> Dict[str, Any]: 'save_enhanced': True, 'calibration_generation': True, 'enhanced_dir_name': 'enhanced', - 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', 'safety_warning'], + 'methods': ['normalize', 'contrast', 'brightness', 'pedestrian_highlight', + 'safety_warning', 'risk_visualization'], 'weather_effects': True, 'augmentation_level': 'medium', - 'pedestrian_safety_mode': True + 'pedestrian_safety_mode': True, + 'vulnerable_user_protection': True, + 'emergency_scenario_simulation': True }, 'performance': { - 'batch_size': 5, + 'batch_size': 8, 'enable_compression': True, - 'compression_level': 3, + 'compression_level': 4, 'enable_downsampling': True, 'enable_memory_cache': True, - 'max_cache_size': 50, + 'max_cache_size': 80, 'enable_async_processing': True, - 'max_workers': 2, + 'max_workers': 4, 'image_processing': { 'compress_images': True, - 'compression_quality': 85, + 'compression_quality': 90, 'resize_images': False, 'resize_dimensions': [640, 480], - 'format': 'jpg' + 'format': 'jpg', + 'progressive_encoding': True }, 'lidar_processing': { - 'batch_size': 10, + 'batch_size': 15, 'enable_compression': True, 'enable_downsampling': True, - 'max_points_per_frame': 50000, - 'memory_warning_threshold': 350, - 'max_batch_memory_mb': 50, + 'max_points_per_frame': 60000, + 'memory_warning_threshold': 450, + 'max_batch_memory_mb': 70, 'v2x_save_interval': 5, - 'compression_method': 'zlib' + 'compression_method': 'zlib', + 'parallel_processing': True }, 'fusion': { - 'fusion_cache_size': 100, + 'fusion_cache_size': 150, 'enable_cache': True, - 'compression_enabled': True + 'compression_enabled': True, + 'real_time_fusion': True }, - 'sensor_cleanup_timeout': 0.5, - 'frame_rate_limit': 5.0, - 'safety_monitoring_interval': 1.0, + 'sensor_cleanup_timeout': 0.3, + 'frame_rate_limit': 8.0, + 'safety_monitoring_interval': 0.5, + 'emergency_response_time': 0.1, 'memory_management': { - 'gc_interval': 50, + 'gc_interval': 40, 'max_memory_mb': 500, - 'early_stop_threshold': 400 + 'early_stop_threshold': 450, + 'memory_monitoring': True, + 'leak_detection': True } }, 'output': { - 'data_dir': 'cvips_dataset', + 'data_dir': 'cvips_dataset_enhanced', 'output_format': 'standard', 'save_raw': True, 'save_stitched': True, @@ -524,26 +823,34 @@ def _get_default_config() -> Dict[str, Any]: 'save_v2x_messages': True, 'save_enhanced': True, 'save_safety_reports': True, + 'save_risk_maps': True, + 'save_emergency_events': True, 'validate_data': True, 'run_analysis': True, 'run_quality_check': True, 'generate_summary': True, 'generate_safety_summary': True, + 'generate_risk_assessment': True, 'compression_enabled': True, - 'file_naming': 'sequential', - 'backup_original': False + 'file_naming': 'timestamp', + 'backup_original': True, + 'metadata_inclusion': 'full' }, 'monitoring': { 'enable_logging': True, 'log_level': 'INFO', - 'log_file': 'cvips.log', + 'log_file': 'cvips_enhanced.log', + 'log_rotation': True, + 'max_log_size': 100, 'enable_performance_monitor': True, - 'performance_log_interval': 10.0, + 'performance_log_interval': 5.0, 'enable_progress_bar': True, 'enable_real_time_stats': True, - 'stats_update_interval': 5.0, + 'stats_update_interval': 2.0, 'enable_safety_monitor': True, - 'safety_log_interval': 2.0 + 'safety_log_interval': 1.0, + 'enable_memory_monitor': True, + 'memory_log_interval': 10.0 }, 'debug': { 'enable_debug_mode': False, @@ -551,21 +858,29 @@ def _get_default_config() -> Dict[str, Any]: 'debug_dir': 'debug', 'print_config': False, 'validate_sensors': True, - 'test_mode': False + 'test_mode': False, + 'profiling': False, + 'traceback_limit': 5 }, 'metadata': { - 'version': '1.0.0', - 'author': 'CVIPS System', + 'version': '2.0.0', + 'author': 'CVIPS System - Enhanced', 'description': '行人安全增强数据采集配置', - 'created': '', - 'modified': '' + 'created': datetime.now().isoformat(), + 'modified': '', + 'pedestrian_safety_features': True, + 'compatibility': { + 'carla_version': '>=0.9.13', + 'python_version': '>=3.7' + } } } @staticmethod def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: + """应用预设配置""" if preset_name not in ConfigManager.PRESET_CONFIGS: - print(f"警告: 未知的预设配置: {preset_name}") + print(f"⚠ 未知的预设配置: {preset_name}") return config preset = ConfigManager.PRESET_CONFIGS[preset_name] @@ -580,6 +895,11 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: config = ConfigOptimizer.optimize_for_speed(config) elif optimization == 'safety': config = ConfigOptimizer.optimize_for_safety(config) + elif optimization == 'research': + config = ConfigOptimizer.optimize_for_research(config) + elif optimization == 'balanced': + # 平衡配置:中等质量,中等性能 + pass # 使用默认配置 elif optimization == 'custom' and 'settings' in preset: config = ConfigManager._deep_update(config, preset['settings']) @@ -587,6 +907,7 @@ def _apply_preset(config: Dict[str, Any], preset_name: str) -> Dict[str, Any]: @staticmethod def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str, Any]: + """加载配置文件""" try: with open(config_file, 'r', encoding='utf-8') as f: if (config_file.endswith('.yaml') or config_file.endswith('.yml')) and YAML_AVAILABLE: @@ -594,15 +915,22 @@ def _load_config_file(config_file: str, base_config: Dict[str, Any]) -> Dict[str else: user_config = json.load(f) - print(f"加载配置文件: {config_file}") + print(f"✓ 加载配置文件: {config_file}") return ConfigManager._deep_update(base_config, user_config) + except json.JSONDecodeError as e: + print(f"✗ JSON解析错误: {e}") + return base_config + except yaml.YAMLError as e: + print(f"✗ YAML解析错误: {e}") + return base_config except Exception as e: - print(f"配置文件加载错误: {e}") + print(f"✗ 配置文件加载错误: {e}") return base_config @staticmethod def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, Any]: + """深度更新配置字典""" for key, value in update.items(): if key in original and isinstance(original[key], dict) and isinstance(value, dict): ConfigManager._deep_update(original[key], value) @@ -612,39 +940,58 @@ def _deep_update(original: Dict[str, Any], update: Dict[str, Any]) -> Dict[str, @staticmethod def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]: - if hasattr(args, 'scenario') and args.scenario: - config['scenario']['name'] = args.scenario - if hasattr(args, 'town') and args.town: - config['scenario']['town'] = args.town - if hasattr(args, 'weather') and args.weather: - config['scenario']['weather'] = args.weather - if hasattr(args, 'time_of_day') and args.time_of_day: - config['scenario']['time_of_day'] = args.time_of_day - if hasattr(args, 'duration') and args.duration: - config['scenario']['duration'] = args.duration - if hasattr(args, 'seed') and args.seed: - config['scenario']['seed'] = args.seed - - if hasattr(args, 'num_vehicles') and args.num_vehicles: - config['traffic']['background_vehicles'] = args.num_vehicles - if hasattr(args, 'num_pedestrians') and args.num_pedestrians: - config['traffic']['pedestrians'] = args.num_pedestrians - - if hasattr(args, 'num_coop_vehicles') and args.num_coop_vehicles: - config['cooperative']['num_coop_vehicles'] = args.num_coop_vehicles - - if hasattr(args, 'capture_interval') and args.capture_interval: - config['sensors']['capture_interval'] = args.capture_interval - - if hasattr(args, 'enable_v2x'): - config['v2x']['enabled'] = args.enable_v2x - - if hasattr(args, 'enable_enhancement'): - config['enhancement']['enabled'] = args.enable_enhancement - - if hasattr(args, 'enable_lidar'): - config['sensors']['lidar_sensors'] = 1 if args.enable_lidar else 0 - config['output']['save_lidar'] = args.enable_lidar + """合并命令行参数""" + arg_mappings = { + 'scenario': ('scenario', 'name'), + 'town': ('scenario', 'town'), + 'weather': ('scenario', 'weather'), + 'time_of_day': ('scenario', 'time_of_day'), + 'duration': ('scenario', 'duration'), + 'seed': ('scenario', 'seed'), + 'num_vehicles': ('traffic', 'background_vehicles'), + 'num_pedestrians': ('traffic', 'pedestrians'), + 'num_coop_vehicles': ('cooperative', 'num_coop_vehicles'), + 'capture_interval': ('sensors', 'capture_interval'), + 'batch_size': ('performance', 'batch_size'), + 'output_format': ('output', 'output_format'), + } + + bool_mappings = { + 'enable_v2x': ('v2x', 'enabled'), + 'enable_enhancement': ('enhancement', 'enabled'), + 'enable_lidar': ('sensors', 'lidar_sensors'), + 'enable_fusion': ('output', 'save_fusion'), + 'enable_cooperative': ('output', 'save_cooperative'), + 'enable_annotations': ('output', 'save_annotations'), + 'enable_safety_monitor': ('monitoring', 'enable_safety_monitor'), + 'enable_compression': ('performance', 'enable_compression'), + 'enable_downsampling': ('performance', 'enable_downsampling'), + 'skip_validation': ('output', 'validate_data'), + 'skip_quality_check': ('output', 'run_quality_check'), + 'run_analysis': ('output', 'run_analysis'), + } + + # 处理普通参数 + for arg_name, (section, key) in arg_mappings.items(): + if hasattr(args, arg_name) and getattr(args, arg_name) is not None: + if section in config and key in config[section]: + config[section][key] = getattr(args, arg_name) + + # 处理布尔参数 + for arg_name, (section, key) in bool_mappings.items(): + if hasattr(args, arg_name): + if arg_name.startswith('skip_'): + config[section][key] = not getattr(args, arg_name) + elif arg_name.startswith('enable_'): + value = getattr(args, arg_name) + if section == 'sensors' and key == 'lidar_sensors': + config[section][key] = 1 if value else 0 + else: + config[section][key] = value + + # 特殊处理 + if hasattr(args, 'enable_lidar') and args.enable_lidar: + config['output']['save_lidar'] = True if hasattr(args, 'enable_fusion'): config['output']['save_fusion'] = args.enable_fusion @@ -652,32 +999,6 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An if hasattr(args, 'enable_cooperative'): config['output']['save_cooperative'] = args.enable_cooperative - if hasattr(args, 'enable_annotations'): - config['output']['save_annotations'] = args.enable_annotations - - if hasattr(args, 'skip_validation'): - config['output']['validate_data'] = not args.skip_validation - - if hasattr(args, 'skip_quality_check'): - config['output']['run_quality_check'] = not args.skip_quality_check - - if hasattr(args, 'run_analysis'): - config['output']['run_analysis'] = args.run_analysis - - if hasattr(args, 'batch_size') and args.batch_size: - config['performance']['batch_size'] = args.batch_size - - if hasattr(args, 'enable_compression'): - config['performance']['enable_compression'] = args.enable_compression - - if hasattr(args, 'enable_downsampling'): - config['performance']['enable_downsampling'] = args.enable_downsampling - if args.enable_downsampling: - config['sensors']['lidar_config']['downsample_ratio'] = 0.3 - - if hasattr(args, 'output_format') and args.output_format: - config['output']['output_format'] = args.output_format - if hasattr(args, 'enable_safety_monitor'): config['monitoring']['enable_safety_monitor'] = args.enable_safety_monitor @@ -685,32 +1006,41 @@ def merge_args(config: Dict[str, Any], args: argparse.Namespace) -> Dict[str, An @staticmethod def save_config(config: Dict[str, Any], output_path: str, format: str = 'json'): + """保存配置到文件""" try: os.makedirs(os.path.dirname(output_path), exist_ok=True) + # 更新修改时间 + if 'metadata' in config: + config['metadata']['modified'] = datetime.now().isoformat() + if format.lower() == 'yaml' and YAML_AVAILABLE: with open(output_path, 'w', encoding='utf-8') as f: - yaml.dump(config, f, default_flow_style=False, allow_unicode=True) + yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False) + print(f"✓ 配置保存为YAML: {output_path}") else: with open(output_path, 'w', encoding='utf-8') as f: - json.dump(config, f, indent=2, ensure_ascii=False) + json.dump(config, f, indent=2, ensure_ascii=False, sort_keys=False) + print(f"✓ 配置保存为JSON: {output_path}") - print(f"配置保存到: {output_path}") return True except Exception as e: - print(f"保存配置失败: {e}") + print(f"✗ 保存配置失败: {e}") return False @staticmethod def generate_config_template(output_path: str, preset: Optional[str] = None): - config = ConfigManager.load_config(preset=preset) + """生成配置模板""" + config = ConfigManager.load_config(preset=preset, validate=False) config['metadata']['created'] = 'template' config['metadata']['description'] = f'配置模板 - {preset if preset else "通用"}' + config['metadata']['modified'] = '' return ConfigManager.save_config(config, output_path) @staticmethod def print_config_summary(config: Dict[str, Any]): + """打印配置摘要""" print("\n" + "=" * 60) print("配置摘要") print("=" * 60) @@ -721,6 +1051,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 地图: {scenario['town']}") print(f" 天气/时间: {scenario['weather']}/{scenario['time_of_day']}") print(f" 时长: {scenario['duration']}秒") + print(f" 行人安全模式: {'启用' if scenario.get('pedestrian_safety_mode', False) else '禁用'}") print(f" 随机种子: {scenario.get('seed', '随机')}") traffic = config['traffic'] @@ -728,8 +1059,10 @@ def print_config_summary(config: Dict[str, Any]): print(f" 主车: {traffic['ego_vehicles']}") print(f" 背景车辆: {traffic['background_vehicles']}") print(f" 行人: {traffic['pedestrians']}") + print(f" 自行车: {traffic.get('bicycles', 0)}") + print(f" 摩托车: {traffic.get('motorcycles', 0)}") print(f" 车速限制: {traffic.get('speed_limit', '无')} km/h") - print(f" 交通灯: {'启用' if traffic['traffic_lights'] else '禁用'}") + print(f" 行人安全区域: {'启用' if traffic.get('pedestrian_safety_zones', False) else '禁用'}") sensors = config['sensors'] print(f"\n📷 传感器:") @@ -738,6 +1071,8 @@ def print_config_summary(config: Dict[str, Any]): print(f" LiDAR: {sensors['lidar_sensors']} (通道: {sensors['lidar_config']['channels']})") print(f" 采集间隔: {sensors['capture_interval']}秒") print(f" 图像尺寸: {sensors['image_size'][0]}x{sensors['image_size'][1]}") + print( + f" 行人检测模式: {'启用' if sensors['camera_config'].get('pedestrian_detection_mode', False) else '禁用'}") v2x = config['v2x'] print(f"\n📡 V2X通信:") @@ -746,12 +1081,14 @@ def print_config_summary(config: Dict[str, Any]): print(f" 通信范围: {v2x['communication_range']}米") print(f" 更新间隔: {v2x['update_interval']}秒") print(f" 安全警告: {'启用' if v2x.get('enable_safety_warnings', False) else '禁用'}") + print(f" 紧急制动: {'启用' if v2x.get('emergency_brake_warning', False) else '禁用'}") coop = config['cooperative'] print(f"\n🤝 协同感知:") print(f" 协同车辆: {coop['num_coop_vehicles']}") print(f" 共享感知: {'启用' if coop['enable_shared_perception'] else '禁用'}") print(f" 行人警告: {'启用' if coop.get('enable_pedestrian_warnings', False) else '禁用'}") + print(f" 紧急制动辅助: {'启用' if coop.get('enable_emergency_brake_assist', False) else '禁用'}") perf = config['performance'] print(f"\n⚡ 性能:") @@ -760,6 +1097,7 @@ def print_config_summary(config: Dict[str, Any]): print(f" 下采样: {'启用' if perf['enable_downsampling'] else '禁用'}") print(f" 帧率限制: {perf['frame_rate_limit']} FPS") print(f" 安全监控间隔: {perf.get('safety_monitoring_interval', 1.0)}秒") + print(f" 紧急响应时间: {perf.get('emergency_response_time', 0.1)}秒") output = config['output'] print(f"\n💾 输出:") @@ -767,26 +1105,58 @@ def print_config_summary(config: Dict[str, Any]): print(f" 输出格式: {output['output_format']}") enabled_outputs = [k.replace('save_', '') for k, v in output.items() if isinstance(v, bool) and v and k.startswith('save_')] - print(f" 启用输出: {', '.join(enabled_outputs)}") + print(f" 启用输出: {', '.join(enabled_outputs[:8])}") + if len(enabled_outputs) > 8: + print(f" {', '.join(enabled_outputs[8:])}") - print(f"\n🛡️ 行人安全:") + print(f"\n🛡️ 行人安全增强:") print(f" 安全监控: {'启用' if config['monitoring'].get('enable_safety_monitor', False) else '禁用'}") print(f" 增强安全模式: {'启用' if config['enhancement'].get('pedestrian_safety_mode', False) else '禁用'}") + print(f" 脆弱用户保护: {'启用' if config['enhancement'].get('vulnerable_user_protection', False) else '禁用'}") + + print("\n📊 统计:") + total_objects = (traffic['ego_vehicles'] + traffic['background_vehicles'] + + traffic['pedestrians'] + traffic.get('bicycles', 0) + + traffic.get('motorcycles', 0)) + print(f" 场景总对象数: {total_objects}") + print(f" 预计数据量: {ConfigManager._estimate_data_size(config)}") print("=" * 60) + @staticmethod + def _estimate_data_size(config: Dict[str, Any]) -> str: + """估计数据大小""" + duration = config['scenario']['duration'] + interval = config['sensors']['capture_interval'] + frames = int(duration / interval) + + # 计算每帧数据大小 + image_size = config['sensors']['image_size'] + image_pixels = image_size[0] * image_size[1] + + # 粗略估计 + total_size_mb = frames * image_pixels * 3 / (1024 * 1024) * 0.1 # 假设压缩率 + + if total_size_mb < 1024: + return f"{total_size_mb:.1f} MB" + else: + return f"{total_size_mb / 1024:.1f} GB" + @staticmethod def list_presets(): + """列出可用预设""" print("\n可用预设配置:") - print("-" * 40) + print("-" * 50) for name, preset in ConfigManager.PRESET_CONFIGS.items(): - print(f" {name:15s} - {preset['description']}") - print("-" * 40) + print(f" {name:20s} - {preset['description']}") + print("-" * 50) -def load_config(config_file=None): - return ConfigManager.load_config(config_file) +def load_config(config_file=None, preset=None): + """加载配置(兼容函数)""" + return ConfigManager.load_config(config_file, preset) def merge_args(config, args): + """合并参数(兼容函数)""" return ConfigManager.merge_args(config, args) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/data_validator.py b/src/enhance_pedestrian_safety/data_validator.py index b472b40eb8..1292bc1852 100644 --- a/src/enhance_pedestrian_safety/data_validator.py +++ b/src/enhance_pedestrian_safety/data_validator.py @@ -1,14 +1,22 @@ import json import os +import numpy as np +from datetime import datetime class DataValidator: + """数据验证器(增强版)""" @staticmethod - def validate_dataset(data_dir): + def validate_dataset(data_dir, detailed=False): + """验证数据集(增强版)""" + print(f"\n{'=' * 60}") print(f"验证数据集: {data_dir}") + print(f"{'=' * 60}") validation_results = { + 'validation_time': datetime.now().isoformat(), + 'dataset_path': data_dir, 'directory_structure': DataValidator._check_directory_structure(data_dir), 'raw_images': DataValidator._validate_raw_images(data_dir), 'stitched_images': DataValidator._validate_stitched_images(data_dir), @@ -17,10 +25,21 @@ def validate_dataset(data_dir): 'lidar_data': DataValidator._validate_lidar_data(data_dir), 'cooperative_data': DataValidator._validate_cooperative_data(data_dir), 'fusion_data': DataValidator._validate_fusion_data(data_dir), - 'safety_data': DataValidator._validate_safety_data(data_dir) + 'safety_data': DataValidator._validate_safety_data(data_dir), + 'enhanced_data': DataValidator._validate_enhanced_data(data_dir), + 'calibration_data': DataValidator._validate_calibration_data(data_dir), + 'timestamps': DataValidator._validate_timestamps(data_dir) } + # 计算安全指标 + validation_results['safety_metrics'] = DataValidator._calculate_safety_metrics(data_dir) + validation_results['overall_score'] = DataValidator._calculate_score(validation_results) + validation_results['health_status'] = DataValidator._get_health_status(validation_results['overall_score']) + + # 详细验证 + if detailed: + validation_results['detailed_analysis'] = DataValidator._detailed_analysis(data_dir) DataValidator._save_validation_report(data_dir, validation_results) DataValidator._print_validation_report(validation_results) @@ -29,22 +48,27 @@ def validate_dataset(data_dir): @staticmethod def _check_directory_structure(data_dir): + """检查目录结构(增强版)""" required_dirs = [ - "raw/vehicle", + "raw/vehicle_1", "raw/infrastructure", "stitched", "metadata", - "cooperative", "cooperative/v2x_messages", "cooperative/shared_perception", - "fusion" + "fusion", + "annotations" ] optional_dirs = [ "lidar", "calibration", - "annotations", - "safety_reports" + "safety_reports", + "enhanced", + "v2xformer_format", + "kitti_format", + "risk_maps", + "emergency_events" ] missing_dirs = [] @@ -59,12 +83,28 @@ def _check_directory_structure(data_dir): if not os.path.exists(full_path): missing_optional.append(dir_path) + # 检查文件数量 + dir_stats = {} + total_files = 0 + for root, dirs, files in os.walk(data_dir): + if root.startswith(os.path.join(data_dir, '.')): + continue # 跳过隐藏目录 + + rel_path = os.path.relpath(root, data_dir) + if rel_path == '.': + rel_path = 'root' + + dir_stats[rel_path] = len(files) + total_files += len(files) + status = 'PASS' if len(missing_dirs) == 0 else 'FAIL' result = { 'status': status, 'missing_directories': missing_dirs, 'missing_optional_directories': missing_optional, + 'directory_stats': dir_stats, + 'total_files': total_files, 'required_directories': required_dirs, 'optional_directories': optional_dirs } @@ -73,11 +113,12 @@ def _check_directory_structure(data_dir): @staticmethod def _validate_raw_images(data_dir): + """验证原始图像(增强版)""" raw_path = os.path.join(data_dir, "raw") if not os.path.exists(raw_path): - return {'vehicle': {'status': 'MISSING', 'count': 0, 'errors': []}, - 'infrastructure': {'status': 'MISSING', 'count': 0, 'errors': []}} + return {'vehicle': {'status': 'MISSING', 'count': 0, 'errors': [], 'sizes': []}, + 'infrastructure': {'status': 'MISSING', 'count': 0, 'errors': [], 'sizes': []}} raw_dirs = [d for d in os.listdir(raw_path) if os.path.isdir(os.path.join(raw_path, d))] results = {} @@ -91,6 +132,7 @@ def _validate_raw_images(data_dir): total_images = 0 errors = [] + image_sizes = [] for camera_dir in camera_dirs: camera_path = os.path.join(path, camera_dir) @@ -99,8 +141,11 @@ def _validate_raw_images(data_dir): for img_file in images: img_path = os.path.join(camera_path, img_file) try: - if os.path.getsize(img_path) == 0: + file_size = os.path.getsize(img_path) + if file_size == 0: errors.append(f"空文件: {img_file}") + else: + image_sizes.append(file_size) except: errors.append(f"文件访问失败: {img_file}") @@ -108,34 +153,51 @@ def _validate_raw_images(data_dir): if len(errors) == 0 and total_images > 0: status = 'PASS' - elif len(errors) < 3 and total_images > 0: + elif len(errors) < 5 and total_images > 0: status = 'WARNING' else: status = 'FAIL' + # 计算统计信息 + stats = {} + if image_sizes: + stats = { + 'min_size_kb': min(image_sizes) / 1024, + 'max_size_kb': max(image_sizes) / 1024, + 'avg_size_kb': np.mean(image_sizes) / 1024, + 'total_size_mb': sum(image_sizes) / (1024 * 1024) + } + results[raw_dir] = { 'status': status, 'count': total_images, - 'errors': errors + 'camera_count': len(camera_dirs), + 'errors': errors, + 'statistics': stats } return results @staticmethod def _validate_stitched_images(data_dir): + """验证拼接图像(增强版)""" stitched_dir = os.path.join(data_dir, "stitched") if not os.path.exists(stitched_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'statistics': {}} images = [f for f in os.listdir(stitched_dir) if f.endswith(('.jpg', '.jpeg', '.png'))] errors = [] + image_sizes = [] for img_file in images: img_path = os.path.join(stitched_dir, img_file) try: - if os.path.getsize(img_path) == 0: + file_size = os.path.getsize(img_path) + if file_size == 0: errors.append(f"空文件: {img_file}") + else: + image_sizes.append(file_size) except: errors.append(f"文件访问失败: {img_file}") @@ -146,22 +208,35 @@ def _validate_stitched_images(data_dir): else: status = 'FAIL' + # 计算统计信息 + stats = {} + if image_sizes: + stats = { + 'min_size_kb': min(image_sizes) / 1024, + 'max_size_kb': max(image_sizes) / 1024, + 'avg_size_kb': np.mean(image_sizes) / 1024, + 'total_size_mb': sum(image_sizes) / (1024 * 1024) + } + return { 'status': status, 'count': len(images), - 'errors': errors + 'errors': errors, + 'statistics': stats } @staticmethod def _validate_annotations(data_dir): + """验证标注文件(增强版)""" annotations_dir = os.path.join(data_dir, "annotations") if not os.path.exists(annotations_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'frame_range': []} json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] errors = [] valid_files = 0 + frame_ids = [] for json_file in json_files: json_path = os.path.join(annotations_dir, json_file) @@ -170,44 +245,80 @@ def _validate_annotations(data_dir): data = json.load(f) # 检查基本结构 - required_keys = ['frame_id', 'objects'] + required_keys = ['frame_id', 'objects', 'safety_info'] for key in required_keys: if key not in data: errors.append(f"缺失必要键: {key} in {json_file}") + # 检查安全信息 + if 'safety_info' in data: + safety_info = data['safety_info'] + if 'pedestrian_count' not in safety_info or 'vehicle_count' not in safety_info: + errors.append(f"缺失安全统计信息: {json_file}") + + # 记录帧ID + if 'frame_id' in data: + frame_ids.append(data['frame_id']) + valid_files += 1 except Exception as e: errors.append(f"无效的JSON文件: {json_file} - {str(e)}") if len(errors) == 0 and valid_files > 0: status = 'PASS' - elif len(errors) < 3 and valid_files > 0: + elif len(errors) < 5 and valid_files > 0: status = 'WARNING' else: status = 'FAIL' + # 计算帧范围 + frame_range = [] + if frame_ids: + frame_range = [min(frame_ids), max(frame_ids)] + return { 'status': status, 'count': valid_files, + 'total_files': len(json_files), + 'frame_range': frame_range, 'errors': errors } @staticmethod def _validate_metadata(data_dir): + """验证元数据(增强版)""" metadata_dir = os.path.join(data_dir, "metadata") if not os.path.exists(metadata_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'files': []} json_files = [f for f in os.listdir(metadata_dir) if f.endswith('.json')] errors = [] valid_files = 0 + file_details = [] + + required_files = ['collection_info.json', 'scene_description.json'] + missing_files = [] + + for req_file in required_files: + if req_file not in json_files: + missing_files.append(req_file) for json_file in json_files: json_path = os.path.join(metadata_dir, json_file) try: with open(json_path, 'r') as f: data = json.load(f) + + # 检查文件大小 + file_size = os.path.getsize(json_path) + + file_details.append({ + 'file': json_file, + 'size_kb': file_size / 1024, + 'keys': list(data.keys()) + }) + valid_files += 1 except Exception as e: errors.append(f"无效的JSON文件: {json_file} - {str(e)}") @@ -219,18 +330,24 @@ def _validate_metadata(data_dir): else: status = 'FAIL' + if missing_files: + errors.extend([f"缺失必要元数据文件: {f}" for f in missing_files]) + return { 'status': status, 'count': valid_files, + 'files': file_details, + 'missing_files': missing_files, 'errors': errors } @staticmethod def _validate_lidar_data(data_dir): + """验证LiDAR数据(增强版)""" lidar_dir = os.path.join(data_dir, "lidar") if not os.path.exists(lidar_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'statistics': {}} bin_files = [f for f in os.listdir(lidar_dir) if f.endswith('.bin')] npy_files = [f for f in os.listdir(lidar_dir) if f.endswith('.npy')] @@ -238,12 +355,15 @@ def _validate_lidar_data(data_dir): errors = [] valid_bin_files = 0 + file_sizes = [] for bin_file in bin_files: bin_path = os.path.join(lidar_dir, bin_file) try: - if os.path.getsize(bin_path) > 0: + file_size = os.path.getsize(bin_path) + if file_size > 0: valid_bin_files += 1 + file_sizes.append(file_size) else: errors.append(f"空文件: {bin_file}") except: @@ -253,23 +373,35 @@ def _validate_lidar_data(data_dir): if len(errors) == 0 and valid_bin_files > 0: status = 'PASS' - elif len(errors) < 3 and valid_bin_files > 0: + elif len(errors) < 5 and valid_bin_files > 0: status = 'WARNING' else: status = 'FAIL' + # 计算统计信息 + stats = {} + if file_sizes: + stats = { + 'min_size_mb': min(file_sizes) / (1024 * 1024), + 'max_size_mb': max(file_sizes) / (1024 * 1024), + 'avg_size_mb': np.mean(file_sizes) / (1024 * 1024), + 'total_size_gb': sum(file_sizes) / (1024 * 1024 * 1024) + } + return { 'status': status, 'count': total_files, 'bin_files': len(bin_files), 'npy_files': len(npy_files), 'json_files': len(json_files), - 'errors': errors + 'valid_bin_files': valid_bin_files, + 'errors': errors, + 'statistics': stats } @staticmethod def _validate_cooperative_data(data_dir): - """验证协同数据""" + """验证协同数据(增强版)""" coop_dir = os.path.join(data_dir, "cooperative") if not os.path.exists(coop_dir): @@ -280,9 +412,13 @@ def _validate_cooperative_data(data_dir): # 检查V2X消息目录 v2x_dir = os.path.join(coop_dir, "v2x_messages") v2x_files = [] + v2x_stats = {'total': 0, 'types': {}} + if os.path.exists(v2x_dir): v2x_files = [f for f in os.listdir(v2x_dir) if f.endswith('.json')] - for v2x_file in v2x_files[:min(5, len(v2x_files))]: # 检查前5个文件 + v2x_stats['total'] = len(v2x_files) + + for v2x_file in v2x_files[:min(10, len(v2x_files))]: try: with open(os.path.join(v2x_dir, v2x_file), 'r') as f: data = json.load(f) @@ -292,6 +428,12 @@ def _validate_cooperative_data(data_dir): for key in required_keys: if key not in data: errors.append(f"V2X消息缺失字段 {key}: {v2x_file}") + + # 统计消息类型 + if 'message' in data and 'message_type' in data['message']: + msg_type = data['message']['message_type'] + v2x_stats['types'][msg_type] = v2x_stats['types'].get(msg_type, 0) + 1 + except Exception as e: errors.append(f"V2X消息文件无效: {v2x_file} - {str(e)}") else: @@ -300,9 +442,14 @@ def _validate_cooperative_data(data_dir): # 检查共享感知目录 perception_dir = os.path.join(coop_dir, "shared_perception") perception_files = [] + perception_stats = {'total': 0, 'avg_objects': 0} + if os.path.exists(perception_dir): perception_files = [f for f in os.listdir(perception_dir) if f.endswith('.json')] - for perception_file in perception_files[:min(5, len(perception_files))]: + perception_stats['total'] = len(perception_files) + + object_counts = [] + for perception_file in perception_files[:min(10, len(perception_files))]: try: with open(os.path.join(perception_dir, perception_file), 'r') as f: data = json.load(f) @@ -312,13 +459,22 @@ def _validate_cooperative_data(data_dir): for key in required_keys: if key not in data: errors.append(f"共享感知文件缺失字段 {key}: {perception_file}") + + # 统计对象数量 + if 'shared_objects' in data: + object_counts.append(len(data['shared_objects'])) + except Exception as e: errors.append(f"共享感知文件无效: {perception_file} - {str(e)}") + + if object_counts: + perception_stats['avg_objects'] = np.mean(object_counts) else: errors.append("共享感知目录不存在") # 检查协同摘要 summary_file = os.path.join(coop_dir, "cooperative_summary.json") + summary_valid = False if not os.path.exists(summary_file): errors.append("协同摘要文件不存在") else: @@ -331,14 +487,16 @@ def _validate_cooperative_data(data_dir): for key in required_keys: if key not in data: errors.append(f"协同摘要缺失字段: {key}") + + summary_valid = True except Exception as e: errors.append(f"协同摘要文件无效: {str(e)}") total_files = len(v2x_files) + len(perception_files) - if len(errors) == 0 and total_files > 0: + if len(errors) == 0 and total_files > 0 and summary_valid: status = 'PASS' - elif len(errors) < 3 and total_files > 0: + elif len(errors) < 5 and total_files > 0: status = 'WARNING' else: status = 'FAIL' @@ -346,28 +504,39 @@ def _validate_cooperative_data(data_dir): return { 'status': status, 'count': total_files, - 'v2x_messages': len(v2x_files), - 'shared_perception': len(perception_files), + 'v2x_messages': v2x_stats, + 'shared_perception': perception_stats, + 'summary_valid': summary_valid, 'errors': errors } @staticmethod def _validate_fusion_data(data_dir): - """验证融合数据""" + """验证融合数据(增强版)""" fusion_dir = os.path.join(data_dir, "fusion") if not os.path.exists(fusion_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'statistics': {}} json_files = [f for f in os.listdir(fusion_dir) if f.endswith('.json')] + gz_files = [f for f in os.listdir(fusion_dir) if f.endswith('.gz')] + all_files = json_files + gz_files + errors = [] valid_files = 0 + sensor_types = set() - for json_file in json_files[:min(5, len(json_files))]: # 检查前5个文件 + for json_file in all_files[:min(10, len(all_files))]: json_path = os.path.join(fusion_dir, json_file) try: - with open(json_path, 'r') as f: - data = json.load(f) + # 处理压缩文件 + if json_file.endswith('.gz'): + import gzip + with gzip.open(json_path, 'rt', encoding='utf-8') as f: + data = json.load(f) + else: + with open(json_path, 'r') as f: + data = json.load(f) # 检查必要字段 required_keys = ['frame_id', 'timestamp', 'sensors'] @@ -375,36 +544,45 @@ def _validate_fusion_data(data_dir): if key not in data: errors.append(f"融合文件缺失字段 {key}: {json_file}") + # 收集传感器类型 + if 'sensors' in data: + sensor_types.update(data['sensors'].keys()) + valid_files += 1 except Exception as e: errors.append(f"融合文件无效: {json_file} - {str(e)}") if len(errors) == 0 and valid_files > 0: status = 'PASS' - elif len(errors) < 3 and valid_files > 0: + elif len(errors) < 5 and valid_files > 0: status = 'WARNING' else: status = 'FAIL' return { 'status': status, - 'count': len(json_files), + 'count': len(all_files), + 'json_files': len(json_files), + 'gz_files': len(gz_files), + 'valid_files': valid_files, + 'sensor_types': list(sensor_types), 'errors': errors } @staticmethod def _validate_safety_data(data_dir): - """验证安全数据""" + """验证安全数据(增强版)""" safety_dir = os.path.join(data_dir, "safety_reports") if not os.path.exists(safety_dir): - return {'status': 'MISSING', 'count': 0, 'errors': []} + return {'status': 'MISSING', 'count': 0, 'errors': [], 'risk_stats': {}} json_files = [f for f in os.listdir(safety_dir) if f.endswith('.json')] errors = [] valid_files = 0 + risk_stats = {'high': 0, 'medium': 0, 'low': 0, 'critical': 0} - for json_file in json_files[:min(5, len(json_files))]: + for json_file in json_files[:min(10, len(json_files))]: json_path = os.path.join(safety_dir, json_file) try: with open(json_path, 'r') as f: @@ -416,13 +594,19 @@ def _validate_safety_data(data_dir): if key not in data: errors.append(f"安全报告缺失字段 {key}: {json_file}") + # 统计风险级别 + if 'risk_level' in data: + risk_level = data['risk_level'] + if risk_level in risk_stats: + risk_stats[risk_level] += 1 + valid_files += 1 except Exception as e: errors.append(f"安全报告无效: {json_file} - {str(e)}") if len(errors) == 0 and valid_files > 0: status = 'PASS' - elif len(errors) < 3 and valid_files > 0: + elif len(errors) < 5 and valid_files > 0: status = 'WARNING' else: status = 'FAIL' @@ -430,21 +614,195 @@ def _validate_safety_data(data_dir): return { 'status': status, 'count': len(json_files), + 'valid_files': valid_files, + 'risk_stats': risk_stats, + 'errors': errors + } + + @staticmethod + def _validate_enhanced_data(data_dir): + """验证增强数据""" + enhanced_dir = os.path.join(data_dir, "enhanced") + + if not os.path.exists(enhanced_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + # 查找所有增强图像 + enhanced_files = [] + for root, dirs, files in os.walk(enhanced_dir): + for file in files: + if file.endswith(('.png', '.jpg', '.jpeg')): + enhanced_files.append(os.path.join(root, file)) + + errors = [] + + # 检查样本文件 + sample_files = enhanced_files[:min(5, len(enhanced_files))] + for file_path in sample_files: + try: + if os.path.getsize(file_path) == 0: + errors.append(f"空增强文件: {os.path.basename(file_path)}") + except: + errors.append(f"文件访问失败: {os.path.basename(file_path)}") + + if len(errors) == 0 and len(enhanced_files) > 0: + status = 'PASS' + elif len(errors) < 3 and len(enhanced_files) > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': len(enhanced_files), + 'errors': errors + } + + @staticmethod + def _validate_calibration_data(data_dir): + """验证标定数据""" + calib_dir = os.path.join(data_dir, "calibration") + + if not os.path.exists(calib_dir): + return {'status': 'MISSING', 'count': 0, 'errors': []} + + json_files = [f for f in os.listdir(calib_dir) if f.endswith('.json')] + errors = [] + valid_files = 0 + + for json_file in json_files: + json_path = os.path.join(calib_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + valid_files += 1 + except Exception as e: + errors.append(f"标定文件无效: {json_file} - {str(e)}") + + if len(errors) == 0 and valid_files > 0: + status = 'PASS' + elif len(errors) < 3 and valid_files > 0: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'count': valid_files, 'errors': errors } + @staticmethod + def _validate_timestamps(data_dir): + """验证时间戳连续性""" + annotations_dir = os.path.join(data_dir, "annotations") + + if not os.path.exists(annotations_dir): + return {'status': 'SKIPPED', 'errors': ['标注目录不存在']} + + json_files = [f for f in os.listdir(annotations_dir) if f.endswith('.json')] + if len(json_files) < 2: + return {'status': 'SKIPPED', 'errors': ['标注文件不足']} + + timestamps = [] + errors = [] + + # 按文件名排序 + json_files.sort() + + for json_file in json_files[:min(100, len(json_files))]: + json_path = os.path.join(annotations_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + + if 'timestamp' in data: + timestamps.append(data['timestamp']) + elif 'frame_id' in data: + timestamps.append(data['frame_id']) + except: + continue + + if len(timestamps) < 2: + return {'status': 'SKIPPED', 'errors': ['有效时间戳不足']} + + # 检查时间戳是否递增 + for i in range(1, len(timestamps)): + if isinstance(timestamps[i], (int, float)) and isinstance(timestamps[i - 1], (int, float)): + if timestamps[i] <= timestamps[i - 1]: + errors.append(f"时间戳不递增: {timestamps[i - 1]} -> {timestamps[i]}") + + if len(errors) == 0: + status = 'PASS' + elif len(errors) < 3: + status = 'WARNING' + else: + status = 'FAIL' + + return { + 'status': status, + 'timestamp_count': len(timestamps), + 'errors': errors + } + + @staticmethod + def _calculate_safety_metrics(data_dir): + """计算安全指标""" + safety_dir = os.path.join(data_dir, "safety_reports") + + if not os.path.exists(safety_dir): + return {'status': 'MISSING', 'metrics': {}} + + json_files = [f for f in os.listdir(safety_dir) if f.endswith('.json')] + + total_high_risk = 0 + total_interactions = 0 + safety_scores = [] + + for json_file in json_files[:min(20, len(json_files))]: + json_path = os.path.join(safety_dir, json_file) + try: + with open(json_path, 'r') as f: + data = json.load(f) + + if 'high_risk_cases' in data: + total_high_risk += data['high_risk_cases'] + if 'total_interactions' in data: + total_interactions += data['total_interactions'] + if 'safety_score' in data: + safety_scores.append(data['safety_score']) + except: + continue + + metrics = {} + if total_interactions > 0: + metrics['high_risk_ratio'] = total_high_risk / total_interactions + metrics['interaction_density'] = total_interactions / len(json_files) if json_files else 0 + + if safety_scores: + metrics['avg_safety_score'] = np.mean(safety_scores) + metrics['min_safety_score'] = min(safety_scores) + metrics['max_safety_score'] = max(safety_scores) + + return {'status': 'CALCULATED', 'metrics': metrics} + @staticmethod def _calculate_score(results): + """计算总体评分(增强版)""" weights = { 'directory_structure': 0.10, 'raw_images': 0.15, 'stitched_images': 0.05, - 'annotations': 0.08, + 'annotations': 0.10, 'metadata': 0.08, - 'lidar_data': 0.12, - 'cooperative_data': 0.12, - 'fusion_data': 0.10, - 'safety_data': 0.20 + 'lidar_data': 0.10, + 'cooperative_data': 0.10, + 'fusion_data': 0.08, + 'safety_data': 0.12, + 'enhanced_data': 0.04, + 'calibration_data': 0.03, + 'timestamps': 0.03, + 'safety_metrics': 0.02 } score = 0 @@ -462,64 +820,191 @@ def _calculate_score(results): score += 100 * weight elif result['status'] == 'WARNING': score += 70 * weight - elif result['status'] in ['FAIL', 'MISSING']: + elif result['status'] == 'FAIL': score += 30 * weight + elif result['status'] == 'MISSING': + score += 20 * weight + elif result['status'] == 'SKIPPED': + score += 50 * weight else: score += 50 * weight - return round(score, 1) + return round(min(100, max(0, score)), 1) + + @staticmethod + def _get_health_status(score): + """获取健康状态""" + if score >= 90: + return 'EXCELLENT' + elif score >= 75: + return 'GOOD' + elif score >= 60: + return 'FAIR' + elif score >= 40: + return 'POOR' + else: + return 'CRITICAL' + + @staticmethod + def _detailed_analysis(data_dir): + """详细分析""" + analysis = { + 'file_size_distribution': DataValidator._analyze_file_sizes(data_dir), + 'data_consistency': DataValidator._check_data_consistency(data_dir), + 'completeness': DataValidator._check_completeness(data_dir) + } + return analysis + + @staticmethod + def _analyze_file_sizes(data_dir): + """分析文件大小分布""" + size_ranges = { + 'tiny': 0, # < 1KB + 'small': 0, # 1KB - 100KB + 'medium': 0, # 100KB - 1MB + 'large': 0, # 1MB - 10MB + 'huge': 0 # > 10MB + } + + total_size = 0 + file_count = 0 + + for root, dirs, files in os.walk(data_dir): + for file in files: + file_path = os.path.join(root, file) + try: + size = os.path.getsize(file_path) + total_size += size + file_count += 1 + + if size < 1024: + size_ranges['tiny'] += 1 + elif size < 1024 * 100: + size_ranges['small'] += 1 + elif size < 1024 * 1024: + size_ranges['medium'] += 1 + elif size < 1024 * 1024 * 10: + size_ranges['large'] += 1 + else: + size_ranges['huge'] += 1 + except: + continue + + return { + 'total_files': file_count, + 'total_size_gb': total_size / (1024 ** 3), + 'avg_file_size_kb': (total_size / max(1, file_count)) / 1024, + 'size_distribution': size_ranges + } + + @staticmethod + def _check_data_consistency(data_dir): + """检查数据一致性""" + # 检查标注文件和图像文件数量是否匹配 + annotations_dir = os.path.join(data_dir, "annotations") + raw_dir = os.path.join(data_dir, "raw") + + annotation_count = 0 + image_count = 0 + + if os.path.exists(annotations_dir): + annotation_count = len([f for f in os.listdir(annotations_dir) if f.endswith('.json')]) + + if os.path.exists(raw_dir): + for root, dirs, files in os.walk(raw_dir): + for file in files: + if file.endswith(('.png', '.jpg', '.jpeg')): + image_count += 1 + + consistency = abs(annotation_count - image_count) <= max(annotation_count, image_count) * 0.1 + + return { + 'annotation_count': annotation_count, + 'image_count': image_count, + 'consistency': consistency, + 'difference': abs(annotation_count - image_count) + } + + @staticmethod + def _check_completeness(data_dir): + """检查数据完整性""" + completeness = {} + + # 检查必要目录 + required_dirs = ['raw', 'annotations', 'metadata'] + for dir_name in required_dirs: + dir_path = os.path.join(data_dir, dir_name) + completeness[dir_name] = os.path.exists(dir_path) and len(os.listdir(dir_path)) > 0 + + # 检查必要文件 + metadata_dir = os.path.join(data_dir, "metadata") + if os.path.exists(metadata_dir): + required_files = ['collection_info.json'] + for file_name in required_files: + file_path = os.path.join(metadata_dir, file_name) + completeness[file_name] = os.path.exists(file_path) + + return completeness @staticmethod def _save_validation_report(data_dir, results): + """保存验证报告""" report_path = os.path.join(data_dir, "metadata", "validation_report.json") + os.makedirs(os.path.dirname(report_path), exist_ok=True) + with open(report_path, 'w', encoding='utf-8') as f: json.dump(results, f, indent=2, ensure_ascii=False) + print(f"\n验证报告已保存: {report_path}") + @staticmethod def _print_validation_report(results): + """打印验证报告""" print("\n" + "=" * 60) print("数据集验证报告") print("=" * 60) + # 总体信息 + print(f"\n📊 总体信息:") + print(f" 数据集路径: {results['dataset_path']}") + print(f" 验证时间: {results['validation_time']}") + print(f" 总体评分: {results['overall_score']}/100") + print(f" 健康状态: {results['health_status']}") + + # 各模块验证结果 + print(f"\n🔍 详细验证结果:") + for key, result in results.items(): - if key == 'overall_score': + if key in ['overall_score', 'health_status', 'dataset_path', 'validation_time', + 'safety_metrics', 'detailed_analysis']: continue print(f"\n{key.replace('_', ' ').title()}:") if 'status' in result: - status_icon = '✓' if result['status'] == 'PASS' else '⚠' if result['status'] == 'WARNING' else '✗' + status_icon = '✓' if result['status'] == 'PASS' else '⚠' if result['status'] in ['WARNING', + 'SKIPPED'] else '✗' print(f" 状态: {status_icon} {result['status']}") - else: - print(f" 状态: 未知") if 'count' in result: - print(f" 数量: {result['count']}") + if isinstance(result['count'], dict): + print(f" 统计: {json.dumps(result['count'], indent=2)}") + else: + print(f" 数量: {result['count']}") # 特定类型数据的额外信息 if key == 'raw_images' and isinstance(result, dict): for subkey, subresult in result.items(): if isinstance(subresult, dict) and 'count' in subresult: print(f" {subkey}: {subresult['count']} 图像") - - if key == 'cooperative_data' and isinstance(result, dict): - if 'v2x_messages' in result: - print(f" V2X消息: {result['v2x_messages']}") - if 'shared_perception' in result: - print(f" 共享感知: {result['shared_perception']}") - - if key == 'lidar_data' and isinstance(result, dict): - if 'bin_files' in result: - print(f" BIN文件: {result['bin_files']}") - if 'npy_files' in result: - print(f" NPY文件: {result['npy_files']}") - if 'json_files' in result: - print(f" JSON文件: {result['json_files']}") + if 'statistics' in subresult and subresult['statistics']: + stats = subresult['statistics'] + print(f" 大小: {stats.get('avg_size_kb', 0):.1f} KB/张") if key == 'safety_data' and isinstance(result, dict): - if 'count' in result: - print(f" 安全报告: {result['count']} 个") + if 'risk_stats' in result: + print(f" 风险统计: {json.dumps(result['risk_stats'], indent=2)}") if 'errors' in result and result['errors']: print(f" 错误 ({len(result['errors'])}):") @@ -528,16 +1013,33 @@ def _print_validation_report(results): if len(result['errors']) > 3: print(f" ... 还有 {len(result['errors']) - 3} 个错误") - print(f"\n总体评分: {results.get('overall_score', 0)}/100") + # 安全指标 + if 'safety_metrics' in results and results['safety_metrics']['status'] != 'MISSING': + print(f"\n🛡️ 安全指标:") + metrics = results['safety_metrics']['metrics'] + for key, value in metrics.items(): + if isinstance(value, float): + print(f" {key}: {value:.3f}") + else: + print(f" {key}: {value}") + # 建议 + print(f"\n💡 建议:") overall_score = results.get('overall_score', 0) if overall_score >= 90: - print("✓ 数据集质量优秀") - elif overall_score >= 70: - print("✓ 数据集质量良好") - elif overall_score >= 50: - print("⚠ 数据集质量一般") + print(" ✓ 数据集质量优秀,可直接使用") + elif overall_score >= 75: + print(" ✓ 数据集质量良好,建议进行少量优化") + elif overall_score >= 60: + print(" ⚠ 数据集质量一般,建议进行优化") + if results.get('directory_structure', {}).get('missing_directories'): + print(" - 补全缺失的必要目录") + if results.get('raw_images', {}).get('vehicle', {}).get('count', 0) < 10: + print(" - 增加车辆图像数量") else: - print("✗ 数据集质量需要改进") + print(" ✗ 数据集质量需要重大改进") + print(" - 检查数据采集过程") + print(" - 验证传感器配置") + print(" - 重新收集关键数据") - print("=" * 60) \ No newline at end of file + print("\n" + "=" * 60) \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/lidar_processor.py b/src/enhance_pedestrian_safety/lidar_processor.py index 8c0f6ebb20..a6bf33c30d 100644 --- a/src/enhance_pedestrian_safety/lidar_processor.py +++ b/src/enhance_pedestrian_safety/lidar_processor.py @@ -8,9 +8,13 @@ import zlib import pickle import gzip +import time +from concurrent.futures import ThreadPoolExecutor +import hashlib class LidarProcessor: + """LiDAR处理器(增强版)""" def __init__(self, output_dir, config=None): self.output_dir = output_dir @@ -21,36 +25,67 @@ def __init__(self, output_dir, config=None): os.makedirs(self.calibration_dir, exist_ok=True) self.frame_counter = 0 - self.data_lock = threading.Lock() + self.data_lock = threading.RLock() + self.processing_lock = threading.Lock() - self.batch_size = config.get('batch_size', 10) if config else 10 + # 配置参数 + self.config = config or {} + self.batch_size = self.config.get('batch_size', 8) self.point_cloud_batch = [] - self.enable_compression = config.get('enable_compression', True) if config else True - self.compression_level = config.get('compression_level', 3) if config else 3 + self.enable_compression = self.config.get('enable_compression', True) + self.compression_level = self.config.get('compression_level', 4) + + self.max_points_per_frame = self.config.get('max_points_per_frame', 60000) + self.enable_downsampling = self.config.get('enable_downsampling', True) + self.downsample_ratio = self.config.get('downsample_ratio', 0.3) + + self.memory_warning_threshold = self.config.get('memory_warning_threshold', 400) + self.max_batch_memory_mb = self.config.get('max_batch_memory_mb', 60) + self.v2x_save_interval = self.config.get('v2x_save_interval', 5) + + # 性能监控 + self.processing_stats = { + 'total_frames': 0, + 'total_points': 0, + 'avg_points_per_frame': 0, + 'processing_times': [], + 'compression_ratios': [], + 'errors': 0 + } - self.max_points_per_frame = config.get('max_points_per_frame', 50000) if config else 50000 - self.enable_downsampling = config.get('enable_downsampling', True) if config else True - self.downsample_ratio = config.get('downsample_ratio', 0.3) if config else 0.3 + # 线程池 + self.thread_pool = ThreadPoolExecutor(max_workers=2) - self.memory_warning_threshold = config.get('memory_warning_threshold', 300) if config else 300 - self.max_batch_memory_mb = config.get('max_batch_memory_mb', 50) if config else 50 - self.v2x_save_interval = config.get('v2x_save_interval', 5) if config else 5 + # 行人检测相关 + self.pedestrian_detection = self.config.get('pedestrian_detection', True) + self.pedestrian_points = [] self._init_calibration_files() def _init_calibration_files(self): + """初始化标定文件(增强版)""" + # LiDAR内参 lidar_intrinsic = { + "sensor_type": "lidar", + "model": "velodyne_vls_128", "channels": 32, - "range": 100.0, - "points_per_second": 56000, + "range": 120.0, + "points_per_second": 100000, "rotation_frequency": 10.0, "horizontal_fov": 360.0, "vertical_fov": 30.0, - "upper_fov": 10.0, - "lower_fov": -20.0 + "upper_fov": 15.0, + "lower_fov": -25.0, + "angular_resolution": 0.1, + "timestamp": datetime.now().isoformat(), + "pedestrian_detection": self.pedestrian_detection, + "height_filter": [-0.5, 2.5] } + # LiDAR外参(车辆坐标系) lidar_extrinsic = { + "sensor_id": "lidar_main", + "vehicle_id": "ego_vehicle_1", "translation": [0.0, 0.0, 2.5], "rotation": [0.0, 0.0, 0.0], "matrix": [ @@ -58,47 +93,94 @@ def _init_calibration_files(self): [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0] - ] + ], + "timestamp": datetime.now().isoformat(), + "coordinate_system": "carla_vehicle" + } + + # 相机-LiDAR标定 + camera_lidar_calib = { + "camera_id": "front_wide", + "lidar_id": "lidar_main", + "projection_matrix": [ + [7.215377e+02, 0.000000e+00, 6.095593e+02, 0.000000e+00], + [0.000000e+00, 7.215377e+02, 1.728540e+02, 0.000000e+00], + [0.000000e+00, 0.000000e+00, 1.000000e+00, 0.000000e+00] + ], + "rectification_matrix": [ + [9.999239e-01, 9.837760e-03, -7.445048e-03], + [-9.869795e-03, 9.999421e-01, -4.278459e-03], + [7.402527e-03, 4.351614e-03, 9.999631e-01] + ], + "translation": [0.0, 0.0, 0.0], + "rotation": [0.0, 0.0, 0.0] } intrinsic_file = os.path.join(self.calibration_dir, "lidar_intrinsic.json") extrinsic_file = os.path.join(self.calibration_dir, "lidar_extrinsic.json") + camera_lidar_file = os.path.join(self.calibration_dir, "camera_lidar_calibration.json") - with open(intrinsic_file, 'w') as f: + with open(intrinsic_file, 'w', encoding='utf-8') as f: json.dump(lidar_intrinsic, f, indent=2) - with open(extrinsic_file, 'w') as f: + with open(extrinsic_file, 'w', encoding='utf-8') as f: json.dump(lidar_extrinsic, f, indent=2) + with open(camera_lidar_file, 'w', encoding='utf-8') as f: + json.dump(camera_lidar_calib, f, indent=2) + def process_lidar_data(self, lidar_data, frame_num): - with self.data_lock: + """处理LiDAR数据(增强版)""" + start_time = time.time() + + with self.processing_lock: try: self.frame_counter = frame_num + # 转换数据格式 points = self._carla_lidar_to_numpy(lidar_data) if points is None or points.shape[0] == 0: return None + # 检查内存使用 if self._check_memory_usage(): return None original_count = points.shape[0] + + # 预处理:过滤地面和过高点 + points = self._preprocess_point_cloud(points) + + # 行人检测 + if self.pedestrian_detection: + pedestrian_clusters = self._detect_pedestrians(points) + if pedestrian_clusters: + self._save_pedestrian_detections(frame_num, pedestrian_clusters) + + # 下采样 if self.enable_downsampling and points.shape[0] > self.max_points_per_frame: points = self._downsample_point_cloud(points) + # 检查批处理内存 batch_memory_mb = self._estimate_batch_memory_mb() if batch_memory_mb > self.max_batch_memory_mb: - self._save_batch() + self._save_batch_async() - self.point_cloud_batch.append((frame_num, points)) + # 添加到批处理 + with self.data_lock: + self.point_cloud_batch.append((frame_num, points)) + self.processing_stats['total_frames'] += 1 + self.processing_stats['total_points'] += points.shape[0] + # 异步保存 if len(self.point_cloud_batch) >= self.batch_size: - self._save_batch() + self._save_batch_async() - bin_path = self._save_as_bin(points, frame_num) - npy_path = self._save_as_npy(points, frame_num) + # 保存单个文件 + save_results = self._save_point_cloud_files(points, frame_num) + # 每N帧保存V2X格式 v2xformer_path = None if frame_num % self.v2x_save_interval == 0: try: @@ -106,53 +188,199 @@ def process_lidar_data(self, lidar_data, frame_num): except Exception as e: v2xformer_path = None - metadata = self._generate_metadata(points, bin_path, npy_path, v2xformer_path) + # 生成元数据 + metadata = self._generate_metadata(points, frame_num, save_results, v2xformer_path, original_count) + # 定期清理 if frame_num % 20 == 0: gc.collect() + # 更新统计 + processing_time = time.time() - start_time + self.processing_stats['processing_times'].append(processing_time) + + # 计算平均点数 + if self.processing_stats['total_frames'] > 0: + self.processing_stats['avg_points_per_frame'] = \ + self.processing_stats['total_points'] / self.processing_stats['total_frames'] + return metadata except Exception as e: - gc.collect() + self.processing_stats['errors'] += 1 return None def _carla_lidar_to_numpy(self, lidar_data): + """CARLA LiDAR数据转numpy(增强版)""" try: + # 方法1:从原始数据解析 points = np.frombuffer(lidar_data.raw_data, dtype=np.float32) points = np.reshape(points, (int(points.shape[0] / 4), 4)) - points = points[:, :3] + + # 分离坐标和强度 + coordinates = points[:, :3] + intensities = points[:, 3] + + # 过滤无效点 + valid_mask = ~np.any(np.isnan(coordinates), axis=1) & ~np.any(np.isinf(coordinates), axis=1) + coordinates = coordinates[valid_mask] + intensities = intensities[valid_mask] + + # 添加强度信息 + points_with_intensity = np.column_stack([coordinates, intensities]) del lidar_data gc.collect() - return points + return points_with_intensity except Exception as e: try: + # 方法2:从点列表解析 points = [] - for i in range(0, len(lidar_data), 4): - point = lidar_data[i:i + 4] + intensities = [] + + # 假设lidar_data是点列表 + for point in lidar_data: points.append([point.x, point.y, point.z]) - return np.array(points, dtype=np.float32) + intensities.append(point.intensity if hasattr(point, 'intensity') else 1.0) + + points_array = np.array(points, dtype=np.float32) + intensities_array = np.array(intensities, dtype=np.float32) + + return np.column_stack([points_array, intensities_array]) + except: return None + def _preprocess_point_cloud(self, points): + """预处理点云""" + if points.shape[1] < 3: + return points + + # 过滤地面点(z坐标接近0) + ground_mask = points[:, 2] > 0.2 # 保留地面以上20cm的点 + + # 过滤过高点(高于建筑物) + height_mask = points[:, 2] < 50.0 + + # 过滤无效点 + valid_mask = ground_mask & height_mask + + return points[valid_mask] + + def _detect_pedestrians(self, points): + """检测行人""" + if points.shape[0] < 100: + return [] + + # 高度过滤:行人通常在0.5m到2.5m之间 + height_mask = (points[:, 2] > 0.5) & (points[:, 2] < 2.5) + candidate_points = points[height_mask] + + if candidate_points.shape[0] < 10: + return [] + + # 简单聚类:基于空间距离 + from sklearn.cluster import DBSCAN + + # 使用DBSCAN聚类 + clustering = DBSCAN(eps=0.5, min_samples=5).fit(candidate_points[:, :3]) + labels = clustering.labels_ + + clusters = [] + unique_labels = set(labels) + + for label in unique_labels: + if label == -1: # 噪声点 + continue + + cluster_points = candidate_points[labels == label] + if cluster_points.shape[0] < 10: # 点数太少 + continue + + # 计算聚类中心 + center = np.mean(cluster_points[:, :3], axis=0) + bbox_min = np.min(cluster_points[:, :3], axis=0) + bbox_max = np.max(cluster_points[:, :3], axis=0) + + # 计算大小 + size = bbox_max - bbox_min + + # 判断是否为行人(基于大小和形状) + if (size[0] < 1.0 and size[1] < 1.0 and size[2] > 0.5 and size[2] < 2.0): + clusters.append({ + 'center': center.tolist(), + 'size': size.tolist(), + 'point_count': cluster_points.shape[0], + 'bbox': { + 'min': bbox_min.tolist(), + 'max': bbox_max.tolist() + } + }) + + return clusters + + def _save_pedestrian_detections(self, frame_num, clusters): + """保存行人检测结果""" + detection_data = { + 'frame_id': frame_num, + 'timestamp': datetime.now().isoformat(), + 'pedestrian_count': len(clusters), + 'clusters': clusters + } + + detection_file = os.path.join(self.lidar_dir, f"pedestrian_detections_{frame_num:06d}.json") + + try: + with open(detection_file, 'w', encoding='utf-8') as f: + json.dump(detection_data, f, indent=2) + except: + pass + def _downsample_point_cloud(self, points): + """下采样点云(增强版)""" if points.shape[0] <= self.max_points_per_frame: return points - indices = np.random.choice(points.shape[0], - int(points.shape[0] * self.downsample_ratio), - replace=False) - downsampled = points[indices] + # 使用体素网格下采样 + try: + from sklearn.neighbors import NearestNeighbors + + # 创建体素网格 + voxel_size = 0.1 # 10cm体素 - del points - gc.collect() + # 计算每个点所属的体素 + voxel_indices = np.floor(points[:, :3] / voxel_size).astype(int) + + # 找到唯一体素 + unique_voxels, indices = np.unique(voxel_indices, axis=0, return_index=True) - return downsampled + # 从每个体素中随机选择一个点 + if len(indices) > self.max_points_per_frame: + # 如果需要进一步下采样,随机选择 + selected_indices = np.random.choice( + indices, + size=self.max_points_per_frame, + replace=False + ) + downsampled = points[selected_indices] + else: + downsampled = points[indices] + + return downsampled + + except: + # 如果体素下采样失败,使用随机下采样 + indices = np.random.choice( + points.shape[0], + size=self.max_points_per_frame, + replace=False + ) + return points[indices] def _estimate_batch_memory_mb(self): + """估计批处理内存使用""" if not self.point_cloud_batch: return 0 @@ -160,10 +388,12 @@ def _estimate_batch_memory_mb(self): for _, points in self.point_cloud_batch: total_points += points.shape[0] - memory_bytes = total_points * 12 * 1.2 + # 估计内存:每个点4个float(x,y,z,intensity),加上开销 + memory_bytes = total_points * 4 * 4 * 1.2 return memory_bytes / (1024 * 1024) def _check_memory_usage(self): + """检查内存使用""" try: import psutil process = psutil.Process() @@ -175,105 +405,161 @@ def _check_memory_usage(self): except: return False - def _save_batch(self): + def _save_batch_async(self): + """异步保存批处理数据""" if not self.point_cloud_batch: return - batch_data = [] - for frame_num, points in self.point_cloud_batch: - batch_data.append({ + # 复制当前批处理数据 + with self.data_lock: + batch_to_save = self.point_cloud_batch.copy() + self.point_cloud_batch.clear() + + # 异步保存 + self.thread_pool.submit(self._save_batch_sync, batch_to_save) + + def _save_batch_sync(self, batch_data): + """同步保存批处理数据""" + if not batch_data: + return + + batch_list = [] + for frame_num, points in batch_data: + batch_list.append({ 'frame_num': frame_num, 'points': points.tolist(), - 'num_points': points.shape[0] + 'num_points': points.shape[0], + 'timestamp': datetime.now().timestamp() }) - min_frame = min([item[0] for item in self.point_cloud_batch]) - max_frame = max([item[0] for item in self.point_cloud_batch]) + min_frame = min([item[0] for item in batch_data]) + max_frame = max([item[0] for item in batch_data]) batch_filename = f"lidar_batch_{min_frame:06d}_{max_frame:06d}.json" batch_path = os.path.join(self.lidar_dir, batch_filename) - if self.enable_compression: - try: - json_str = json.dumps(batch_data) + try: + if self.enable_compression: + json_str = json.dumps(batch_list) compressed_data = zlib.compress( json_str.encode('utf-8'), level=self.compression_level ) + + # 计算压缩率 + original_size = len(json_str.encode('utf-8')) + compressed_size = len(compressed_data) + compression_ratio = compressed_size / max(1, original_size) + self.processing_stats['compression_ratios'].append(compression_ratio) + with open(batch_path, 'wb') as f: f.write(compressed_data) - except Exception as e: - try: - with open(batch_path, 'w') as f: - json.dump(batch_data, f) - except Exception as e2: - pass - else: - try: - with open(batch_path, 'w') as f: - json.dump(batch_data, f) - except Exception as e: - pass + else: + with open(batch_path, 'w', encoding='utf-8') as f: + json.dump(batch_list, f) - self.point_cloud_batch.clear() - gc.collect() + except Exception as e: + pass - def _save_as_bin(self, points, frame_num): - bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") + gc.collect() - points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) - points_with_intensity[:, :3] = points - points_with_intensity[:, 3] = 1.0 + def _save_point_cloud_files(self, points, frame_num): + """保存点云文件(多种格式)""" + save_results = { + 'bin': None, + 'npy': None, + 'pcd': None + } + # 1. 保存为.bin文件(KITTI格式) + bin_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.bin") try: - points_with_intensity.tofile(bin_path) - except Exception as e: - return None + # KITTI格式:x,y,z,intensity + points_with_intensity = np.zeros((points.shape[0], 4), dtype=np.float32) + if points.shape[1] >= 4: + points_with_intensity[:, :] = points[:, :4] + else: + points_with_intensity[:, :3] = points[:, :3] + points_with_intensity[:, 3] = 1.0 - return bin_path + points_with_intensity.tofile(bin_path) + save_results['bin'] = bin_path + except: + save_results['bin'] = None - def _save_as_npy(self, points, frame_num): + # 2. 保存为.npy文件 npy_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.npy") + try: + np.save(npy_path, points) + save_results['npy'] = npy_path + except: + save_results['npy'] = None + # 3. 尝试保存为.pcd文件(点云库格式) + pcd_path = os.path.join(self.lidar_dir, f"lidar_{frame_num:06d}.pcd") try: - memmap_array = np.lib.format.open_memmap( - npy_path, - mode='w+', - dtype=np.float32, - shape=points.shape - ) - memmap_array[:] = points[:] - memmap_array.flush() - except Exception as e: - try: - np.save(npy_path, points) - except Exception as e2: - return None + self._save_as_pcd(points, pcd_path) + save_results['pcd'] = pcd_path + except: + save_results['pcd'] = None - return npy_path + return save_results + + def _save_as_pcd(self, points, filepath): + """保存为PCD格式""" + try: + with open(filepath, 'w') as f: + f.write("# .PCD v0.7 - Point Cloud Data file format\n") + f.write("VERSION 0.7\n") + f.write("FIELDS x y z intensity\n") + f.write("SIZE 4 4 4 4\n") + f.write("TYPE F F F F\n") + f.write("COUNT 1 1 1 1\n") + f.write(f"WIDTH {points.shape[0]}\n") + f.write("HEIGHT 1\n") + f.write("VIEWPOINT 0 0 0 1 0 0 0\n") + f.write(f"POINTS {points.shape[0]}\n") + f.write("DATA ascii\n") + + for i in range(points.shape[0]): + if points.shape[1] >= 4: + f.write(f"{points[i, 0]:.6f} {points[i, 1]:.6f} {points[i, 2]:.6f} {points[i, 3]:.6f}\n") + else: + f.write(f"{points[i, 0]:.6f} {points[i, 1]:.6f} {points[i, 2]:.6f} 1.0\n") + except: + pass def _save_as_v2xformer_format(self, points, frame_num): - v2x_dir = os.path.join(self.output_dir, "v2xformer_format") + """保存为V2XFormer格式""" + v2x_dir = os.path.join(self.output_dir, "v2xformer_format", "point_cloud") os.makedirs(v2x_dir, exist_ok=True) try: + # 创建V2XFormer格式数据 v2x_data = { 'frame_id': frame_num, 'timestamp': datetime.now().timestamp(), + 'sensor_id': 'lidar_main', 'point_cloud': { - 'points': points.tolist(), + 'points': points[:, :3].tolist(), + 'intensities': points[:, 3].tolist() if points.shape[1] >= 4 else [1.0] * points.shape[0], 'num_points': points.shape[0], - 'range': [float(points[:, 0].min()), float(points[:, 0].max()), - float(points[:, 1].min()), float(points[:, 1].max()), - float(points[:, 2].min()), float(points[:, 2].max())] + 'bounding_box': { + 'min': [float(points[:, 0].min()), float(points[:, 1].min()), float(points[:, 2].min())], + 'max': [float(points[:, 0].max()), float(points[:, 1].max()), float(points[:, 2].max())] + } }, 'metadata': { 'sensor_type': 'lidar', - 'format_version': '1.0', + 'format_version': '2.0', 'coordinate_system': 'carla_world', - 'frame_rate': 10.0 - } + 'frame_rate': 10.0, + 'pedestrian_detection': self.pedestrian_detection, + 'compression': 'none' + }, + 'pedestrian_detections': self.pedestrian_points[-10:] if self.pedestrian_points else [] } + # 使用gzip压缩保存 filename = f"{frame_num:06d}.pkl.gz" filepath = os.path.join(v2x_dir, filename) @@ -285,35 +571,52 @@ def _save_as_v2xformer_format(self, points, frame_num): except Exception as e: return None - def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): + def _generate_metadata(self, points, frame_num, save_results, v2xformer_path, original_count): + """生成元数据(增强版)""" metadata = { - 'frame_id': self.frame_counter, + 'frame_id': frame_num, 'timestamp': datetime.now().isoformat(), - 'point_count': int(points.shape[0]), + 'processing_info': { + 'original_points': original_count, + 'processed_points': int(points.shape[0]), + 'downsampling_applied': self.enable_downsampling and original_count > self.max_points_per_frame, + 'downsample_ratio': self.downsample_ratio if self.enable_downsampling else 1.0, + 'compression_enabled': self.enable_compression, + 'compression_level': self.compression_level, + 'v2x_saved': v2xformer_path is not None, + 'pedestrian_detection': self.pedestrian_detection + }, 'file_paths': { - 'bin': os.path.basename(bin_path) if bin_path else None, - 'npy': os.path.basename(npy_path) if npy_path else None, + 'bin': os.path.basename(save_results['bin']) if save_results['bin'] else None, + 'npy': os.path.basename(save_results['npy']) if save_results['npy'] else None, + 'pcd': os.path.basename(save_results['pcd']) if save_results['pcd'] else None, 'v2xformer': os.path.basename(v2xformer_path) if v2xformer_path else None }, 'statistics': { + 'point_count': int(points.shape[0]), 'x_range': [float(points[:, 0].min()), float(points[:, 0].max())], 'y_range': [float(points[:, 1].min()), float(points[:, 1].max())], 'z_range': [float(points[:, 2].min()), float(points[:, 2].max())], - 'mean': [float(points[:, 0].mean()), float(points[:, 1].mean()), float(points[:, 2].mean())], - 'std': [float(points[:, 0].std()), float(points[:, 1].std()), float(points[:, 2].std())] - }, - 'processing_info': { - 'downsampled': self.enable_downsampling and points.shape[0] > self.max_points_per_frame, - 'downsample_ratio': self.downsample_ratio if self.enable_downsampling else 1.0, - 'compression_enabled': self.enable_compression, - 'compression_level': self.compression_level, - 'v2x_saved': v2xformer_path is not None + 'mean_position': [float(points[:, 0].mean()), float(points[:, 1].mean()), float(points[:, 2].mean())], + 'std_position': [float(points[:, 0].std()), float(points[:, 1].std()), float(points[:, 2].std())], + 'density': points.shape[0] / max(1, (points[:, 0].max() - points[:, 0].min()) * + (points[:, 1].max() - points[:, 1].min())) } } - meta_path = os.path.join(self.lidar_dir, f"lidar_meta_{self.frame_counter:06d}.json") + # 如果有强度信息,添加强度统计 + if points.shape[1] >= 4: + metadata['statistics']['intensity'] = { + 'min': float(points[:, 3].min()), + 'max': float(points[:, 3].max()), + 'mean': float(points[:, 3].mean()), + 'std': float(points[:, 3].std()) + } + + # 保存元数据文件 + meta_path = os.path.join(self.lidar_dir, f"lidar_meta_{frame_num:06d}.json") try: - with open(meta_path, 'w') as f: + with open(meta_path, 'w', encoding='utf-8') as f: json.dump(metadata, f, indent=2) except Exception as e: pass @@ -321,66 +624,113 @@ def _generate_metadata(self, points, bin_path, npy_path, v2xformer_path): return metadata def flush_batch(self): + """刷新批处理数据""" if self.point_cloud_batch: - self._save_batch() + self._save_batch_sync(self.point_cloud_batch.copy()) + self.point_cloud_batch.clear() def generate_lidar_summary(self): + """生成LiDAR数据摘要(增强版)""" if not os.path.exists(self.lidar_dir): return None import glob + + # 查找各种文件 bin_files = glob.glob(os.path.join(self.lidar_dir, "*.bin")) npy_files = glob.glob(os.path.join(self.lidar_dir, "*.npy")) + pcd_files = glob.glob(os.path.join(self.lidar_dir, "*.pcd")) + json_files = glob.glob(os.path.join(self.lidar_dir, "*.json")) batch_files = glob.glob(os.path.join(self.lidar_dir, "*batch*.json")) - v2x_files = glob.glob(os.path.join(self.output_dir, "v2xformer_format", "*.pkl.gz")) + # V2XFormer格式文件 + v2x_dir = os.path.join(self.output_dir, "v2xformer_format", "point_cloud") + v2x_files = glob.glob(os.path.join(v2x_dir, "*.pkl.gz")) if os.path.exists(v2x_dir) else [] + + # 计算总点数和文件大小 total_points = 0 total_size = 0 - sample_files = bin_files[:5] if len(bin_files) > 5 else bin_files + # 抽样检查文件 + sample_files = bin_files[:min(10, len(bin_files))] for bin_file in sample_files: - if os.path.exists(bin_file): - try: - file_size = os.path.getsize(bin_file) - total_size += file_size - points_in_file = file_size // (4 * 4) - total_points += points_in_file - except: - continue + try: + file_size = os.path.getsize(bin_file) + total_size += file_size + # 估计点数:每个点4个float32 = 16字节 + points_in_file = file_size // 16 + total_points += points_in_file + except: + continue + + # 计算统计 if sample_files and len(bin_files) > 0: avg_points_per_file = total_points / max(len(sample_files), 1) total_points_estimated = avg_points_per_file * len(bin_files) else: total_points_estimated = 0 + avg_points_per_file = 0 + + # 处理统计 + avg_processing_time = np.mean(self.processing_stats['processing_times']) if self.processing_stats[ + 'processing_times'] else 0 + avg_compression_ratio = np.mean(self.processing_stats['compression_ratios']) if self.processing_stats[ + 'compression_ratios'] else 1.0 summary = { - 'total_frames': len(bin_files), - 'total_points_estimated': int(total_points_estimated), - 'average_points_per_frame': int(avg_points_per_file) if sample_files else 0, - 'file_types': { - 'bin': len(bin_files), - 'npy': len(npy_files), - 'batch': len(batch_files), - 'v2xformer': len(v2x_files) + 'summary_time': datetime.now().isoformat(), + 'file_statistics': { + 'total_frames': len(bin_files), + 'bin_files': len(bin_files), + 'npy_files': len(npy_files), + 'pcd_files': len(pcd_files), + 'json_files': len(json_files), + 'batch_files': len(batch_files), + 'v2xformer_files': len(v2x_files) + }, + 'point_statistics': { + 'total_points_estimated': int(total_points_estimated), + 'average_points_per_frame': int(avg_points_per_file), + 'total_points_processed': self.processing_stats['total_points'] }, - 'total_size_mb': round(total_size / (1024 * 1024), 2), - 'compression_ratio': round(sum([os.path.getsize(f) for f in batch_files]) / - max(1, sum([os.path.getsize(f) for f in bin_files])), 2) - if bin_files and batch_files else 1.0 + 'size_statistics': { + 'total_size_mb': round(total_size / (1024 * 1024), 2), + 'average_file_size_kb': round((total_size / max(1, len(sample_files))) / 1024, 2), + 'compression_ratio': round(avg_compression_ratio, 3) + }, + 'processing_statistics': { + 'total_frames_processed': self.processing_stats['total_frames'], + 'average_processing_time_ms': round(avg_processing_time * 1000, 2), + 'error_count': self.processing_stats['errors'], + 'success_rate': round((self.processing_stats['total_frames'] - self.processing_stats['errors']) / + max(1, self.processing_stats['total_frames']) * 100, 1) + }, + 'pedestrian_detection': { + 'enabled': self.pedestrian_detection, + 'detection_count': len(self.pedestrian_points) + } } + # 保存摘要 summary_path = os.path.join(self.output_dir, "metadata", "lidar_summary.json") try: - with open(summary_path, 'w') as f: + with open(summary_path, 'w', encoding='utf-8') as f: json.dump(summary, f, indent=2) except Exception as e: pass return summary + def cleanup(self): + """清理资源""" + self.flush_batch() + self.thread_pool.shutdown(wait=True) + gc.collect() + class MultiSensorFusion: + """多传感器融合(增强版)""" def __init__(self, output_dir, config=None): self.output_dir = output_dir @@ -389,90 +739,210 @@ def __init__(self, output_dir, config=None): self.calibration_data = {} self.fusion_cache = {} - self.cache_size = config.get('fusion_cache_size', 50) if config else 50 + self.cache_size = config.get('fusion_cache_size', 100) if config else 100 + + self.fusion_stats = { + 'total_fusions': 0, + 'cache_hits': 0, + 'processing_times': [] + } self._load_calibration() def _load_calibration(self): + """加载标定数据(增强版)""" calibration_dir = os.path.join(self.output_dir, "calibration") - if os.path.exists(calibration_dir): - calibration_files = [] - for root, dirs, files in os.walk(calibration_dir): - for file in files: - if file.endswith('.json'): - calibration_files.append(os.path.join(root, file)) - - for file in calibration_files[:10]: - try: - with open(file, 'r') as f: - data = json.load(f) - sensor_name = os.path.basename(file).replace('.json', '') - self.calibration_data[sensor_name] = data - except Exception as e: - pass + if not os.path.exists(calibration_dir): + return + + calibration_files = [] + for root, dirs, files in os.walk(calibration_dir): + for file in files: + if file.endswith('.json'): + calibration_files.append(os.path.join(root, file)) + + for file in calibration_files: + try: + with open(file, 'r', encoding='utf-8') as f: + data = json.load(f) + + sensor_name = os.path.basename(file).replace('.json', '') + self.calibration_data[sensor_name] = data + + # 解析传感器类型 + if 'sensor_type' in data: + sensor_type = data['sensor_type'] + if sensor_type not in self.calibration_data: + self.calibration_data[sensor_type] = [] + self.calibration_data[sensor_type].append(data) + + except Exception as e: + pass def create_synchronization_file(self, frame_num, sensor_data): - cache_key = f"{frame_num}_{hash(str(sensor_data))}" + """创建同步文件(增强版)""" + start_time = time.time() + + # 生成缓存键 + cache_key = f"{frame_num}_{hash(str(sorted(sensor_data.items())))}" + if cache_key in self.fusion_cache: + self.fusion_stats['cache_hits'] += 1 return self.fusion_cache[cache_key] sync_data = { 'frame_id': frame_num, 'timestamp': datetime.now().timestamp(), + 'iso_timestamp': datetime.now().isoformat(), 'sensors': {}, - 'transformations': {} + 'transformations': {}, + 'synchronization_quality': 'good', + 'missing_sensors': [] } + # 处理每个传感器的数据 for sensor_type, data_path in sensor_data.items(): if data_path and os.path.exists(data_path): - file_info = { - 'file_path': os.path.basename(data_path), - 'file_size': os.path.getsize(data_path), - 'modified_time': os.path.getmtime(data_path) - } - - if data_path.endswith(('.png', '.jpg', '.jpeg')): - try: - import cv2 - img = cv2.imread(data_path) - if img is not None: - file_info['dimensions'] = img.shape[:2] - except: - pass - + file_info = self._get_file_info(data_path) sync_data['sensors'][sensor_type] = file_info + # 添加标定变换 if sensor_type in self.calibration_data: + calib_data = self.calibration_data[sensor_type] + sync_data['transformations'][sensor_type] = { + 'matrix': calib_data.get('matrix', + [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]), + 'calibration_source': 'loaded' + } + else: + # 使用默认变换 sync_data['transformations'][sensor_type] = { - 'matrix': self.calibration_data[sensor_type].get('matrix', - [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], - [0, 0, 0, 1]]) + 'matrix': [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], + 'calibration_source': 'default' } + else: + sync_data['missing_sensors'].append(sensor_type) + + # 计算同步质量 + if len(sync_data['missing_sensors']) > 2: + sync_data['synchronization_quality'] = 'poor' + elif len(sync_data['missing_sensors']) > 0: + sync_data['synchronization_quality'] = 'fair' + + # 添加传感器间的时间偏差估计 + sync_data['temporal_alignment'] = self._estimate_temporal_alignment(sync_data['sensors']) + # 保存同步文件 sync_file = os.path.join(self.fusion_dir, f"sync_{frame_num:06d}.json") - if len(str(sync_data)) > 1000: - compressed_data = zlib.compress( - json.dumps(sync_data).encode('utf-8'), - level=3 - ) - sync_file = sync_file.replace('.json', '.json.gz') - with open(sync_file, 'wb') as f: - f.write(compressed_data) - else: - with open(sync_file, 'w') as f: - json.dump(sync_data, f, separators=(',', ':')) + try: + # 根据数据大小选择是否压缩 + json_str = json.dumps(sync_data, separators=(',', ':')) + + if len(json_str) > 5000: # 大于5KB时压缩 + compressed_data = zlib.compress( + json_str.encode('utf-8'), + level=3 + ) + sync_file = sync_file.replace('.json', '.json.gz') + with open(sync_file, 'wb') as f: + f.write(compressed_data) + else: + with open(sync_file, 'w', encoding='utf-8') as f: + json.dump(sync_data, f, indent=2) - if len(self.fusion_cache) >= self.cache_size: + except Exception as e: + # 保存失败时使用简单格式 + try: + with open(sync_file, 'w') as f: + f.write(json.dumps({'frame_id': frame_num, 'error': str(e)})) + except: + sync_file = None + + # 更新缓存 + if sync_file and len(self.fusion_cache) >= self.cache_size: + # 移除最旧的缓存项 oldest_key = next(iter(self.fusion_cache)) del self.fusion_cache[oldest_key] - self.fusion_cache[cache_key] = sync_file + if sync_file: + self.fusion_cache[cache_key] = sync_file + + # 更新统计 + self.fusion_stats['total_fusions'] += 1 + processing_time = time.time() - start_time + self.fusion_stats['processing_times'].append(processing_time) return sync_file + def _get_file_info(self, filepath): + """获取文件信息(增强版)""" + file_info = { + 'file_path': os.path.basename(filepath), + 'file_size': os.path.getsize(filepath), + 'modified_time': os.path.getmtime(filepath), + 'file_type': os.path.splitext(filepath)[1][1:] + } + + # 图像文件额外信息 + if filepath.endswith(('.png', '.jpg', '.jpeg')): + try: + import cv2 + img = cv2.imread(filepath) + if img is not None: + file_info['dimensions'] = img.shape[:2] + file_info['channels'] = img.shape[2] if len(img.shape) > 2 else 1 + file_info['dtype'] = str(img.dtype) + except: + pass + + # LiDAR文件额外信息 + elif filepath.endswith('.bin'): + try: + file_size = os.path.getsize(filepath) + # 估计点数:每个点4个float32 = 16字节 + estimated_points = file_size // 16 + file_info['estimated_points'] = estimated_points + file_info['point_format'] = 'xyz-intensity' + except: + pass + + return file_info + + def _estimate_temporal_alignment(self, sensors_info): + """估计时间对齐""" + alignment = { + 'max_time_difference': 0, + 'average_time_difference': 0, + 'alignment_score': 1.0 + } + + if len(sensors_info) < 2: + return alignment + + # 获取修改时间 + mod_times = [info['modified_time'] for info in sensors_info.values()] + + if mod_times: + max_diff = max(mod_times) - min(mod_times) + avg_diff = np.mean([abs(t - np.mean(mod_times)) for t in mod_times]) + + alignment['max_time_difference'] = max_diff + alignment['average_time_difference'] = avg_diff + + # 计算对齐分数(差异越小分数越高) + if max_diff > 1.0: # 超过1秒 + alignment['alignment_score'] = 0.3 + elif max_diff > 0.1: # 超过0.1秒 + alignment['alignment_score'] = 0.7 + else: + alignment['alignment_score'] = 1.0 + + return alignment + def generate_fusion_report(self): + """生成融合报告(增强版)""" if not os.path.exists(self.fusion_dir): return None @@ -480,36 +950,80 @@ def generate_fusion_report(self): sync_files = glob.glob(os.path.join(self.fusion_dir, "*.json*")) frame_ids = [] - for sync_file in sync_files[:20]: + file_sizes = [] + compression_stats = {'compressed': 0, 'uncompressed': 0} + + for sync_file in sync_files[:50]: # 只检查前50个文件 try: filename = os.path.basename(sync_file) if filename.startswith('sync_'): - frame_id = int(filename.split('_')[1].split('.')[0]) - frame_ids.append(frame_id) + # 提取帧ID + frame_id_str = filename.split('_')[1].split('.')[0] + if frame_id_str.isdigit(): + frame_id = int(frame_id_str) + frame_ids.append(frame_id) + + # 统计文件大小 + file_size = os.path.getsize(sync_file) + file_sizes.append(file_size) + + # 统计压缩情况 + if sync_file.endswith('.gz'): + compression_stats['compressed'] += 1 + else: + compression_stats['uncompressed'] += 1 + except: continue + # 计算处理统计 + avg_processing_time = np.mean(self.fusion_stats['processing_times']) if self.fusion_stats[ + 'processing_times'] else 0 + cache_hit_rate = self.fusion_stats['cache_hits'] / max(1, self.fusion_stats['total_fusions']) + report = { - 'total_sync_frames': len(sync_files), - 'calibration_data_count': len(self.calibration_data), - 'sensor_types': list(set([f.split('_')[0] for f in self.calibration_data.keys()])), - 'frame_range': [min(frame_ids), max(frame_ids)] if frame_ids else [], - 'file_sizes': { - 'total_mb': round(sum([os.path.getsize(f) for f in sync_files]) / (1024 * 1024), 2), - 'average_kb': round(np.mean([os.path.getsize(f) / 1024 for f in sync_files]), 2) if sync_files else 0 + 'report_time': datetime.now().isoformat(), + 'fusion_statistics': { + 'total_sync_frames': len(sync_files), + 'calibration_data_count': len(self.calibration_data), + 'sensor_types': list(set([data.get('sensor_type', 'unknown') + for data in self.calibration_data.values() + if isinstance(data, dict)])), + 'frame_range': [min(frame_ids), max(frame_ids)] if frame_ids else [], + 'cache_hit_rate': round(cache_hit_rate, 3), + 'average_processing_time_ms': round(avg_processing_time * 1000, 2) }, - 'compression_info': { - 'compressed_files': len([f for f in sync_files if f.endswith('.gz')]), + 'file_statistics': { + 'total_files': len(sync_files), + 'total_size_mb': round(sum(file_sizes) / (1024 * 1024), 2), + 'average_file_size_kb': round(np.mean(file_sizes) / 1024, 2) if file_sizes else 0, 'compression_ratio': round( - sum([os.path.getsize(f) for f in sync_files if f.endswith('.gz')]) / - max(1, sum([os.path.getsize(f) for f in sync_files if not f.endswith('.gz')])), - 2 - ) if sync_files else 1.0 + sum([s for f, s in zip(sync_files, file_sizes) if f.endswith('.gz')]) / + max(1, sum([s for f, s in zip(sync_files, file_sizes) if not f.endswith('.gz')])), 2 + ) if sync_files else 1.0, + 'compression_stats': compression_stats + }, + 'calibration_summary': { + 'total_calibrations': len(self.calibration_data), + 'by_type': {} } } + # 按类型统计标定数据 + for data in self.calibration_data.values(): + if isinstance(data, dict) and 'sensor_type' in data: + sensor_type = data['sensor_type'] + report['calibration_summary']['by_type'][sensor_type] = \ + report['calibration_summary']['by_type'].get(sensor_type, 0) + 1 + + # 保存报告 report_path = os.path.join(self.output_dir, "metadata", "fusion_report.json") - with open(report_path, 'w') as f: + with open(report_path, 'w', encoding='utf-8') as f: json.dump(report, f, indent=2) - return report \ No newline at end of file + return report + + def cleanup(self): + """清理资源""" + self.fusion_cache.clear() + gc.collect() \ No newline at end of file diff --git a/src/enhance_pedestrian_safety/main.py b/src/enhance_pedestrian_safety/main.py index bfd920d8f4..012872ae61 100644 --- a/src/enhance_pedestrian_safety/main.py +++ b/src/enhance_pedestrian_safety/main.py @@ -1,4 +1,7 @@ -# !/usr/bin/env python3 +#!/usr/bin/env python3 +""" +CVIPS 行人安全增强数据收集系统 - 主程序(增强版) +""" import sys import os import time @@ -12,38 +15,71 @@ import gc import psutil import numpy as np +import signal -from carla_utils import setup_carla_path, import_carla_module +from carla_utils import setup_carla_path, import_carla_module, setup_carla_environment from config_manager import ConfigManager from annotation_generator import AnnotationGenerator from data_validator import DataValidator from lidar_processor import LidarProcessor, MultiSensorFusion from multi_vehicle_manager import MultiVehicleManager from pedestrian_safety_monitor import PedestrianSafetyMonitor +from scene_manager import SceneManager +from sensor_enhancer import SensorDataEnhancer, EnhancementConfig, WeatherType, EnhancementMethod +from v2x_communication import V2XCommunication -carla_egg_path, remaining_argv = setup_carla_path() -carla = import_carla_module() +# 设置CARLA环境 +carla_module, remaining_argv = setup_carla_environment() +carla = carla_module class PerformanceMonitor: - def __init__(self): + """性能监控器(增强版)""" + + def __init__(self, config): + self.config = config self.start_time = time.time() self.memory_samples = [] self.cpu_samples = [] self.frame_times = [] self.first_frame_time = None self.last_frame_time = None + self.gc_stats = [] + self.network_stats = [] + + # 性能阈值 + self.warning_thresholds = { + 'memory_mb': config.get('performance', {}).get('memory_management', {}).get('early_stop_threshold', 450), + 'cpu_percent': 90, + 'frame_time_ms': 200 # 5 FPS + } + + # 警告记录 + self.warnings = [] def sample_memory(self): + """采样内存使用""" try: process = psutil.Process(os.getpid()) - memory_mb = process.memory_info().rss / 1024 / 1024 + memory_info = process.memory_info() + + memory_mb = memory_info.rss / 1024 / 1024 self.memory_samples.append(memory_mb) + + # 检查内存警告 + if memory_mb > self.warning_thresholds['memory_mb'] * 0.8: + if not any('内存使用高' in w for w in self.warnings[-5:]): # 避免重复警告 + self.warnings.append(f"内存使用高: {memory_mb:.1f}MB") + + system_memory = psutil.virtual_memory() + return { 'process_mb': memory_mb, - 'system_total_mb': psutil.virtual_memory().total / 1024 / 1024, - 'system_used_percent': psutil.virtual_memory().percent, - 'system_available_mb': psutil.virtual_memory().available / 1024 / 1024 + 'process_vms_mb': memory_info.vms / 1024 / 1024, + 'system_total_mb': system_memory.total / 1024 / 1024, + 'system_used_percent': system_memory.percent, + 'system_available_mb': system_memory.available / 1024 / 1024, + 'warning': memory_mb > self.warning_thresholds['memory_mb'] * 0.8 } except: memory_mb = 0 @@ -52,17 +88,28 @@ def sample_memory(self): 'process_mb': memory_mb, 'system_total_mb': 0, 'system_used_percent': 0, - 'system_available_mb': 0 + 'system_available_mb': 0, + 'warning': False } def sample_cpu(self): + """采样CPU使用""" try: cpu_percent = psutil.cpu_percent(interval=0.1) self.cpu_samples.append(cpu_percent) + + # 检查CPU警告 + if cpu_percent > self.warning_thresholds['cpu_percent']: + if not any('CPU使用高' in w for w in self.warnings[-5:]): + self.warnings.append(f"CPU使用高: {cpu_percent:.1f}%") + + per_core = psutil.cpu_percent(interval=0.1, percpu=True) + return { 'total_percent': cpu_percent, - 'per_core': psutil.cpu_percent(interval=0.1, percpu=True), - 'count': psutil.cpu_count() + 'per_core': per_core, + 'count': psutil.cpu_count(), + 'warning': cpu_percent > self.warning_thresholds['cpu_percent'] } except: cpu_percent = 0 @@ -70,16 +117,41 @@ def sample_cpu(self): return { 'total_percent': cpu_percent, 'per_core': [0], - 'count': 1 + 'count': 1, + 'warning': False + } + + def sample_gc(self): + """采样垃圾回收统计""" + try: + gc.collect() + gc_stats = { + 'collected': gc.get_count()[0], + 'uncollectable': len(gc.garbage), + 'thresholds': gc.get_threshold(), + 'enabled': gc.isenabled() } + self.gc_stats.append(gc_stats) + return gc_stats + except: + return {} def record_frame_time(self, frame_time): + """记录帧时间""" self.frame_times.append(frame_time) + + # 检查帧时间警告 + frame_time_ms = frame_time * 1000 + if frame_time_ms > self.warning_thresholds['frame_time_ms']: + if not any('帧时间过长' in w for w in self.warnings[-5:]): + self.warnings.append(f"帧时间过长: {frame_time_ms:.1f}ms") + if self.first_frame_time is None: self.first_frame_time = time.time() self.last_frame_time = time.time() def get_performance_summary(self): + """获取性能摘要""" if not self.frame_times or len(self.frame_times) < 2: avg_frame_time = 0 fps = 0 @@ -89,19 +161,36 @@ def get_performance_summary(self): summary = { 'total_runtime': time.time() - self.start_time, - 'average_memory_mb': np.mean(self.memory_samples) if self.memory_samples else 0, - 'max_memory_mb': max(self.memory_samples) if self.memory_samples else 0, - 'min_memory_mb': min(self.memory_samples) if self.memory_samples else 0, - 'average_cpu_percent': np.mean(self.cpu_samples) if self.cpu_samples else 0, - 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, - 'average_frame_time': avg_frame_time, - 'frames_per_second': fps, - 'total_frames': len(self.frame_times) + 'memory_statistics': { + 'average_memory_mb': np.mean(self.memory_samples) if self.memory_samples else 0, + 'max_memory_mb': max(self.memory_samples) if self.memory_samples else 0, + 'min_memory_mb': min(self.memory_samples) if self.memory_samples else 0, + 'memory_warnings': len( + [m for m in self.memory_samples if m > self.warning_thresholds['memory_mb'] * 0.8]) + }, + 'cpu_statistics': { + 'average_cpu_percent': np.mean(self.cpu_samples) if self.cpu_samples else 0, + 'max_cpu_percent': max(self.cpu_samples) if self.cpu_samples else 0, + 'cpu_warnings': len([c for c in self.cpu_samples if c > self.warning_thresholds['cpu_percent']]) + }, + 'frame_statistics': { + 'average_frame_time': avg_frame_time, + 'frames_per_second': fps, + 'total_frames': len(self.frame_times), + 'frame_time_warnings': len( + [f for f in self.frame_times if f * 1000 > self.warning_thresholds['frame_time_ms']]) + }, + 'gc_statistics': { + 'total_collections': len(self.gc_stats), + 'average_collected': np.mean([s.get('collected', 0) for s in self.gc_stats]) if self.gc_stats else 0 + }, + 'warnings': self.warnings[-10:] # 最近10个警告 } if self.frame_times and len(self.frame_times) >= 2: summary['frame_time_stats'] = { 'p50': np.percentile(self.frame_times, 50), + 'p75': np.percentile(self.frame_times, 75), 'p95': np.percentile(self.frame_times, 95), 'p99': np.percentile(self.frame_times, 99) if len(self.frame_times) > 1 else 0, 'std': np.std(self.frame_times) @@ -109,6 +198,7 @@ def get_performance_summary(self): else: summary['frame_time_stats'] = { 'p50': 0, + 'p75': 0, 'p95': 0, 'p99': 0, 'std': 0 @@ -116,97 +206,361 @@ def get_performance_summary(self): return summary + def check_emergency_stop(self): + """检查是否需要紧急停止""" + if not self.memory_samples: + return False + + current_memory = self.memory_samples[-1] + return current_memory > self.warning_thresholds['memory_mb'] + class Log: + """日志系统(增强版)""" + + LOG_LEVELS = { + 'DEBUG': 0, + 'INFO': 1, + 'WARNING': 2, + 'ERROR': 3, + 'CRITICAL': 4 + } + + current_level = 'INFO' + log_file = None + + @classmethod + def setup(cls, config): + """设置日志系统""" + cls.current_level = config.get('monitoring', {}).get('log_level', 'INFO') + log_file = config.get('monitoring', {}).get('log_file', 'cvips.log') + + if config.get('monitoring', {}).get('enable_logging', True): + cls.log_file = open(log_file, 'a', encoding='utf-8') + + @classmethod + def _should_log(cls, level): + """检查是否应该记录""" + return cls.LOG_LEVELS[level] >= cls.LOG_LEVELS[cls.current_level] + @staticmethod def info(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[INFO][{timestamp}] {msg}") + """信息日志""" + if not Log._should_log('INFO'): + return + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[INFO][{timestamp}] {msg}" + print(f"\033[92m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() @staticmethod def warning(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[WARNING][{timestamp}] {msg}") + """警告日志""" + if not Log._should_log('WARNING'): + return + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[WARNING][{timestamp}] {msg}" + print(f"\033[93m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() @staticmethod def error(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[ERROR][{timestamp}] {msg}") + """错误日志""" + if not Log._should_log('ERROR'): + return + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[ERROR][{timestamp}] {msg}" + print(f"\033[91m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() @staticmethod def debug(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[DEBUG][{timestamp}] {msg}") + """调试日志""" + if not Log._should_log('DEBUG'): + return + + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[DEBUG][{timestamp}] {msg}" + print(f"\033[90m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() @staticmethod def performance(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[PERF][{timestamp}] {msg}") + """性能日志""" + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[PERF][{timestamp}] {msg}" + print(f"\033[96m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() @staticmethod def safety(msg): - timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") - print(f"[SAFETY][{timestamp}] {msg}") + """安全日志""" + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[SAFETY][{timestamp}] {msg}" + print(f"\033[95m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() + + @staticmethod + def critical(msg): + """关键日志""" + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3] + log_msg = f"[CRITICAL][{timestamp}] {msg}" + print(f"\033[91;1m{log_msg}\033[0m") + + if Log.log_file: + Log.log_file.write(log_msg + '\n') + Log.log_file.flush() + + @classmethod + def cleanup(cls): + """清理日志资源""" + if cls.log_file: + cls.log_file.close() + cls.log_file = None + + +class EmergencyHandler: + """紧急处理程序""" + + def __init__(self, data_collector): + self.data_collector = data_collector + self.emergency_stop = False + self.last_emergency_time = 0 + + # 设置信号处理器 + signal.signal(signal.SIGINT, self._signal_handler) + signal.signal(signal.SIGTERM, self._signal_handler) + + def _signal_handler(self, signum, frame): + """信号处理""" + Log.critical(f"收到信号 {signum},正在安全关闭...") + self.emergency_stop = True + self.data_collector.is_running = False + + def check_emergency(self): + """检查紧急情况""" + current_time = time.time() + + # 避免过于频繁的紧急检查 + if current_time - self.last_emergency_time < 5.0: + return False + + self.last_emergency_time = current_time + + # 检查内存使用 + try: + import psutil + process = psutil.Process() + memory_mb = process.memory_info().rss / (1024 * 1024) + + memory_threshold = self.data_collector.config['performance'].get( + 'memory_management', {}).get('early_stop_threshold', 450) + + if memory_mb > memory_threshold: + Log.critical(f"内存使用超过阈值: {memory_mb:.1f}MB > {memory_threshold}MB") + return True + + except: + pass + + return False + + def emergency_cleanup(self): + """紧急清理""" + Log.critical("执行紧急清理...") + + try: + # 强制垃圾回收 + gc.collect() + + # 清理传感器数据 + for sensor_manager in self.data_collector.sensor_managers.values(): + if hasattr(sensor_manager, 'image_processor'): + if hasattr(sensor_manager.image_processor, 'image_cache'): + sensor_manager.image_processor.image_cache.clear() + + Log.critical("紧急清理完成") + + except Exception as e: + Log.error(f"紧急清理失败: {e}") class WeatherSystem: + """天气系统(增强版)""" + WEATHER_PRESETS = { - 'clear': {'cloudiness': 10, 'precipitation': 0, 'wind': 5}, - 'rainy': {'cloudiness': 90, 'precipitation': 80, 'wind': 15}, - 'cloudy': {'cloudiness': 70, 'precipitation': 10, 'wind': 10}, - 'foggy': {'cloudiness': 50, 'precipitation': 0, 'fog_density': 40} + 'clear': { + 'cloudiness': 10, + 'precipitation': 0, + 'wind': 5, + 'fog_density': 0, + 'wetness': 0, + 'sun_altitude': 75 + }, + 'rainy': { + 'cloudiness': 90, + 'precipitation': 80, + 'wind': 15, + 'fog_density': 20, + 'wetness': 80, + 'sun_altitude': 30 + }, + 'cloudy': { + 'cloudiness': 70, + 'precipitation': 10, + 'wind': 10, + 'fog_density': 10, + 'wetness': 20, + 'sun_altitude': 45 + }, + 'foggy': { + 'cloudiness': 50, + 'precipitation': 0, + 'fog_density': 60, + 'wind': 3, + 'wetness': 30, + 'sun_altitude': 20 + }, + 'wet': { + 'cloudiness': 40, + 'precipitation': 0, + 'wind': 8, + 'fog_density': 10, + 'wetness': 60, + 'sun_altitude': 50 + } + } + + TIME_PRESETS = { + 'noon': {'sun_altitude': 75, 'sun_azimuth': 0}, + 'sunset': {'sun_altitude': 15, 'sun_azimuth': 270}, + 'night': {'sun_altitude': -20, 'sun_azimuth': 0}, + 'dawn': {'sun_altitude': 15, 'sun_azimuth': 90} } @staticmethod def create_weather(weather_type, time_of_day): + """创建天气(增强版)""" weather = carla.WeatherParameters() if weather_type in WeatherSystem.WEATHER_PRESETS: preset = WeatherSystem.WEATHER_PRESETS[weather_type] weather.cloudiness = preset.get('cloudiness', 30) weather.precipitation = preset.get('precipitation', 0) + weather.precipitation_deposits = preset.get('wetness', 0) weather.wind_intensity = preset.get('wind', 5) - if 'fog_density' in preset: - weather.fog_density = preset['fog_density'] + weather.fog_density = preset.get('fog_density', 0) + weather.fog_distance = 5.0 if preset.get('fog_density', 0) > 50 else 15.0 + weather.wetness = preset.get('wetness', 0) - if time_of_day == 'noon': - weather.sun_altitude_angle = 75 - elif time_of_day == 'sunset': - weather.sun_altitude_angle = 15 - elif time_of_day == 'night': - weather.sun_altitude_angle = -20 + if time_of_day in WeatherSystem.TIME_PRESETS: + time_preset = WeatherSystem.TIME_PRESETS[time_of_day] + weather.sun_altitude_angle = time_preset['sun_altitude'] + weather.sun_azimuth_angle = time_preset['sun_azimuth'] + + # 根据时间调整亮度 + if time_of_day == 'night': + weather.cloudiness = min(weather.cloudiness + 20, 100) return weather + @staticmethod + def create_dynamic_weather(base_weather, variation=0.1): + """创建动态变化的天气""" + dynamic = carla.WeatherParameters() + + # 基于基础天气添加随机变化 + for attr in ['cloudiness', 'precipitation', 'wind_intensity', 'fog_density']: + if hasattr(base_weather, attr): + base_value = getattr(base_weather, attr) + variation_range = base_value * variation + new_value = max(0, min(100, base_value + random.uniform(-variation_range, variation_range))) + setattr(dynamic, attr, new_value) + + # 保持其他属性 + for attr in ['sun_altitude_angle', 'sun_azimuth_angle', 'precipitation_deposits', 'wetness']: + if hasattr(base_weather, attr): + setattr(dynamic, attr, getattr(base_weather, attr)) + + return dynamic + class ImageProcessor: + """图像处理器(增强版)""" + def __init__(self, output_dir, config=None): self.output_dir = output_dir self.stitched_dir = os.path.join(output_dir, "stitched") os.makedirs(self.stitched_dir, exist_ok=True) - self.compress_images = config.get('compress_images', True) if config else True - self.compression_quality = config.get('compression_quality', 85) if config else 85 - self.enable_memory_cache = config.get('enable_memory_cache', True) if config else True + self.config = config or {} + img_config = self.config.get('image_processing', {}) + + self.compress_images = img_config.get('compress_images', True) + self.compression_quality = img_config.get('compression_quality', 85) + self.enable_memory_cache = img_config.get('enable_memory_cache', True) self.image_cache = {} - self.max_cache_size = config.get('max_cache_size', 50) if config else 50 + self.max_cache_size = img_config.get('max_cache_size', 50) + + self.stitch_layouts = { + 'vehicle_4cam': { + 'canvas_size': (640 * 2 + 20, 360 * 2 + 20), + 'positions': [(10, 10), (660, 10), (10, 390), (660, 390)], + 'tile_size': (640, 360) + }, + 'infrastructure_4cam': { + 'canvas_size': (640 * 2 + 20, 360 * 2 + 20), + 'positions': [(10, 10), (660, 10), (10, 390), (660, 390)], + 'tile_size': (640, 360) + }, + 'wide_view': { + 'canvas_size': (1280, 720), + 'positions': [(0, 0)], + 'tile_size': (1280, 720) + } + } self.stats = { 'images_processed': 0, 'cache_hits': 0, 'cache_misses': 0, - 'total_processing_time': 0 + 'total_processing_time': 0, + 'stitching_errors': 0, + 'saved_size_mb': 0 } def stitch(self, image_paths, frame_num, view_type="vehicle"): + """拼接图像(增强版)""" try: - from PIL import Image, ImageDraw + from PIL import Image, ImageDraw, ImageFont except ImportError: Log.warning("PIL未安装,跳过图像拼接") return False start_time = time.time() + # 检查缓存 cache_key = f"{view_type}_{frame_num}" if self.enable_memory_cache and cache_key in self.image_cache: cached_image = self.image_cache[cache_key] @@ -220,52 +574,98 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): progressive=True) else: cached_image.save(output_path, "PNG", optimize=True) + + self.stats['cache_hits'] += 1 + self.stats['images_processed'] += 1 + processing_time = time.time() - start_time + self.stats['total_processing_time'] += processing_time + + return True except Exception as e: Log.error(f"保存缓存图像失败: {e}") return False - self.stats['cache_hits'] += 1 - self.stats['images_processed'] += 1 - processing_time = time.time() - start_time - self.stats['total_processing_time'] += processing_time - return True - self.stats['cache_misses'] += 1 - positions = [(10, 10), (660, 10), (10, 390), (660, 390)] + # 获取布局配置 + layout = self.stitch_layouts.get(view_type, self.stitch_layouts['vehicle_4cam']) + canvas_size = layout['canvas_size'] + positions = layout['positions'] + tile_size = layout['tile_size'] - canvas = Image.new('RGB', (640 * 2 + 20, 360 * 2 + 20), (40, 40, 40)) + # 创建画布 + canvas = Image.new('RGB', canvas_size, (40, 40, 40)) draw = ImageDraw.Draw(canvas) + # 尝试加载字体 + try: + font = ImageFont.truetype("arial.ttf", 14) + except: + font = ImageFont.load_default() + images_loaded = 0 - for idx, (cam_name, img_path) in enumerate(list(image_paths.items())[:4]): + image_items = list(image_paths.items()) + + for idx, (cam_name, img_path) in enumerate(image_items[:len(positions)]): if img_path and os.path.exists(img_path): try: + # 检查缓存 if img_path in self.image_cache: img = self.image_cache[img_path] else: + # 加载图像 img = Image.open(img_path) img.load() - img = img.resize((640, 360), Image.Resampling.LANCZOS) + # 调整大小 + if img.size != tile_size: + img = img.resize(tile_size, Image.Resampling.LANCZOS) + + # 缓存图像 if self.enable_memory_cache: self.image_cache[img_path] = img if len(self.image_cache) > self.max_cache_size: self._cleanup_cache() - images_loaded += 1 + + # 添加到画布 + if idx < len(positions): + canvas.paste(img, positions[idx]) + + # 添加摄像机标签 + label = cam_name.replace('_', ' ').title() + draw.text((positions[idx][0] + 5, positions[idx][1] + 5), + label, fill=(255, 255, 200), font=font) + + images_loaded += 1 + except Exception as e: - Log.warning(f"加载图像失败: {e}") - img = Image.new('RGB', (640, 360), (80, 80, 80)) + Log.warning(f"加载图像失败 {cam_name}: {e}") + + # 创建占位图像 + placeholder = Image.new('RGB', tile_size, (80, 80, 80)) + if idx < len(positions): + canvas.paste(placeholder, positions[idx]) + draw.text((positions[idx][0] + 5, positions[idx][1] + 5), + f"Error: {cam_name}", fill=(255, 100, 100), font=font) else: - img = Image.new('RGB', (640, 360), (80, 80, 80)) - - canvas.paste(img, positions[idx]) - draw.text((positions[idx][0] + 5, positions[idx][1] + 5), - cam_name, fill=(255, 255, 200)) + # 创建占位图像 + placeholder = Image.new('RGB', tile_size, (80, 80, 80)) + if idx < len(positions): + canvas.paste(placeholder, positions[idx]) + draw.text((positions[idx][0] + 5, positions[idx][1] + 5), + f"Missing: {cam_name}", fill=(255, 200, 100), font=font) if images_loaded == 0: + Log.warning(f"没有图像加载成功: {view_type}") + self.stats['stitching_errors'] += 1 return False + # 添加帧信息和时间戳 + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + info_text = f"Frame: {frame_num:06d} | {timestamp} | {view_type} | Images: {images_loaded}/{len(image_items)}" + draw.text((10, canvas_size[1] - 25), info_text, fill=(200, 200, 255), font=font) + + # 保存图像 output_path = os.path.join(self.stitched_dir, f"{view_type}_{frame_num:06d}.jpg") try: @@ -277,36 +677,66 @@ def stitch(self, image_paths, frame_num, view_type="vehicle"): subsampling='4:2:0') else: canvas.save(output_path, "PNG", optimize=True) + + # 计算节省的空间 + original_size = sum([os.path.getsize(p) for p in image_paths.values() if p and os.path.exists(p)]) + stitched_size = os.path.getsize(output_path) + if original_size > 0: + size_saving = (original_size - stitched_size) / (1024 * 1024) + self.stats['saved_size_mb'] += max(0, size_saving) + except Exception as e: Log.error(f"保存图像失败: {e}") + self.stats['stitching_errors'] += 1 return False + # 更新缓存 if self.enable_memory_cache: self.image_cache[cache_key] = canvas.copy() + # 清理 del canvas gc.collect() + # 更新统计 self.stats['images_processed'] += 1 processing_time = time.time() - start_time self.stats['total_processing_time'] += processing_time + # 定期报告 if self.stats['images_processed'] % 50 == 0: - avg_time = self.stats['total_processing_time'] / self.stats['images_processed'] - cache_hit_rate = self.stats['cache_hits'] / max(1, self.stats['cache_hits'] + self.stats['cache_misses']) - Log.performance(f"图像处理统计: 处理{self.stats['images_processed']}张, " - f"平均{avg_time:.3f}秒/张, 缓存命中率{cache_hit_rate:.1%}") + self._report_statistics() return True def _cleanup_cache(self): + """清理缓存""" if len(self.image_cache) > self.max_cache_size: keys_to_remove = list(self.image_cache.keys())[:len(self.image_cache) - self.max_cache_size] for key in keys_to_remove: del self.image_cache[key] - Log.debug(f"清理缓存: 移除了{len(keys_to_remove)}个缓存项") + Log.debug(f"清理图像缓存: 移除了{len(keys_to_remove)}个缓存项") + + def _report_statistics(self): + """报告统计信息""" + total_operations = self.stats['cache_hits'] + self.stats['cache_misses'] + if total_operations > 0: + cache_hit_rate = self.stats['cache_hits'] / total_operations + else: + cache_hit_rate = 0 + + avg_time = 0 + if self.stats['images_processed'] > 0: + avg_time = self.stats['total_processing_time'] / self.stats['images_processed'] + + Log.performance(f"图像处理统计: " + f"处理{self.stats['images_processed']}张, " + f"平均{avg_time:.3f}秒/张, " + f"缓存命中率{cache_hit_rate:.1%}, " + f"节省空间{self.stats['saved_size_mb']:.1f}MB") def get_stats(self): + """获取统计信息""" total_operations = self.stats['cache_hits'] + self.stats['cache_misses'] if total_operations > 0: cache_hit_rate = self.stats['cache_hits'] / total_operations @@ -321,107 +751,170 @@ def get_stats(self): **self.stats, 'cache_hit_rate': cache_hit_rate, 'average_processing_time': avg_time, - 'current_cache_size': len(self.image_cache) + 'current_cache_size': len(self.image_cache), + 'stitching_success_rate': (self.stats['images_processed'] - self.stats['stitching_errors']) / + max(1, self.stats['images_processed']) } class TrafficManager: + """交通管理器(增强版)""" + def __init__(self, world, config): self.world = world self.config = config self.vehicles = [] self.pedestrians = [] + self.bicycles = [] + self.motorcycles = [] - seed = config['scenario'].get('seed', random.randint(1, 1000)) + # 设置随机种子 + seed = config['scenario'].get('seed', random.randint(1, 10000)) random.seed(seed) + np.random.seed(seed) Log.info(f"随机种子: {seed}") self.batch_spawn = config.get('batch_spawn', True) - self.max_spawn_attempts = config.get('max_spawn_attempts', 5) + self.max_spawn_attempts = config.get('max_spawn_attempts', 10) + + # 行人安全相关 + self.pedestrian_safety_zones = config.get('pedestrian_safety_zones', True) + self.crosswalk_density = config.get('crosswalk_density', 'medium') self.spawn_stats = { 'total_attempts': 0, 'successful_spawns': 0, 'failed_spawns': 0, - 'total_spawn_time': 0 + 'total_spawn_time': 0, + 'vehicle_types': {}, + 'pedestrian_types': {} } def spawn_ego_vehicle(self): + """生成主车(增强版)""" blueprint_lib = self.world.get_blueprint_library() - common_vehicles = [ + # 优先选择的车辆类型 + preferred_vehicles = [ 'vehicle.tesla.model3', 'vehicle.audi.tt', - 'vehicle.mini.cooperst', - 'vehicle.nissan.micra' + 'vehicle.nissan.patrol', + 'vehicle.mercedes.coupe', + 'vehicle.bmw.grandtourer', + 'vehicle.lincoln.mkz2017', + 'vehicle.chevrolet.impala' ] - for vtype in common_vehicles: + vehicle_bp = None + for vtype in preferred_vehicles: if blueprint_lib.filter(vtype): vehicle_bp = random.choice(blueprint_lib.filter(vtype)) break - else: + + if not vehicle_bp: vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + # 设置车辆属性 + if vehicle_bp.has_attribute('color'): + colors = vehicle_bp.get_attribute('color').recommended_values + if colors: + vehicle_bp.set_attribute('color', random.choice(colors)) + spawn_points = self.world.get_map().get_spawn_points() if not spawn_points: + Log.error("没有可用的生成点") return None - spawn_point = random.choice(spawn_points) - + # 尝试生成 for attempt in range(self.max_spawn_attempts): self.spawn_stats['total_attempts'] += 1 + spawn_point = random.choice(spawn_points) + try: start_time = time.time() vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + + # 设置自动驾驶 vehicle.set_autopilot(True) - vehicle.apply_control(carla.VehicleControl(throttle=0.2)) + + # 设置初始控制 + control = carla.VehicleControl() + control.throttle = 0.3 + control.steer = 0.0 + vehicle.apply_control(control) spawn_time = time.time() - start_time self.spawn_stats['total_spawn_time'] += spawn_time self.spawn_stats['successful_spawns'] += 1 - Log.info(f"主车: {vehicle.type_id}, 生成时间: {spawn_time:.3f}秒") + # 记录车辆类型 + vehicle_type = vehicle.type_id + self.spawn_stats['vehicle_types'][vehicle_type] = \ + self.spawn_stats['vehicle_types'].get(vehicle_type, 0) + 1 + + Log.info(f"主车生成: {vehicle_type}, 位置: {spawn_point.location}, 时间: {spawn_time:.3f}秒") + return vehicle + except Exception as e: self.spawn_stats['failed_spawns'] += 1 if attempt == self.max_spawn_attempts - 1: Log.warning(f"主车生成失败: {e}") else: - spawn_point = random.choice(spawn_points) time.sleep(0.1) return None def spawn_traffic(self, center_location): + """生成交通(增强版)""" start_time = time.time() - if self.batch_spawn: - vehicles = self._spawn_vehicles_batch() - else: - vehicles = self._spawn_vehicles() + # 生成车辆 + vehicles_spawned = self._spawn_vehicles_batch() if self.batch_spawn else self._spawn_vehicles() - pedestrians = self._spawn_pedestrians(center_location) + # 生成行人 + pedestrians_spawned = self._spawn_pedestrians(center_location) + + # 生成自行车 + bicycles_spawned = self._spawn_bicycles(center_location) + + # 生成摩托车 + motorcycles_spawned = self._spawn_motorcycles(center_location) total_time = time.time() - start_time - Log.info(f"交通生成: {vehicles}辆车, {pedestrians}个行人, 用时: {total_time:.2f}秒") + Log.info(f"交通生成完成: " + f"{vehicles_spawned}辆车, " + f"{pedestrians_spawned}个行人, " + f"{bicycles_spawned}辆自行车, " + f"{motorcycles_spawned}辆摩托车, " + f"用时: {total_time:.2f}秒") + + # 生成统计报告 success_rate = self.spawn_stats['successful_spawns'] / max(1, self.spawn_stats['total_attempts']) avg_spawn_time = self.spawn_stats['total_spawn_time'] / max(1, self.spawn_stats['successful_spawns']) - Log.performance(f"生成统计: 成功率{success_rate:.1%}, 平均生成时间{avg_spawn_time:.3f}秒") - return vehicles + pedestrians + Log.performance(f"生成统计: " + f"成功率{success_rate:.1%}, " + f"平均生成时间{avg_spawn_time:.3f}秒, " + f"车辆类型: {len(self.spawn_stats['vehicle_types'])}种, " + f"行人类型: {len(self.spawn_stats['pedestrian_types'])}种") + + return vehicles_spawned + pedestrians_spawned + bicycles_spawned + motorcycles_spawned def _spawn_vehicles_batch(self): + """批量生成车辆""" blueprint_lib = self.world.get_blueprint_library() spawn_points = self.world.get_map().get_spawn_points() if not spawn_points: + Log.warning("没有可用的车辆生成点") return 0 - num_vehicles = min(self.config['traffic']['background_vehicles'], 10) + num_vehicles = min(self.config['traffic']['background_vehicles'], 20) spawned = 0 + # 准备批处理命令 batch_commands = [] available_points = spawn_points.copy() random.shuffle(available_points) @@ -431,80 +924,240 @@ def _spawn_vehicles_batch(self): break try: - vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + # 选择车辆类型 + vehicle_types = self.config['traffic']['vehicle_types'] + available_types = [vt for vt in vehicle_types if blueprint_lib.filter(vt)] + + if not available_types: + vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) + else: + vehicle_bp = random.choice(blueprint_lib.filter(random.choice(available_types))) + + # 设置颜色 + if vehicle_bp.has_attribute('color'): + colors = vehicle_bp.get_attribute('color').recommended_values + if colors: + vehicle_bp.set_attribute('color', random.choice(colors)) + spawn_point = available_points[i] - batch_commands.append((vehicle_bp, spawn_point)) - except: - pass - for vehicle_bp, spawn_point in batch_commands: + # 添加随机偏移 + offset_x = random.uniform(-3.0, 3.0) + offset_y = random.uniform(-3.0, 3.0) + location = carla.Location( + x=spawn_point.location.x + offset_x, + y=spawn_point.location.y + offset_y, + z=spawn_point.location.z + ) + + # 稍微调整方向 + rotation = carla.Rotation( + pitch=spawn_point.rotation.pitch, + yaw=spawn_point.rotation.yaw + random.uniform(-10, 10), + roll=spawn_point.rotation.roll + ) + + transform = carla.Transform(location, rotation) + batch_commands.append((vehicle_bp, transform)) + + except Exception as e: + Log.debug(f"准备车辆生成命令失败: {e}") + continue + + # 执行批处理生成 + for vehicle_bp, transform in batch_commands: try: - vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) + vehicle = self.world.spawn_actor(vehicle_bp, transform) vehicle.set_autopilot(True) + + # 设置初始速度 + control = carla.VehicleControl() + control.throttle = random.uniform(0.2, 0.5) + vehicle.apply_control(control) + self.vehicles.append(vehicle) spawned += 1 self.spawn_stats['successful_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 - except: + + # 记录类型 + vehicle_type = vehicle.type_id + self.spawn_stats['vehicle_types'][vehicle_type] = \ + self.spawn_stats['vehicle_types'].get(vehicle_type, 0) + 1 + + except Exception as e: self.spawn_stats['failed_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 - pass + Log.debug(f"车辆生成失败: {e}") + # 小延迟以避免过载 if spawned % 3 == 0: time.sleep(0.05) return spawned - def _spawn_vehicles(self): + def _spawn_pedestrians(self, center_location): + """生成行人(增强版)""" blueprint_lib = self.world.get_blueprint_library() - spawn_points = self.world.get_map().get_spawn_points() - if not spawn_points: + num_peds = min(self.config['traffic']['pedestrians'], 30) + spawned = 0 + + # 获取行人类型 + pedestrian_types = self.config['traffic']['pedestrian_types'] + available_types = [pt for pt in pedestrian_types if blueprint_lib.filter(pt)] + + if not available_types: + available_types = list(blueprint_lib.filter('walker.pedestrian.*')) + + if not available_types: + Log.warning("没有可用的行人生成蓝图") return 0 - num_vehicles = min(self.config['traffic']['background_vehicles'], 10) + for i in range(num_peds): + try: + # 选择行人类型 + ped_bp = random.choice(available_types) + + # 根据场景类型调整位置 + scenario_name = self.config['scenario']['name'].lower() + + if 'school' in scenario_name or 'crossing' in scenario_name: + # 学校或人行横道场景:行人在中心区域更密集 + angle = random.uniform(0, 2 * math.pi) + if i < num_peds * 0.7: # 70%的行人在中心区域 + distance = random.uniform(3.0, 10.0) + else: + distance = random.uniform(10.0, 20.0) + else: + # 普通场景 + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(5.0, 25.0) + + # 计算位置 + location = carla.Location( + x=center_location.x + distance * math.cos(angle), + y=center_location.y + distance * math.sin(angle), + z=center_location.z + 0.5 + ) + + # 确保位置在地面上 + waypoint = self.world.get_map().get_waypoint(location) + if waypoint: + location.z = waypoint.transform.location.z + 0.5 + + # 创建行人 + pedestrian = self.world.spawn_actor(ped_bp, carla.Transform(location)) + + # 设置行人控制器 + controller_bp = blueprint_lib.find('controller.ai.walker') + if controller_bp: + controller = self.world.spawn_actor(controller_bp, carla.Transform(), attach_to=pedestrian) + controller.start() + + # 设置目标位置 + target_location = carla.Location( + x=center_location.x + random.uniform(-20, 20), + y=center_location.y + random.uniform(-20, 20), + z=location.z + ) + controller.go_to_location(target_location) + + # 设置速度 + controller.set_max_speed(random.uniform(0.5, 2.0)) + + self.pedestrians.append(pedestrian) + spawned += 1 + + self.spawn_stats['successful_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 + + # 记录类型 + pedestrian_type = pedestrian.type_id + self.spawn_stats['pedestrian_types'][pedestrian_type] = \ + self.spawn_stats['pedestrian_types'].get(pedestrian_type, 0) + 1 + + except Exception as e: + self.spawn_stats['failed_spawns'] += 1 + self.spawn_stats['total_attempts'] += 1 + Log.debug(f"行人生成失败: {e}") + + return spawned + + def _spawn_bicycles(self, center_location): + """生成自行车""" + blueprint_lib = self.world.get_blueprint_library() + + num_bikes = min(self.config['traffic'].get('bicycles', 0), 10) spawned = 0 - for _ in range(num_vehicles): + # 查找自行车蓝图 + bike_bps = list(blueprint_lib.filter('vehicle.bh*')) + list(blueprint_lib.filter('vehicle.diamondback*')) + + if not bike_bps: + Log.debug("没有可用的自行车蓝图") + return 0 + + for i in range(num_bikes): try: - vehicle_bp = random.choice(blueprint_lib.filter('vehicle.*')) - spawn_point = random.choice(spawn_points) - vehicle = self.world.spawn_actor(vehicle_bp, spawn_point) - vehicle.set_autopilot(True) - self.vehicles.append(vehicle) + bike_bp = random.choice(bike_bps) + + # 计算位置(在行人附近) + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(8.0, 15.0) + + location = carla.Location( + x=center_location.x + distance * math.cos(angle), + y=center_location.y + distance * math.sin(angle), + z=center_location.z + 0.3 + ) + + # 确保位置在地面上 + waypoint = self.world.get_map().get_waypoint(location) + if waypoint: + location.z = waypoint.transform.location.z + 0.3 + + # 创建自行车 + rotation = carla.Rotation(0, random.uniform(0, 360), 0) + bicycle = self.world.spawn_actor(bike_bp, carla.Transform(location, rotation)) + + self.bicycles.append(bicycle) spawned += 1 self.spawn_stats['successful_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 - except: + + except Exception as e: self.spawn_stats['failed_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 - pass + Log.debug(f"自行车生成失败: {e}") return spawned - def _spawn_pedestrians(self, center_location): + def _spawn_motorcycles(self, center_location): + """生成摩托车""" blueprint_lib = self.world.get_blueprint_library() - num_peds = min(self.config['traffic']['pedestrians'], 12) # 增加行人数量 + num_motos = min(self.config['traffic'].get('motorcycles', 0), 5) spawned = 0 - for _ in range(num_peds): - try: - ped_bps = list(blueprint_lib.filter('walker.pedestrian.*')) - if not ped_bps: - continue + # 查找摩托车蓝图 + moto_bps = list(blueprint_lib.filter('vehicle.harley-davidson*')) + \ + list(blueprint_lib.filter('vehicle.yamaha*')) + \ + list(blueprint_lib.filter('vehicle.kawasaki*')) - ped_bp = random.choice(ped_bps) + if not moto_bps: + Log.debug("没有可用的摩托车蓝图") + return 0 - # 在学校区域或人行横道场景中,行人更集中 - if self.config.get('scenario', {}).get('name', '').lower() in ['school_zone', 'pedestrian_crossing']: - angle = random.uniform(0, 2 * math.pi) - distance = random.uniform(3.0, 8.0) # 更靠近中心 - else: - angle = random.uniform(0, 2 * math.pi) - distance = random.uniform(5.0, 15.0) + for i in range(num_motos): + try: + moto_bp = random.choice(moto_bps) + + # 计算位置 + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(10.0, 20.0) location = carla.Location( x=center_location.x + distance * math.cos(angle), @@ -512,48 +1165,125 @@ def _spawn_pedestrians(self, center_location): z=center_location.z + 0.5 ) - pedestrian = self.world.spawn_actor(ped_bp, carla.Transform(location)) - self.pedestrians.append(pedestrian) + # 确保位置在地面上 + waypoint = self.world.get_map().get_waypoint(location) + if waypoint: + location.z = waypoint.transform.location.z + 0.5 + + # 创建摩托车 + rotation = carla.Rotation(0, random.uniform(0, 360), 0) + motorcycle = self.world.spawn_actor(moto_bp, carla.Transform(location, rotation)) + motorcycle.set_autopilot(True) + + self.motorcycles.append(motorcycle) spawned += 1 self.spawn_stats['successful_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 + except Exception as e: self.spawn_stats['failed_spawns'] += 1 self.spawn_stats['total_attempts'] += 1 - Log.debug(f"行人生成失败: {e}") + Log.debug(f"摩托车生成失败: {e}") return spawned + def add_pedestrian_safety_features(self, center_location): + """添加行人安全设施""" + features = [] + + try: + # 添加交通锥 + if self.pedestrian_safety_zones: + from scene_manager import SceneManager + cones = SceneManager.spawn_traffic_cones(self.world, center_location, num_cones=8) + features.extend(cones) + + # 添加行人横道标记 + if self.crosswalk_density in ['medium', 'high']: + from scene_manager import SceneManager + crosswalks = SceneManager.spawn_pedestrian_safety_features( + self.world, center_location, 'crosswalk') + features.extend(crosswalks) + + Log.info(f"添加了 {len(features)} 个行人安全设施") + + except Exception as e: + Log.warning(f"添加行人安全设施失败: {e}") + + return features + def cleanup(self): + """清理交通管理器""" Log.info("开始清理交通管理器...") + cleanup_stats = { + 'vehicles_destroyed': 0, + 'pedestrians_destroyed': 0, + 'bicycles_destroyed': 0, + 'motorcycles_destroyed': 0, + 'errors': 0 + } + try: + # 清理行人 for pedestrian in self.pedestrians: try: if pedestrian and pedestrian.is_alive: pedestrian.destroy() + cleanup_stats['pedestrians_destroyed'] += 1 except: - pass + cleanup_stats['errors'] += 1 self.pedestrians.clear() + # 清理自行车 + for bicycle in self.bicycles: + try: + if bicycle and bicycle.is_alive: + bicycle.destroy() + cleanup_stats['bicycles_destroyed'] += 1 + except: + cleanup_stats['errors'] += 1 + + self.bicycles.clear() + + # 清理摩托车 + for motorcycle in self.motorcycles: + try: + if motorcycle and motorcycle.is_alive: + motorcycle.destroy() + cleanup_stats['motorcycles_destroyed'] += 1 + except: + cleanup_stats['errors'] += 1 + + self.motorcycles.clear() + + # 清理车辆 for vehicle in self.vehicles: try: if vehicle and vehicle.is_alive: vehicle.destroy() + cleanup_stats['vehicles_destroyed'] += 1 except: - pass + cleanup_stats['errors'] += 1 self.vehicles.clear() - Log.info("交通管理器清理完成") + Log.info(f"交通管理器清理完成: " + f"车辆{cleanup_stats['vehicles_destroyed']}, " + f"行人{cleanup_stats['pedestrians_destroyed']}, " + f"自行车{cleanup_stats['bicycles_destroyed']}, " + f"摩托车{cleanup_stats['motorcycles_destroyed']}, " + f"错误{cleanup_stats['errors']}") except Exception as e: Log.error(f"清理交通管理器失败: {e}") class SensorManager: + """传感器管理器(增强版)""" + def __init__(self, world, config, data_dir): self.world = world self.config = config @@ -564,56 +1294,99 @@ def __init__(self, world, config, data_dir): self.last_capture_time = 0 self.last_performance_sample = 0 - self.target_fps = config['performance'].get('frame_rate_limit', 5.0) - self.min_frame_interval = 1.0 / self.target_fps if self.target_fps > 0 else 0.1 + # 帧率控制 + self.target_fps = config['performance'].get('frame_rate_limit', 8.0) + self.min_frame_interval = 1.0 / self.target_fps if self.target_fps > 0 else 0.125 self.last_frame_time = 0 self.frame_skip_count = 0 - self.max_frame_skip = 2 + self.max_frame_skip = 3 + # 数据缓冲 self.vehicle_buffer = {} self.infra_buffer = {} - self.buffer_lock = threading.Lock() + self.buffer_lock = threading.RLock() + # 状态控制 self.is_running = True + self.is_paused = False - self.performance_monitor = PerformanceMonitor() + # 性能监控 + self.performance_monitor = PerformanceMonitor(config) + # 处理器 self.image_processor = ImageProcessor(data_dir, config.get('image_processing', {})) self.lidar_processor = None self.fusion_manager = None - self.batch_size = config['performance'].get('batch_size', 5) - self.enable_async_processing = config.get('enable_async_processing', True) + # 配置参数 + self.batch_size = config['performance'].get('batch_size', 8) + self.enable_async_processing = config['performance'].get('enable_async_processing', True) + self.max_workers = config['performance'].get('max_workers', 4) + # LiDAR处理 if config['sensors'].get('lidar_sensors', 0) > 0: - self.lidar_processor = LidarProcessor(data_dir, config['performance'].get('lidar_processing', {})) + lidar_config = config['performance'].get('lidar_processing', {}) + self.lidar_processor = LidarProcessor(data_dir, lidar_config) + # 融合处理 if config['output'].get('save_fusion', False): - self.fusion_manager = MultiSensorFusion(data_dir, config['performance'].get('fusion', {})) + fusion_config = config['performance'].get('fusion', {}) + self.fusion_manager = MultiSensorFusion(data_dir, fusion_config) + # 统计 self.sensor_stats = { 'total_images': 0, 'total_lidar_frames': 0, 'image_capture_times': [], - 'lidar_processing_times': [] + 'lidar_processing_times': [], + 'sensor_errors': 0, + 'dropped_frames': 0 } def setup_cameras(self, vehicle, center_location, vehicle_id=0): + """设置摄像头(增强版)""" vehicle_cams = self._setup_vehicle_cameras(vehicle, vehicle_id) infra_cams = self._setup_infrastructure_cameras(center_location) - Log.info(f"摄像头: {vehicle_cams}车辆 + {infra_cams}基础设施") + Log.info(f"摄像头设置完成: {vehicle_cams}车辆摄像头 + {infra_cams}基础设施摄像头") return vehicle_cams + infra_cams def _setup_vehicle_cameras(self, vehicle, vehicle_id): + """设置车辆摄像头""" if not vehicle: return 0 camera_configs = { - 'front_wide': {'loc': (2.0, 0, 1.8), 'rot': (0, -3, 0), 'fov': 100}, - 'front_narrow': {'loc': (2.0, 0, 1.6), 'rot': (0, 0, 0), 'fov': 60}, - 'right_side': {'loc': (0.5, 1.0, 1.5), 'rot': (0, -2, 45), 'fov': 90}, - 'left_side': {'loc': (0.5, -1.0, 1.5), 'rot': (0, -2, -45), 'fov': 90} + 'front_wide': { + 'loc': (2.0, 0, 1.8), + 'rot': (0, -3, 0), + 'fov': 120, + 'description': '前视广角摄像头' + }, + 'front_narrow': { + 'loc': (2.0, 0, 1.6), + 'rot': (0, 0, 0), + 'fov': 60, + 'description': '前视窄角摄像头' + }, + 'right_side': { + 'loc': (0.5, 1.0, 1.5), + 'rot': (0, -2, 90), + 'fov': 100, + 'description': '右侧摄像头' + }, + 'left_side': { + 'loc': (0.5, -1.0, 1.5), + 'rot': (0, -2, -90), + 'fov': 100, + 'description': '左侧摄像头' + }, + 'rear': { + 'loc': (-1.5, 0, 1.7), + 'rot': (0, -5, 180), + 'fov': 100, + 'description': '后视摄像头' + } } installed = 0 @@ -624,11 +1397,38 @@ def _setup_vehicle_cameras(self, vehicle, vehicle_id): return installed def _setup_infrastructure_cameras(self, center_location): + """设置基础设施摄像头""" camera_configs = [ - {'name': 'north', 'offset': (0, -20, 12), 'rotation': (0, -25, 180)}, - {'name': 'south', 'offset': (0, 20, 12), 'rotation': (0, -25, 0)}, - {'name': 'east', 'offset': (20, 0, 12), 'rotation': (0, -25, -90)}, - {'name': 'west', 'offset': (-20, 0, 12), 'rotation': (0, -25, 90)} + { + 'name': 'north', + 'offset': (0, -25, 15), + 'rotation': (0, -30, 180), + 'description': '北向路口摄像头' + }, + { + 'name': 'south', + 'offset': (0, 25, 15), + 'rotation': (0, -30, 0), + 'description': '南向路口摄像头' + }, + { + 'name': 'east', + 'offset': (25, 0, 15), + 'rotation': (0, -30, -90), + 'description': '东向路口摄像头' + }, + { + 'name': 'west', + 'offset': (-25, 0, 15), + 'rotation': (0, -30, 90), + 'description': '西向路口摄像头' + }, + { + 'name': 'overhead', + 'offset': (0, 0, 30), + 'rotation': (-90, 0, 0), + 'description': '俯视摄像头' + } ] installed = 0 @@ -640,7 +1440,8 @@ def _setup_infrastructure_cameras(self, center_location): center_location.z + cam_config['offset'][2] ), 'rot': cam_config['rotation'], - 'fov': 90 + 'fov': 90, + 'description': cam_config['description'] } if self._create_camera(cam_config['name'], sensor_config, None, 'infrastructure'): @@ -649,6 +1450,7 @@ def _setup_infrastructure_cameras(self, center_location): return installed def setup_lidar(self, vehicle, vehicle_id=0): + """设置LiDAR传感器""" if not vehicle or not self.config['sensors'].get('lidar_sensors', 0) > 0: return 0 @@ -656,40 +1458,54 @@ def setup_lidar(self, vehicle, vehicle_id=0): blueprint_lib = self.world.get_blueprint_library() lidar_bp = blueprint_lib.find('sensor.lidar.ray_cast') + if not lidar_bp: + Log.warning("未找到LiDAR传感器蓝图") + return 0 + lidar_config = self.config['sensors'].get('lidar_config', {}) + # 设置LiDAR参数 lidar_bp.set_attribute('channels', str(lidar_config.get('channels', 32))) lidar_bp.set_attribute('range', str(lidar_config.get('range', 100))) - lidar_bp.set_attribute('points_per_second', str(lidar_config.get('points_per_second', 56000))) + lidar_bp.set_attribute('points_per_second', str(lidar_config.get('points_per_second', 100000))) lidar_bp.set_attribute('rotation_frequency', str(lidar_config.get('rotation_frequency', 10))) - lidar_bp.set_attribute('upper_fov', '10') - lidar_bp.set_attribute('lower_fov', '-20') + # 设置视野 + lidar_bp.set_attribute('upper_fov', str(lidar_config.get('upper_fov', 15))) + lidar_bp.set_attribute('lower_fov', str(lidar_config.get('lower_fov', -25))) lidar_bp.set_attribute('horizontal_fov', '360') + # 设置位置和方向 lidar_location = carla.Location(x=0, y=0, z=2.5) lidar_rotation = carla.Rotation(0, 0, 0) lidar_transform = carla.Transform(lidar_location, lidar_rotation) + # 生成LiDAR传感器 lidar_sensor = self.world.spawn_actor(lidar_bp, lidar_transform, attach_to=vehicle) def lidar_callback(lidar_data): - if not self.is_running: + """LiDAR数据回调""" + if not self.is_running or self.is_paused: return try: current_time = time.time() frame_start_time = time.time() + # 检查采集间隔 if current_time - self.last_capture_time >= self.config['sensors']['capture_interval']: if self.lidar_processor: try: start_process = time.time() + + # 处理LiDAR数据 metadata = self.lidar_processor.process_lidar_data(lidar_data, self.frame_counter) + process_time = time.time() - start_process self.sensor_stats['lidar_processing_times'].append(process_time) self.sensor_stats['total_lidar_frames'] += 1 + # 创建融合文件 if metadata and self.fusion_manager: vehicle_image_path = None with self.buffer_lock: @@ -706,21 +1522,28 @@ def lidar_callback(lidar_data): if vehicle_image_path: sensor_data['camera'] = vehicle_image_path - self.fusion_manager.create_synchronization_file(self.frame_counter, sensor_data) + self.fusion_manager.create_synchronization_file( + self.frame_counter, sensor_data) + except Exception as e: + self.sensor_stats['sensor_errors'] += 1 if self.is_running: Log.error(f"LiDAR处理失败: {e}") + # 记录帧时间 frame_time = time.time() - frame_start_time self.performance_monitor.record_frame_time(frame_time) + except Exception as e: + self.sensor_stats['sensor_errors'] += 1 if self.is_running: Log.error(f"LiDAR回调错误: {e}") + # 开始监听 lidar_sensor.listen(lidar_callback) self.sensors.append(lidar_sensor) - Log.info("LiDAR传感器已安装") + Log.info(f"LiDAR传感器已安装: {lidar_bp.id}, 通道数: {lidar_config.get('channels', 32)}") return 1 except Exception as e: @@ -728,23 +1551,37 @@ def lidar_callback(lidar_data): return 0 def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): + """创建摄像头""" try: blueprint = self.world.get_blueprint_library().find('sensor.camera.rgb') + if not blueprint: + Log.warning(f"未找到摄像头蓝图: sensor.camera.rgb") + return False + + # 设置摄像头参数 img_size = self.config['sensors'].get('image_size', [1280, 720]) blueprint.set_attribute('image_size_x', str(img_size[0])) blueprint.set_attribute('image_size_y', str(img_size[1])) blueprint.set_attribute('fov', str(config.get('fov', 90))) + # 设置后处理效果 + camera_config = self.config['sensors'].get('camera_config', {}) + if camera_config.get('post_processing') == 'semantic': + blueprint.set_attribute('enable_postprocess_effects', 'True') + + # 设置位置和方向 location = carla.Location(config['loc'][0], config['loc'][1], config['loc'][2]) rotation = carla.Rotation(config['rot'][0], config['rot'][1], config['rot'][2]) transform = carla.Transform(location, rotation) + # 生成摄像头 if parent: camera = self.world.spawn_actor(blueprint, transform, attach_to=parent) else: camera = self.world.spawn_actor(blueprint, transform) + # 创建保存目录 if sensor_type == 'vehicle' and vehicle_id > 0: save_dir = os.path.join(self.data_dir, "raw", f"vehicle_{vehicle_id}", name) else: @@ -752,10 +1589,13 @@ def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): os.makedirs(save_dir, exist_ok=True) + # 创建回调函数 callback = self._create_callback(save_dir, name, sensor_type, vehicle_id) camera.listen(callback) self.sensors.append(camera) + + Log.debug(f"摄像头创建成功: {name} ({sensor_type}), 位置: {location}") return True except Exception as e: @@ -763,31 +1603,37 @@ def _create_camera(self, name, config, parent, sensor_type, vehicle_id=0): return False def _create_callback(self, save_dir, name, sensor_type, vehicle_id=0): + """创建回调函数""" capture_interval = self.config['sensors']['capture_interval'] def callback(image): - if not self.is_running: + """摄像头数据回调""" + if not self.is_running or self.is_paused: return try: current_time = time.time() frame_start_time = time.time() + # 帧率控制 time_since_last_frame = current_time - self.last_frame_time if time_since_last_frame < self.min_frame_interval: self.frame_skip_count += 1 if self.frame_skip_count > self.max_frame_skip: self.frame_skip_count = 0 else: + self.sensor_stats['dropped_frames'] += 1 return else: self.frame_skip_count = 0 + # 检查采集间隔 if current_time - self.last_capture_time >= capture_interval: self.frame_counter += 1 self.last_capture_time = current_time self.last_frame_time = current_time + # 保存图像 capture_start = time.time() filename = os.path.join(save_dir, f"{name}_{self.frame_counter:06d}.png") image.save_to_disk(filename, carla.ColorConverter.Raw) @@ -796,103 +1642,142 @@ def callback(image): self.sensor_stats['image_capture_times'].append(capture_time) self.sensor_stats['total_images'] += 1 + # 缓冲图像路径 with self.buffer_lock: if sensor_type == 'vehicle': self.vehicle_buffer[name] = filename + + # 检查是否触发拼接 if len(self.vehicle_buffer) >= 4: - if self.enable_async_processing: - import concurrent.futures - with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: - future = executor.submit( - self.image_processor.stitch, - self.vehicle_buffer.copy(), - self.frame_counter, - f'vehicle_{vehicle_id}' - ) - else: - self.image_processor.stitch(self.vehicle_buffer, self.frame_counter, - f'vehicle_{vehicle_id}') + self._trigger_stitching(self.vehicle_buffer.copy(), + self.frame_counter, + f'vehicle_{vehicle_id}') self.vehicle_buffer.clear() else: self.infra_buffer[name] = filename + + # 检查是否触发拼接 if len(self.infra_buffer) >= 4: - if self.enable_async_processing: - import concurrent.futures - with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor: - future = executor.submit( - self.image_processor.stitch, - self.infra_buffer.copy(), - self.frame_counter, - 'infrastructure' - ) - else: - self.image_processor.stitch(self.infra_buffer, self.frame_counter, 'infrastructure') + self._trigger_stitching(self.infra_buffer.copy(), + self.frame_counter, + 'infrastructure') self.infra_buffer.clear() + # 性能监控 if current_time - self.last_performance_sample >= 5.0: memory_info = self.performance_monitor.sample_memory() cpu_info = self.performance_monitor.sample_cpu() - if self.frame_counter % 10 == 0: - Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " + if self.frame_counter % 20 == 0: + Log.performance(f"系统监控 - " + f"内存: {memory_info['process_mb']:.1f}MB, " f"CPU: {cpu_info['total_percent']:.1f}%, " - f"线程数: {threading.active_count()}") + f"线程数: {threading.active_count()}, " + f"帧数: {self.frame_counter}") self.last_performance_sample = current_time + # 记录帧时间 frame_time = time.time() - frame_start_time self.performance_monitor.record_frame_time(frame_time) + # 定期垃圾回收 if self.frame_counter % 50 == 0: gc.collect() + # 报告传感器统计 if self.sensor_stats['total_images'] > 0: - avg_capture_time = np.mean(self.sensor_stats['image_capture_times'][-100:]) if len( - self.sensor_stats['image_capture_times']) > 0 else 0 - Log.performance(f"传感器统计: 图像{self.sensor_stats['total_images']}张, " - f"平均捕获时间{avg_capture_time:.3f}秒") + avg_capture_time = np.mean(self.sensor_stats['image_capture_times'][-100:]) \ + if len(self.sensor_stats['image_capture_times']) > 0 else 0 + Log.performance(f"传感器统计: " + f"图像{self.sensor_stats['total_images']}张, " + f"平均捕获时间{avg_capture_time:.3f}秒, " + f"错误{self.sensor_stats['sensor_errors']}个") + except Exception as e: + self.sensor_stats['sensor_errors'] += 1 if self.is_running: Log.error(f"传感器回调错误: {e}") return callback + def _trigger_stitching(self, image_buffer, frame_num, view_type): + """触发图像拼接""" + if self.enable_async_processing: + try: + from concurrent.futures import ThreadPoolExecutor + + # 使用线程池异步处理 + with ThreadPoolExecutor(max_workers=min(2, self.max_workers)) as executor: + future = executor.submit( + self.image_processor.stitch, + image_buffer, + frame_num, + view_type + ) + # 可以在这里添加回调处理结果 + except: + # 异步处理失败,回退到同步处理 + self.image_processor.stitch(image_buffer, frame_num, view_type) + else: + # 同步处理 + self.image_processor.stitch(image_buffer, frame_num, view_type) + def get_frame_count(self): + """获取帧计数""" return self.frame_counter + def pause(self): + """暂停传感器""" + self.is_paused = True + + def resume(self): + """恢复传感器""" + self.is_paused = False + def generate_sensor_summary(self): + """生成传感器摘要""" summary = { 'total_sensors': len(self.sensors), 'frame_count': self.frame_counter, 'lidar_data': None, 'fusion_data': None, 'performance': self.performance_monitor.get_performance_summary(), - 'sensor_stats': self.sensor_stats + 'sensor_stats': self.sensor_stats, + 'image_processor_stats': self.image_processor.get_stats() } + # 添加图像捕获统计 if self.sensor_stats['image_capture_times']: - summary['sensor_stats']['avg_image_capture_time'] = np.mean(self.sensor_stats['image_capture_times']) - summary['sensor_stats']['max_image_capture_time'] = np.max(self.sensor_stats['image_capture_times']) + summary['sensor_stats']['avg_image_capture_time'] = \ + np.mean(self.sensor_stats['image_capture_times']) + summary['sensor_stats']['max_image_capture_time'] = \ + max(self.sensor_stats['image_capture_times']) + # 添加LiDAR处理统计 if self.sensor_stats['lidar_processing_times']: - summary['sensor_stats']['avg_lidar_process_time'] = np.mean(self.sensor_stats['lidar_processing_times']) - summary['sensor_stats']['max_lidar_process_time'] = np.max(self.sensor_stats['lidar_processing_times']) + summary['sensor_stats']['avg_lidar_process_time'] = \ + np.mean(self.sensor_stats['lidar_processing_times']) + summary['sensor_stats']['max_lidar_process_time'] = \ + max(self.sensor_stats['lidar_processing_times']) + # LiDAR数据摘要 if self.lidar_processor: summary['lidar_data'] = self.lidar_processor.generate_lidar_summary() + # 融合数据摘要 if self.fusion_manager: summary['fusion_data'] = self.fusion_manager.generate_fusion_report() - summary['image_processor_stats'] = self.image_processor.get_stats() - return summary def cleanup(self): + """清理传感器""" Log.info(f"安全清理 {len(self.sensors)} 个传感器...") self.is_running = False + # 停止所有传感器 for sensor in self.sensors: try: if hasattr(sensor, 'stop'): @@ -903,64 +1788,48 @@ def cleanup(self): time.sleep(0.2) + # 刷新LiDAR批处理数据 if self.lidar_processor: try: self.lidar_processor.flush_batch() + self.lidar_processor.cleanup() except: pass + # 销毁传感器 for i, sensor in enumerate(self.sensors): try: if hasattr(sensor, 'destroy'): sensor.destroy() except: pass + if i % 5 == 0: time.sleep(0.01) self.sensors.clear() + # 清理图像缓存 if hasattr(self.image_processor, 'image_cache'): try: self.image_processor.image_cache.clear() except: pass - self.vehicle_buffer.clear() - self.infra_buffer.clear() + # 清理数据缓冲 + with self.buffer_lock: + self.vehicle_buffer.clear() + self.infra_buffer.clear() + # 垃圾回收 gc.collect() Log.info("传感器清理完成") -class V2XCommunication: - def __init__(self, config): - self.config = config - self.nodes = {} - self.messages = [] - - def register_node(self, node_id, position, capabilities): - self.nodes[node_id] = { - 'position': position, - 'capabilities': capabilities, - 'last_update': time.time() - } - - def broadcast_basic_safety_message(self, sender_id, vehicle_data): - pass - - def get_messages_for_node(self, node_id): - return [] - - def get_network_status(self): - return {'nodes': len(self.nodes), 'messages': len(self.messages)} - - def stop(self): - pass - - class DataCollector: + """数据收集器(增强版)""" + def __init__(self, config): self.config = config self.client = None @@ -968,23 +1837,36 @@ def __init__(self, config): self.ego_vehicles = [] self.scene_center = None + # 设置输出目录 self.setup_directories() + # 管理器 self.traffic_manager = None self.sensor_managers = {} self.multi_vehicle_manager = None self.v2x_communication = None self.safety_monitor = None + self.scene_manager = None + # 状态 self.start_time = None self.is_running = False self.collected_frames = 0 - self.performance_monitor = PerformanceMonitor() + # 性能监控 + self.performance_monitor = PerformanceMonitor(config) + + # 紧急处理 + self.emergency_handler = EmergencyHandler(self) + # 输出格式 self.output_format = config.get('output_format', 'standard') + # 行人安全增强 + self.pedestrian_safety_mode = config['scenario'].get('pedestrian_safety_mode', True) + def setup_directories(self): + """设置输出目录""" scenario = self.config['scenario'] timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") @@ -993,6 +1875,7 @@ def setup_directories(self): f"{scenario['name']}_{scenario['town']}_{timestamp}" ) + # 创建必要目录 directories = [ "raw/vehicle_1", "raw/vehicle_2", @@ -1001,12 +1884,15 @@ def setup_directories(self): "lidar", "fusion", "calibration", - "cooperative", - "v2x_messages", + "cooperative/v2x_messages", + "cooperative/shared_perception", "v2xformer_format", "kitti_format", "metadata", - "safety_reports" + "safety_reports", + "risk_maps", + "emergency_events", + "enhanced" ] for subdir in directories: @@ -1015,54 +1901,72 @@ def setup_directories(self): Log.info(f"数据目录: {self.output_dir}") def connect(self): + """连接到CARLA服务器""" for attempt in range(1, 6): try: self.client = carla.Client('localhost', 2000) - self.client.set_timeout(10.0) + self.client.set_timeout(15.0) town = self.config['scenario']['town'] self.world = self.client.load_world(town) + # 设置世界参数 settings = self.world.get_settings() settings.synchronous_mode = False + settings.fixed_delta_seconds = 0.05 self.world.apply_settings(settings) - Log.info(f"连接成功: {town}") + Log.info(f"连接成功: {town} (尝试 {attempt}/5)") return True except Exception as e: - Log.warning(f"连接尝试 {attempt}/5 失败: {str(e)[:50]}") - time.sleep(2) + Log.warning(f"连接尝试 {attempt}/5 失败: {str(e)[:100]}") + time.sleep(3) return False def setup_scene(self): + """设置场景(增强版)""" + # 设置天气 weather_cfg = self.config['scenario'] weather = WeatherSystem.create_weather(weather_cfg['weather'], weather_cfg['time_of_day']) self.world.set_weather(weather) Log.info(f"天气: {weather_cfg['weather']}, 时间: {weather_cfg['time_of_day']}") + # 获取场景中心 spawn_points = self.world.get_map().get_spawn_points() if spawn_points: self.scene_center = spawn_points[len(spawn_points) // 2].location else: self.scene_center = carla.Location(0, 0, 0) + # 初始化交通管理器 self.traffic_manager = TrafficManager(self.world, self.config) + # 生成主车 num_ego_vehicles = min(self.config['cooperative'].get('num_coop_vehicles', 2) + 1, 3) for i in range(num_ego_vehicles): ego_vehicle = self.traffic_manager.spawn_ego_vehicle() if ego_vehicle: self.ego_vehicles.append(ego_vehicle) Log.info(f"主车 {i + 1} 生成: {ego_vehicle.type_id}") + else: + Log.warning(f"主车 {i + 1} 生成失败") if not self.ego_vehicles: - Log.error("主车生成失败") + Log.error("没有主车生成成功") return False - self.traffic_manager.spawn_traffic(self.scene_center) + # 生成交通 + traffic_count = self.traffic_manager.spawn_traffic(self.scene_center) + Log.info(f"生成交通: {traffic_count} 个对象") + # 添加行人安全设施 + if self.pedestrian_safety_mode: + safety_features = self.traffic_manager.add_pedestrian_safety_features(self.scene_center) + Log.info(f"添加行人安全设施: {len(safety_features)} 个") + + # 初始化V2X通信 if self.config['v2x']['enabled']: self.v2x_communication = V2XCommunication(self.config['v2x']) @@ -1071,9 +1975,10 @@ def setup_scene(self): self.v2x_communication.register_node( f'vehicle_{vehicle.id}', (location.x, location.y, location.z), - {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} + {'type': 'vehicle', 'capabilities': ['bsm', 'rsm', 'emergency_brake']} ) + # 初始化多车辆管理器 self.multi_vehicle_manager = MultiVehicleManager( self.world, self.config, @@ -1082,9 +1987,12 @@ def setup_scene(self): self.multi_vehicle_manager.ego_vehicles = self.ego_vehicles + # 生成协同车辆 num_coop_vehicles = self.config['cooperative'].get('num_coop_vehicles', 2) coop_vehicles = self.multi_vehicle_manager.spawn_cooperative_vehicles(num_coop_vehicles) + Log.info(f"生成协同车辆: {len(coop_vehicles)} 辆") + # 注册V2X节点 if self.v2x_communication: for vehicle in coop_vehicles: location = vehicle.get_location() @@ -1094,21 +2002,32 @@ def setup_scene(self): {'type': 'vehicle', 'capabilities': ['bsm', 'rsm']} ) + # 初始化行人安全监控器 self.safety_monitor = PedestrianSafetyMonitor(self.world, self.output_dir) - time.sleep(3.0) + # 初始化场景管理器 + self.scene_manager = SceneManager() + + # 等待场景稳定 + Log.info("等待场景稳定...") + time.sleep(5.0) + return True def setup_sensors(self): + """设置传感器(增强版)""" for i, vehicle in enumerate(self.ego_vehicles): sensor_manager = SensorManager(self.world, self.config, self.output_dir) + # 设置摄像头 cameras = sensor_manager.setup_cameras(vehicle, self.scene_center, i + 1) if cameras == 0: Log.error(f"车辆 {i + 1} 没有摄像头安装成功") return False + # 设置LiDAR lidars = sensor_manager.setup_lidar(vehicle, i + 1) + Log.info(f"车辆 {i + 1} 传感器: {cameras}摄像头 + {lidars}LiDAR") self.sensor_managers[vehicle.id] = sensor_manager @@ -1116,12 +2035,14 @@ def setup_sensors(self): return True def collect_data(self): + """收集数据(增强版)""" duration = self.config['scenario']['duration'] Log.info(f"开始数据收集,时长: {duration}秒") self.start_time = time.time() self.is_running = True + # 计时器 last_update = time.time() last_v2x_update = time.time() last_perception_share = time.time() @@ -1129,10 +2050,13 @@ def collect_data(self): last_detailed_log = time.time() last_memory_check = time.time() last_safety_check = time.time() + last_weather_change = time.time() + # 状态标志 memory_warning_issued = False early_stop_triggered = False + # 内存阈值 memory_warning_threshold = 350 memory_critical_threshold = 400 early_stop_threshold = 450 @@ -1142,25 +2066,34 @@ def collect_data(self): current_time = time.time() elapsed = current_time - self.start_time - if current_time - last_memory_check >= 2.0: + # 检查紧急停止 + if self.emergency_handler.check_emergency(): + Log.critical("检测到紧急情况,执行紧急停止...") + self.emergency_handler.emergency_cleanup() + early_stop_triggered = True + break + + # 内存监控 + if current_time - last_memory_check >= 3.0: try: import psutil process = psutil.Process() memory_mb = process.memory_info().rss / (1024 * 1024) if memory_mb > early_stop_threshold: - Log.error( - f"内存使用超过临界值({early_stop_threshold}MB): {memory_mb:.1f}MB,提前结束数据收集") + Log.critical(f"内存使用超过临界值({early_stop_threshold}MB): {memory_mb:.1f}MB") early_stop_triggered = True break elif memory_mb > memory_critical_threshold: - Log.warning(f"内存使用严重过高: {memory_mb:.1f}MB,进行强制清理") - self._force_memory_cleanup() - memory_warning_issued = True - elif memory_mb > memory_warning_threshold and not memory_warning_issued: - Log.warning(f"内存使用较高: {memory_mb:.1f}MB,减少数据处理") - memory_warning_issued = True - elif memory_mb < memory_warning_threshold: + if not memory_warning_issued: + Log.warning(f"内存使用严重过高: {memory_mb:.1f}MB") + self._force_memory_cleanup() + memory_warning_issued = True + elif memory_mb > memory_warning_threshold: + if not memory_warning_issued: + Log.warning(f"内存使用较高: {memory_mb:.1f}MB") + memory_warning_issued = True + elif memory_mb < memory_warning_threshold * 0.8: memory_warning_issued = False except Exception as e: @@ -1168,14 +2101,17 @@ def collect_data(self): last_memory_check = current_time + # 更新车辆状态 if self.multi_vehicle_manager: self.multi_vehicle_manager.update_vehicle_states() - v2x_interval = self.config['v2x'].get('update_interval', 2.0) + # V2X通信更新 + v2x_interval = self.config['v2x'].get('update_interval', 1.0) if self.v2x_communication and current_time - last_v2x_update >= v2x_interval: self._update_v2x_communication() last_v2x_update = current_time + # 协同感知共享 if (not memory_warning_issued and self.config['cooperative'].get('enable_shared_perception', True) and current_time - last_perception_share >= 2.0): @@ -1185,47 +2121,69 @@ def collect_data(self): # 行人安全检查 if current_time - last_safety_check >= 1.0 and self.safety_monitor: safety_report = self.safety_monitor.check_pedestrian_safety() + + # 高风险情况处理 if safety_report['risk_distribution']['high'] > 0: Log.safety(f"行人安全警告: {safety_report['risk_distribution']['high']}个高风险情况") - # 广播行人警告 self._broadcast_pedestrian_warnings(safety_report) + + # 临界情况紧急处理 + if safety_report['risk_distribution']['critical'] > 0: + Log.safety(f"行人安全紧急警告: {safety_report['risk_distribution']['critical']}个临界情况") + self._handle_critical_safety_situation(safety_report) + last_safety_check = current_time + # 动态天气变化 + if current_time - last_weather_change >= 30.0: + self._update_dynamic_weather() + last_weather_change = current_time + + # 性能监控 if current_time - last_performance_sample >= 10.0: memory_info = self.performance_monitor.sample_memory() cpu_info = self.performance_monitor.sample_cpu() if current_time - last_detailed_log >= 60.0: - Log.performance(f"详细性能监控:") + Log.performance("详细性能监控:") Log.performance(f" 进程内存: {memory_info['process_mb']:.1f}MB") Log.performance(f" 系统内存: {memory_info['system_used_percent']:.1f}%使用率") Log.performance(f" CPU: {cpu_info['total_percent']:.1f}% ({cpu_info['count']}核心)") + Log.performance(f" 总帧数: {self.collected_frames}") last_detailed_log = current_time else: - Log.performance(f"系统监控 - 内存: {memory_info['process_mb']:.1f}MB, " + Log.performance(f"系统监控 - " + f"内存: {memory_info['process_mb']:.1f}MB, " f"CPU: {cpu_info['total_percent']:.1f}%, " - f"活跃线程: {threading.active_count()}") + f"活跃线程: {threading.active_count()}, " + f"帧数: {self.collected_frames}") last_performance_sample = current_time + # 垃圾回收 gc.collect() - if current_time - last_update >= 5.0: + # 进度更新 + if current_time - last_update >= 10.0: total_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) + self.collected_frames = total_frames progress = (elapsed / duration) * 100 if total_frames > 0: frames_per_second = total_frames / elapsed - remaining_frames = (duration - elapsed) * frames_per_second - eta_seconds = (duration - elapsed) + remaining_time = (duration - elapsed) + eta_minutes = remaining_time / 60 else: - eta_seconds = duration - elapsed + remaining_time = duration - elapsed + eta_minutes = remaining_time / 60 Log.info(f"进度: {elapsed:.0f}/{duration}秒 ({progress:.1f}%) | " f"总帧数: {total_frames} | " - f"ETA: {eta_seconds:.0f}秒") + f"帧率: {frames_per_second:.1f} FPS | " + f"剩余: {eta_minutes:.1f}分钟") last_update = current_time + # 短暂休眠以减少CPU使用 time.sleep(0.01) except KeyboardInterrupt: @@ -1237,10 +2195,10 @@ def collect_data(self): self.is_running = False elapsed = time.time() - self.start_time + # 更新收集的帧数 self.collected_frames = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) if self.collected_frames > 0: - total_frames_from_sensors = self.collected_frames performance_summary = self.performance_monitor.get_performance_summary() if early_stop_triggered: @@ -1248,67 +2206,163 @@ def collect_data(self): else: Log.info(f"收集完成: {self.collected_frames}帧, 用时: {elapsed:.1f}秒") - fps = total_frames_from_sensors / max(elapsed, 0.1) + fps = self.collected_frames / max(elapsed, 0.1) Log.info(f"平均帧率: {fps:.2f} FPS") - Log.info(f"最大内存使用: {performance_summary['max_memory_mb']:.1f} MB") - Log.info(f"平均CPU使用: {performance_summary['average_cpu_percent']:.1f}%") + Log.info(f"最大内存使用: {performance_summary['memory_statistics']['max_memory_mb']:.1f} MB") + Log.info(f"平均CPU使用: {performance_summary['cpu_statistics']['average_cpu_percent']:.1f}%") # 生成行人安全报告 if self.safety_monitor: final_report = self.safety_monitor.generate_final_report() - Log.safety( - f"行人安全报告: {final_report['risk_distribution']['high']}高风险, {final_report['risk_distribution']['medium']}中风险") - Log.safety(f"行人安全评分: {final_report['safety_score']:.1f}/100") + Log.safety(f"行人安全最终报告:") + Log.safety(f" 高风险: {final_report['risk_distribution']['high']}次") + Log.safety(f" 临界风险: {final_report['risk_distribution']['critical']}次") + Log.safety(f" 安全评分: {final_report['safety_score']:.1f}/100") else: Log.warning("未收集到任何数据帧") + # 保存元数据和生成摘要 self._save_metadata() self._print_summary() + # 数据格式转换 if self.output_format != 'standard': self._convert_to_target_format() def _broadcast_pedestrian_warnings(self, safety_report): - """广播行人警告""" + """广播行人警告(增强版)""" if not self.multi_vehicle_manager: return - # 检查高风险交互 - if safety_report.get('risk_distribution', {}).get('high', 0) > 0: - for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + high_risk_count = safety_report.get('risk_distribution', {}).get('high', 0) + critical_count = safety_report.get('risk_distribution', {}).get('critical', 0) + + if high_risk_count > 0 or critical_count > 0: + # 获取所有车辆 + all_vehicles = self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles + + for vehicle in all_vehicles: if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue try: location = vehicle.get_location() velocity = vehicle.get_velocity() - speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) + speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) * 3.6 # km/h - # 模拟行人位置(实际应用中应从感知系统获取) - pedestrian_location = ( - location.x + random.uniform(-5, 5), - location.y + random.uniform(-5, 5), - location.z - ) + # 查找附近的潜在行人(模拟) + nearby_pedestrians = [] - distance = math.sqrt( - (location.x - pedestrian_location[0]) ** 2 + - (location.y - pedestrian_location[1]) ** 2 - ) + # 模拟检测:随机生成行人位置 + for _ in range(random.randint(0, 3)): + angle = random.uniform(0, 2 * math.pi) + distance = random.uniform(5.0, 25.0) - if distance < 20.0: # 只广播近距离行人 - self.multi_vehicle_manager.share_pedestrian_warning( - vehicle.id, - pedestrian_location, - distance, - speed + pedestrian_location = ( + location.x + distance * math.cos(angle), + location.y + distance * math.sin(angle), + location.z ) + + # 计算距离和相对速度 + actual_distance = math.sqrt( + (location.x - pedestrian_location[0]) ** 2 + + (location.y - pedestrian_location[1]) ** 2 + ) + + if actual_distance < 30.0: # 只广播近距离行人 + # 评估风险 + if actual_distance < 5.0: + risk_level = 'critical' + elif actual_distance < 10.0: + risk_level = 'high' + elif actual_distance < 20.0: + risk_level = 'medium' + else: + risk_level = 'low' + + nearby_pedestrians.append({ + 'location': pedestrian_location, + 'distance': actual_distance, + 'risk_level': risk_level + }) + + # 广播警告 + for pedestrian in nearby_pedestrians: + if pedestrian['risk_level'] in ['high', 'critical']: + self.multi_vehicle_manager.share_pedestrian_warning( + vehicle.id, + pedestrian['location'], + pedestrian['distance'], + speed, + pedestrian_id=random.randint(1000, 9999) + ) + + except Exception as e: + Log.debug(f"广播行人警告失败: {e}") + + def _handle_critical_safety_situation(self, safety_report): + """处理临界安全情况""" + critical_count = safety_report.get('risk_distribution', {}).get('critical', 0) + + if critical_count > 0: + Log.safety("⚠ 检测到临界安全情况,执行紧急措施") + + # 1. 向所有车辆发送紧急制动警告 + if self.v2x_communication: + for vehicle in self.ego_vehicles: + try: + location = vehicle.get_location() + warning_data = { + 'type': 'emergency_brake', + 'location': (location.x, location.y, location.z), + 'severity': 'critical', + 'reason': 'pedestrian_critical_risk', + 'timestamp': time.time() + } + + self.v2x_communication.broadcast_roadside_safety_message( + f'emergency_system', + warning_data + ) + except: + pass + + # 2. 降低车辆速度 + for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + try: + if hasattr(vehicle, 'is_alive') and vehicle.is_alive: + control = carla.VehicleControl() + control.throttle = 0.0 + control.brake = 0.5 # 轻度制动 + vehicle.apply_control(control) except: pass + # 3. 记录紧急事件 + emergency_event = { + 'timestamp': datetime.now().isoformat(), + 'type': 'pedestrian_critical_risk', + 'critical_count': critical_count, + 'safety_report': safety_report, + 'actions_taken': ['v2x_warning', 'speed_reduction'] + } + + emergency_dir = os.path.join(self.output_dir, "emergency_events") + os.makedirs(emergency_dir, exist_ok=True) + + event_file = os.path.join(emergency_dir, f"emergency_{int(time.time())}.json") + try: + with open(event_file, 'w', encoding='utf-8') as f: + json.dump(emergency_event, f, indent=2) + except: + pass + def _force_memory_cleanup(self): + """强制内存清理""" Log.info("执行强制内存清理...") + # 清理图像缓存 for sensor_manager in self.sensor_managers.values(): if hasattr(sensor_manager, 'image_processor'): if hasattr(sensor_manager.image_processor, 'image_cache'): @@ -1319,6 +2373,7 @@ def _force_memory_cleanup(self): except: pass + # 刷新LiDAR批处理 for sensor_manager in self.sensor_managers.values(): if hasattr(sensor_manager, 'lidar_processor'): try: @@ -1327,212 +2382,101 @@ def _force_memory_cleanup(self): except: pass - gc.collect() - - Log.info("强制内存清理完成") - - def cleanup(self): - Log.info("开始安全清理场景...") - - cleanup_start = time.time() - - try: - self.is_running = False - - time.sleep(0.2) - - if self.v2x_communication: - try: - Log.info("停止V2X通信...") - self.v2x_communication.stop() - except: - pass - - if self.safety_monitor: - try: - Log.info("保存行人安全数据...") - self.safety_monitor.save_data() - except: - pass - - Log.info(f"清理 {len(self.sensor_managers)} 个传感器管理器...") - for vehicle_id, sensor_manager in self.sensor_managers.items(): - try: - sensor_manager.cleanup() - except: - pass - - self.sensor_managers.clear() - time.sleep(0.1) - - if self.multi_vehicle_manager: - try: - Log.info("清理多车辆管理器...") - self.multi_vehicle_manager.cleanup() - except: - pass - - if self.traffic_manager: - try: - Log.info("清理交通管理器...") - self.traffic_manager.cleanup() - except: - pass - - Log.info(f"清理 {len(self.ego_vehicles)} 个主车...") - for vehicle in self.ego_vehicles: + # 清理融合缓存 + for sensor_manager in self.sensor_managers.values(): + if hasattr(sensor_manager, 'fusion_manager'): try: - if hasattr(vehicle, 'destroy'): - vehicle.destroy() + sensor_manager.fusion_manager.cleanup() + Log.debug("清理融合缓存") except: pass - time.sleep(0.01) - - self.ego_vehicles.clear() - - try: - if self.world: - default_weather = carla.WeatherParameters() - self.world.set_weather(default_weather) - except: - pass - - gc.collect() - - time.sleep(0.3) - - self.traffic_manager = None - self.multi_vehicle_manager = None - self.v2x_communication = None - self.safety_monitor = None - self.scene_center = None - - gc.collect() - - Log.info(f"清理完成,总用时: {time.time() - cleanup_start:.2f}秒") - - except Exception as e: - Log.error(f"清理过程中发生错误: {e}") - try: - self.sensor_managers.clear() - self.ego_vehicles.clear() - self.traffic_manager = None - self.multi_vehicle_manager = None - self.v2x_communication = None - self.safety_monitor = None - gc.collect() - except: - pass - def _convert_to_target_format(self): - Log.info(f"转换为 {self.output_format} 格式...") - - if self.output_format == 'v2xformer': - self._convert_to_v2xformer_format() - elif self.output_format == 'kitti': - self._convert_to_kitti_format() - - def _convert_to_v2xformer_format(self): - try: - v2x_dir = os.path.join(self.output_dir, "v2xformer_format") - - splits = ['train', 'val', 'test'] - for split in splits: - split_dir = os.path.join(v2x_dir, split) - os.makedirs(split_dir, exist_ok=True) - - for subdir in ['image', 'point_cloud', 'calib', 'label']: - os.makedirs(os.path.join(split_dir, subdir), exist_ok=True) - - total_frames = self.collected_frames - train_ratio = 0.7 - val_ratio = 0.2 - test_ratio = 0.1 - - train_frames = int(total_frames * train_ratio) - val_frames = int(total_frames * val_ratio) - test_frames = total_frames - train_frames - val_frames - - splits_info = { - 'train': list(range(0, train_frames)), - 'val': list(range(train_frames, train_frames + val_frames)), - 'test': list(range(train_frames + val_frames, total_frames)) - } - - splits_file = os.path.join(v2x_dir, "splits.json") - with open(splits_file, 'w') as f: - json.dump(splits_info, f, indent=2) - - Log.info(f"V2XFormer格式转换完成: {v2x_dir}") - - except Exception as e: - Log.error(f"V2XFormer格式转换失败: {e}") - - def _convert_to_kitti_format(self): - try: - kitti_dir = os.path.join(self.output_dir, "kitti_format") - - for subdir in ['training', 'testing']: - full_dir = os.path.join(kitti_dir, subdir) - os.makedirs(full_dir, exist_ok=True) - - for subsubdir in ['image_2', 'velodyne', 'calib', 'label_2']: - os.makedirs(os.path.join(full_dir, subsubdir), exist_ok=True) - - self._generate_kitti_calibration(kitti_dir) - - Log.info(f"KITTI格式转换完成: {kitti_dir}") - - except Exception as e: - Log.error(f"KITTI格式转换失败: {e}") - - def _generate_kitti_calibration(self, kitti_dir): - calib_template = """P0: 7.215377e+02 0.000000e+00 6.095593e+02 0.000000e+00 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 -P1: 7.215377e+02 0.000000e+00 6.095593e+02 -3.875744e+02 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 -P2: 7.215377e+02 0.000000e+00 6.095593e+02 4.485728e+01 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 -P3: 7.215377e+02 0.000000e+00 6.095593e+02 -3.341729e+02 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 -R0_rect: 9.999239e-01 9.837760e-03 -7.445048e-03 -9.869795e-03 9.999421e-01 -4.278459e-03 7.402527e-03 4.351614e-03 9.999631e-01 -Tr_velo_to_cam: 4.276802e-04 -9.999672e-01 -8.084491e-03 -1.198459e-02 -7.210626e-03 8.081198e-03 -9.999413e-01 -5.403984e-02 9.999738e-01 4.859485e-04 -7.206933e-03 -2.921968e-02 -Tr_imu_to_velo: 9.999976e-01 7.553071e-04 -2.035826e-03 -8.086759e-01 -7.854027e-04 9.998898e-01 -1.482298e-02 3.195559e-01 2.024406e-03 1.482454e-02 9.998881e-01 -7.997231e-01""" + # 垃圾回收 + gc.collect() - for i in range(self.collected_frames): - calib_file = os.path.join(kitti_dir, "training", "calib", f"{i:06d}.txt") - with open(calib_file, 'w') as f: - f.write(calib_template) + Log.info("强制内存清理完成") def _update_v2x_communication(self): + """更新V2X通信""" if not self.v2x_communication: return - for vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + # 更新车辆状态 + all_vehicles = self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles + + for vehicle in all_vehicles: if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue try: location = vehicle.get_location() velocity = vehicle.get_velocity() - speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) + transform = vehicle.get_transform() + + speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) * 3.6 # km/h vehicle_data = { 'position': (location.x, location.y, location.z), 'speed': speed, - 'heading': vehicle.get_transform().rotation.yaw, - 'acceleration': (0, 0, 0) + 'heading': transform.rotation.yaw, + 'acceleration': (0, 0, 0), + 'vehicle_id': vehicle.id, + 'timestamp': time.time() } self.v2x_communication.broadcast_basic_safety_message( f'vehicle_{vehicle.id}', vehicle_data ) - except: - pass + except Exception as e: + Log.debug(f"V2X状态更新失败: {e}") + + # 检查并处理接收到的消息 for vehicle in self.ego_vehicles: messages = self.v2x_communication.get_messages_for_node(f'vehicle_{vehicle.id}') - if messages: + if messages and len(messages) > 0: Log.debug(f"车辆 {vehicle.id} 收到 {len(messages)} 条V2X消息") + # 处理安全警告 + safety_messages = [m for m in messages if + m['message']['message_type'] in ['warning', 'emergency_brake']] + if safety_messages: + self._process_v2x_safety_warnings(vehicle, safety_messages) + + def _process_v2x_safety_warnings(self, vehicle, warnings): + """处理V2X安全警告""" + for warning in warnings: + message = warning['message'] + data = message['data'] + + if data.get('type') == 'pedestrian': + Log.safety(f"车辆 {vehicle.id} 收到行人警告: {data.get('severity', 'unknown')}风险") + + # 根据风险等级采取行动 + if data.get('severity') in ['high', 'critical']: + try: + control = carla.VehicleControl() + control.throttle = 0.0 + control.brake = 0.3 + vehicle.apply_control(control) + Log.safety(f"车辆 {vehicle.id} 执行减速") + except: + pass + + elif data.get('type') == 'emergency_brake': + Log.safety(f"车辆 {vehicle.id} 收到紧急制动警告") + + try: + control = carla.VehicleControl() + control.throttle = 0.0 + control.brake = 1.0 # 紧急制动 + vehicle.apply_control(control) + except: + pass + def _share_perception_data(self): + """共享感知数据""" if not self.multi_vehicle_manager or not self.config['cooperative']['enable_shared_perception']: return @@ -1540,38 +2484,95 @@ def _share_perception_data(self): if not hasattr(vehicle, 'is_alive') or not vehicle.is_alive: continue + # 模拟物体检测 detected_objects = self._simulate_object_detection(vehicle) if detected_objects: self.multi_vehicle_manager.share_perception_data(vehicle.id, detected_objects) + # 保存共享感知数据 + frame_num = sum(mgr.get_frame_count() for mgr in self.sensor_managers.values()) + if frame_num % 10 == 0: # 每10帧保存一次 + self.multi_vehicle_manager.save_shared_perception(frame_num) + def _simulate_object_detection(self, vehicle): + """模拟物体检测""" detected_objects = [] - for other_vehicle in self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles: + # 检测其他车辆 + all_vehicles = self.ego_vehicles + self.multi_vehicle_manager.cooperative_vehicles + + for other_vehicle in all_vehicles: if other_vehicle.id == vehicle.id or not hasattr(other_vehicle, 'is_alive') or not other_vehicle.is_alive: continue try: location = other_vehicle.get_location() + velocity = other_vehicle.get_velocity() distance = vehicle.get_location().distance(location) - if distance < 50.0: + if distance < 50.0: # 检测范围50米 + speed = math.sqrt(velocity.x ** 2 + velocity.y ** 2 + velocity.z ** 2) * 3.6 + obj_data = { 'class': 'vehicle', + 'type': other_vehicle.type_id, 'position': {'x': location.x, 'y': location.y, 'z': location.z}, - 'velocity': {'x': 0, 'y': 0, 'z': 0}, + 'velocity': {'x': velocity.x, 'y': velocity.y, 'z': velocity.z, 'speed_kmh': speed}, + 'distance': distance, 'confidence': max(0.7, 1.0 - distance / 50.0), - 'size': {'width': 2.0, 'length': 4.5, 'height': 1.5}, - 'id': other_vehicle.id + 'size': {'width': 1.8, 'length': 4.5, 'height': 1.5}, + 'id': other_vehicle.id, + 'timestamp': time.time() } detected_objects.append(obj_data) except: pass + # 检测行人 + if self.traffic_manager and self.traffic_manager.pedestrians: + for pedestrian in self.traffic_manager.pedestrians[:10]: # 只检查前10个行人 + if not hasattr(pedestrian, 'is_alive') or not pedestrian.is_alive: + continue + + try: + location = pedestrian.get_location() + distance = vehicle.get_location().distance(location) + + if distance < 30.0: # 行人检测范围30米 + obj_data = { + 'class': 'pedestrian', + 'type': pedestrian.type_id, + 'position': {'x': location.x, 'y': location.y, 'z': location.z}, + 'distance': distance, + 'confidence': max(0.6, 1.0 - distance / 30.0), + 'size': {'width': 0.5, 'length': 0.5, 'height': 1.7}, + 'id': pedestrian.id, + 'timestamp': time.time(), + 'risk_level': 'high' if distance < 10.0 else 'medium' if distance < 20.0 else 'low' + } + detected_objects.append(obj_data) + except: + pass + return detected_objects + def _update_dynamic_weather(self): + """更新动态天气""" + try: + current_weather = self.world.get_weather() + dynamic_weather = WeatherSystem.create_dynamic_weather(current_weather, variation=0.15) + self.world.set_weather(dynamic_weather) + + Log.debug(f"天气更新: " + f"云量 {dynamic_weather.cloudiness:.0f}%, " + f"降水 {dynamic_weather.precipitation:.0f}%, " + f"雾密度 {dynamic_weather.fog_density:.0f}%") + except: + pass + def _save_metadata(self): + """保存元数据""" total_frames = self.collected_frames metadata = { @@ -1583,31 +2584,52 @@ def _save_metadata(self): 'output_format': self.output_format, 'output': self.config['output'], 'collection': { + 'start_time': self.start_time, 'duration': round(time.time() - self.start_time, 2), 'total_frames': total_frames, 'frame_rate': round(total_frames / max(time.time() - self.start_time, 0.1), - 2) if total_frames > 0 else 0 + 2) if total_frames > 0 else 0, + 'completed': True, + 'early_stop': self.emergency_handler.emergency_stop } } if total_frames > 0: + # 性能摘要 performance_summary = self.performance_monitor.get_performance_summary() metadata['performance'] = performance_summary + # 传感器摘要 sensor_summaries = {} for vehicle_id, sensor_manager in self.sensor_managers.items(): sensor_summaries[vehicle_id] = sensor_manager.generate_sensor_summary() metadata['sensor_summaries'] = sensor_summaries + # V2X状态 if self.v2x_communication: metadata['v2x_status'] = self.v2x_communication.get_network_status() + # 协同摘要 if self.multi_vehicle_manager: metadata['cooperative_summary'] = self.multi_vehicle_manager.generate_summary() + # 安全报告 if self.safety_monitor: metadata['safety_report'] = self.safety_monitor.generate_final_report() + # 场景描述 + if self.scene_manager: + scene_info = { + 'center_location': { + 'x': self.scene_center.x, + 'y': self.scene_center.y, + 'z': self.scene_center.z + } if self.scene_center else None, + 'town': self.config['scenario']['town'], + 'pedestrian_safety_mode': self.pedestrian_safety_mode + } + metadata['scene_info'] = scene_info + meta_path = os.path.join(self.output_dir, "metadata", "collection_info.json") with open(meta_path, 'w', encoding='utf-8') as f: json.dump(metadata, f, indent=2, ensure_ascii=False) @@ -1615,42 +2637,75 @@ def _save_metadata(self): Log.info(f"元数据保存: {meta_path}") def _print_summary(self): + """打印摘要""" print("\n" + "=" * 60) print("数据收集摘要") print("=" * 60) - raw_dirs = [d for d in os.listdir(self.output_dir) if d.startswith('raw')] + # 统计文件 + raw_dirs = [d for d in os.listdir(os.path.join(self.output_dir, "raw")) + if os.path.isdir(os.path.join(self.output_dir, "raw", d))] + total_raw_images = 0 for raw_dir in raw_dirs: - raw_path = os.path.join(self.output_dir, raw_dir) - if os.path.exists(raw_path): - for root, dirs, files in os.walk(raw_path): - total_raw_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) + raw_path = os.path.join(self.output_dir, "raw", raw_dir) + for root, dirs, files in os.walk(raw_path): + total_raw_images += len([f for f in files if f.endswith(('.png', '.jpg', '.jpeg'))]) print(f"原始图像: {total_raw_images} 张") + # LiDAR数据 lidar_dir = os.path.join(self.output_dir, "lidar") if os.path.exists(lidar_dir): import glob bin_files = glob.glob(os.path.join(lidar_dir, "*.bin")) npy_files = glob.glob(os.path.join(lidar_dir, "*.npy")) - batch_files = glob.glob(os.path.join(lidar_dir, "*batch*.json")) - print(f"LiDAR数据: {len(bin_files)} .bin文件, {len(npy_files)} .npy文件") - print(f"批处理文件: {len(batch_files)} 个") + pcd_files = glob.glob(os.path.join(lidar_dir, "*.pcd")) + print(f"LiDAR数据: {len(bin_files)} .bin文件, " + f"{len(npy_files)} .npy文件, " + f"{len(pcd_files)} .pcd文件") + + # 计算总点数估计 + if bin_files: + sample_files = bin_files[:min(5, len(bin_files))] + total_points = 0 + for file in sample_files: + try: + file_size = os.path.getsize(file) + points_in_file = file_size // 16 # 每个点16字节 + total_points += points_in_file + except: + pass + + if sample_files: + avg_points = total_points / len(sample_files) + estimated_total = avg_points * len(bin_files) + print(f" 估计总点数: {estimated_total:,.0f}") + + # 协同数据 coop_dir = os.path.join(self.output_dir, "cooperative") if os.path.exists(coop_dir): - v2x_files = len( - [f for f in os.listdir(os.path.join(coop_dir, "v2x_messages")) if f.endswith(('.json', '.gz'))]) - perception_files = len( - [f for f in os.listdir(os.path.join(coop_dir, "shared_perception")) if f.endswith('.json')]) - print(f"协同数据: {v2x_files} V2X消息, {perception_files} 共享感知文件") + v2x_files = [] + perception_files = [] + + v2x_dir = os.path.join(coop_dir, "v2x_messages") + if os.path.exists(v2x_dir): + v2x_files = [f for f in os.listdir(v2x_dir) if f.endswith(('.json', '.gz'))] + + perception_dir = os.path.join(coop_dir, "shared_perception") + if os.path.exists(perception_dir): + perception_files = [f for f in os.listdir(perception_dir) if f.endswith('.json')] + print(f"协同数据: {len(v2x_files)} V2X消息, {len(perception_files)} 共享感知文件") + + # 安全数据 safety_dir = os.path.join(self.output_dir, "safety_reports") if os.path.exists(safety_dir): safety_files = len([f for f in os.listdir(safety_dir) if f.endswith('.json')]) print(f"安全报告: {safety_files} 个") + # 格式转换 if self.output_format == 'v2xformer': v2x_dir = os.path.join(self.output_dir, "v2xformer_format") if os.path.exists(v2x_dir): @@ -1661,6 +2716,7 @@ def _print_summary(self): if os.path.exists(kitti_dir): print(f"KITTI格式: 已生成") + # 性能统计 total_frames = self.collected_frames elapsed = time.time() - self.start_time @@ -1671,24 +2727,324 @@ def _print_summary(self): performance = self.performance_monitor.get_performance_summary() print(f" 帧时统计:") - print(f" 平均: {performance['average_frame_time']:.3f}秒") - print(f" P50: {performance['frame_time_stats']['p50']:.3f}秒") - print(f" P95: {performance['frame_time_stats']['p95']:.3f}秒") - print(f" P99: {performance['frame_time_stats']['p99']:.3f}秒") - print(f" 平均内存: {performance['average_memory_mb']:.1f} MB") - print(f" 最大内存: {performance['max_memory_mb']:.1f} MB") - print(f" 平均CPU: {performance['average_cpu_percent']:.1f}%") + print(f" 平均: {performance['frame_statistics']['average_frame_time'] * 1000:.1f}ms") + print(f" P50: {performance['frame_time_stats']['p50'] * 1000:.1f}ms") + print(f" P95: {performance['frame_time_stats']['p95'] * 1000:.1f}ms") + print(f" P99: {performance['frame_time_stats']['p99'] * 1000:.1f}ms") + print(f" 内存使用:") + print(f" 平均: {performance['memory_statistics']['average_memory_mb']:.1f} MB") + print(f" 最大: {performance['memory_statistics']['max_memory_mb']:.1f} MB") + print(f" 警告: {len(performance['warnings'])} 个") print(f" 总帧数: {total_frames}") else: print(" 未收集到有效帧数据") + # 行人安全统计 + if self.safety_monitor: + try: + final_report = self.safety_monitor.generate_final_report() + print(f"\n行人安全统计:") + print(f" 高风险交互: {final_report['risk_distribution']['high']}") + print(f" 临界风险: {final_report['risk_distribution']['critical']}") + print(f" 安全评分: {final_report['safety_score']:.1f}/100") + except: + pass + print(f"\n输出目录: {self.output_dir}") print("=" * 60) + def _convert_to_target_format(self): + """转换为目标格式""" + Log.info(f"转换为 {self.output_format} 格式...") + + if self.output_format == 'v2xformer': + self._convert_to_v2xformer_format() + elif self.output_format == 'kitti': + self._convert_to_kitti_format() + elif self.output_format == 'nuscenes': + self._convert_to_nuscenes_format() + + def _convert_to_v2xformer_format(self): + """转换为V2XFormer格式""" + try: + v2x_dir = os.path.join(self.output_dir, "v2xformer_format") + + # 创建标准目录结构 + splits = ['train', 'val', 'test'] + for split in splits: + split_dir = os.path.join(v2x_dir, split) + os.makedirs(split_dir, exist_ok=True) + + for subdir in ['image', 'point_cloud', 'calib', 'label']: + os.makedirs(os.path.join(split_dir, subdir), exist_ok=True) + + # 计算分割 + total_frames = self.collected_frames + if total_frames == 0: + Log.warning("没有数据帧可转换") + return + + train_ratio = 0.7 + val_ratio = 0.2 + test_ratio = 0.1 + + train_frames = int(total_frames * train_ratio) + val_frames = int(total_frames * val_ratio) + test_frames = total_frames - train_frames - val_frames + + splits_info = { + 'train': list(range(0, train_frames)), + 'val': list(range(train_frames, train_frames + val_frames)), + 'test': list(range(train_frames + val_frames, total_frames)) + } + + # 保存分割信息 + splits_file = os.path.join(v2x_dir, "splits.json") + with open(splits_file, 'w', encoding='utf-8') as f: + json.dump(splits_info, f, indent=2) + + # 创建配置文件 + config = { + 'dataset': { + 'name': 'CVIPS_Pedestrian_Safety', + 'version': '2.0', + 'description': '行人安全增强数据集', + 'splits': splits_info, + 'total_frames': total_frames, + 'created': datetime.now().isoformat() + }, + 'sensors': { + 'cameras': self.config['sensors']['vehicle_cameras'], + 'lidars': self.config['sensors']['lidar_sensors'], + 'image_size': self.config['sensors']['image_size'] + }, + 'classes': { + 'vehicle': ['car', 'truck', 'bus', 'motorcycle', 'bicycle'], + 'pedestrian': ['pedestrian'], + 'traffic': ['traffic_light', 'traffic_sign'] + } + } + + config_file = os.path.join(v2x_dir, "config.json") + with open(config_file, 'w', encoding='utf-8') as f: + json.dump(config, f, indent=2) + + Log.info(f"V2XFormer格式转换完成: {v2x_dir}") + + except Exception as e: + Log.error(f"V2XFormer格式转换失败: {e}") + + def _convert_to_kitti_format(self): + """转换为KITTI格式""" + try: + kitti_dir = os.path.join(self.output_dir, "kitti_format") + + # 创建标准目录结构 + for subdir in ['training', 'testing']: + full_dir = os.path.join(kitti_dir, subdir) + os.makedirs(full_dir, exist_ok=True) + + for subsubdir in ['image_2', 'velodyne', 'calib', 'label_2']: + os.makedirs(os.path.join(full_dir, subsubdir), exist_ok=True) + + # 生成标定文件 + self._generate_kitti_calibration(kitti_dir) + + # 创建映射文件 + mapping = { + 'dataset_name': 'CVIPS_KITTI', + 'original_path': self.output_dir, + 'converted_path': kitti_dir, + 'total_frames': self.collected_frames, + 'conversion_time': datetime.now().isoformat() + } + + mapping_file = os.path.join(kitti_dir, "mapping.json") + with open(mapping_file, 'w', encoding='utf-8') as f: + json.dump(mapping, f, indent=2) + + Log.info(f"KITTI格式转换完成: {kitti_dir}") + + except Exception as e: + Log.error(f"KITTI格式转换失败: {e}") + + def _convert_to_nuscenes_format(self): + """转换为nuScenes格式""" + try: + nuscenes_dir = os.path.join(self.output_dir, "nuscenes_format") + + # 创建标准目录结构 + for subdir in ['samples', 'sweeps', 'maps']: + os.makedirs(os.path.join(nuscenes_dir, subdir), exist_ok=True) + + # 创建基本配置文件 + config = { + 'dataset': { + 'name': 'CVIPS_nuScenes', + 'version': 'v1.0', + 'description': '行人安全增强数据集 - nuScenes格式', + 'created': datetime.now().isoformat() + }, + 'sensors': { + 'cameras': 6, + 'lidars': 1, + 'radars': 0 + }, + 'classes': [ + 'car', 'truck', 'bus', 'trailer', + 'pedestrian', 'bicycle', 'motorcycle', + 'traffic_cone', 'barrier' + ] + } + + config_file = os.path.join(nuscenes_dir, "config.json") + with open(config_file, 'w', encoding='utf-8') as f: + json.dump(config, f, indent=2) + + Log.info(f"nuScenes格式转换开始: {nuscenes_dir}") + + except Exception as e: + Log.error(f"nuScenes格式转换失败: {e}") + + def _generate_kitti_calibration(self, kitti_dir): + """生成KITTI标定文件""" + calib_template = """P0: 7.215377e+02 0.000000e+00 6.095593e+02 0.000000e+00 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 +P1: 7.215377e+02 0.000000e+00 6.095593e+02 -3.875744e+02 0.000000e+00 7.215377e+02 1.728540e+02 0.000000e+00 0.000000e+00 0.000000e+00 1.000000e+00 0.000000e+00 +P2: 7.215377e+02 0.000000e+00 6.095593e+02 4.485728e+01 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 +P3: 7.215377e+02 0.000000e+00 6.095593e+02 -3.341729e+02 0.000000e+00 7.215377e+02 1.728540e+02 2.163791e-01 0.000000e+00 0.000000e+00 1.000000e+00 2.745884e-03 +R0_rect: 9.999239e-01 9.837760e-03 -7.445048e-03 -9.869795e-03 9.999421e-01 -4.278459e-03 7.402527e-03 4.351614e-03 9.999631e-01 +Tr_velo_to_cam: 4.276802e-04 -9.999672e-01 -8.084491e-03 -1.198459e-02 -7.210626e-03 8.081198e-03 -9.999413e-01 -5.403984e-02 9.999738e-01 4.859485e-04 -7.206933e-03 -2.921968e-02 +Tr_imu_to_velo: 9.999976e-01 7.553071e-04 -2.035826e-03 -8.086759e-01 -7.854027e-04 9.998898e-01 -1.482298e-02 3.195559e-01 2.024406e-03 1.482454e-02 9.998881e-01 -7.997231e-01""" + + # 为每帧生成标定文件 + for i in range(min(self.collected_frames, 1000)): # 限制数量 + calib_file = os.path.join(kitti_dir, "training", "calib", f"{i:06d}.txt") + try: + with open(calib_file, 'w') as f: + f.write(calib_template) + except: + pass + def run_validation(self): + """运行数据验证""" if self.config['output'].get('validate_data', True) and self.collected_frames > 0: Log.info("运行数据验证...") - DataValidator.validate_dataset(self.output_dir) + + detailed = self.config['output'].get('run_quality_check', True) + validation_results = DataValidator.validate_dataset(self.output_dir, detailed) + + # 根据验证结果给出建议 + overall_score = validation_results.get('overall_score', 0) + health_status = validation_results.get('health_status', 'UNKNOWN') + + Log.info(f"验证完成: 评分 {overall_score}/100, 状态 {health_status}") + + if overall_score < 60: + Log.warning("数据集质量较低,建议检查采集过程") + elif overall_score < 80: + Log.info("数据集质量良好,部分项目需要优化") + else: + Log.info("数据集质量优秀") + else: + Log.info("跳过数据验证") + + def cleanup(self): + """清理数据收集器""" + Log.info("开始安全清理场景...") + + cleanup_start = time.time() + + try: + self.is_running = False + + # 短暂等待确保所有处理完成 + time.sleep(0.5) + + # 停止V2X通信 + if self.v2x_communication: + try: + Log.info("停止V2X通信...") + self.v2x_communication.stop() + except: + pass + + # 保存行人安全数据 + if self.safety_monitor: + try: + Log.info("保存行人安全数据...") + self.safety_monitor.save_data() + except: + pass + + # 清理传感器管理器 + Log.info(f"清理 {len(self.sensor_managers)} 个传感器管理器...") + for vehicle_id, sensor_manager in self.sensor_managers.items(): + try: + sensor_manager.cleanup() + except: + pass + + self.sensor_managers.clear() + time.sleep(0.2) + + # 清理多车辆管理器 + if self.multi_vehicle_manager: + try: + Log.info("清理多车辆管理器...") + self.multi_vehicle_manager.cleanup() + except: + pass + + # 清理交通管理器 + if self.traffic_manager: + try: + Log.info("清理交通管理器...") + self.traffic_manager.cleanup() + except: + pass + + # 清理主车 + Log.info(f"清理 {len(self.ego_vehicles)} 个主车...") + for vehicle in self.ego_vehicles: + try: + if hasattr(vehicle, 'destroy'): + vehicle.destroy() + except: + pass + time.sleep(0.01) + + self.ego_vehicles.clear() + + # 恢复默认天气 + try: + if self.world: + default_weather = carla.WeatherParameters() + self.world.set_weather(default_weather) + except: + pass + + # 清理Python对象 + self.traffic_manager = None + self.multi_vehicle_manager = None + self.v2x_communication = None + self.safety_monitor = None + self.scene_manager = None + self.scene_center = None + + # 垃圾回收 + gc.collect() + + Log.info(f"清理完成,总用时: {time.time() - cleanup_start:.2f}秒") + + except Exception as e: + Log.error(f"清理过程中发生错误: {e}") + try: + # 尝试强制清理 + self.sensor_managers.clear() + self.ego_vehicles.clear() + gc.collect() + except: + pass def main():