|
|
@@ -0,0 +1,1899 @@
|
|
|
+#!/usr/bin/env python
|
|
|
+# -*- coding: utf-8 -*-
|
|
|
+##################################################################
|
|
|
+#
|
|
|
+# Copyright (c) 2023 CICV, Inc. All Rights Reserved
|
|
|
+#
|
|
|
+##################################################################
|
|
|
+"""
|
|
|
+@Authors: zhanghaiwen(zhanghaiwen@china-icv.cn)
|
|
|
+@Data: 2023/06/25
|
|
|
+@Last Modified: 2025/05/20
|
|
|
+@Summary: Chart generation utilities for metrics visualization
|
|
|
+"""
|
|
|
+
|
|
|
+import os
|
|
|
+import numpy as np
|
|
|
+import pandas as pd
|
|
|
+import matplotlib
|
|
|
+matplotlib.use('Agg') # 使用非图形界面的后端
|
|
|
+import matplotlib.pyplot as plt
|
|
|
+from typing import Optional, Dict, List, Any, Union
|
|
|
+from pathlib import Path
|
|
|
+
|
|
|
+from modules.lib.log_manager import LogManager
|
|
|
+
|
|
|
+def generate_function_chart_data(function_calculator, metric_name: str, output_dir: Optional[str] = None) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate chart data for function metrics
|
|
|
+
|
|
|
+ Args:
|
|
|
+ function_calculator: FunctionCalculator instance
|
|
|
+ metric_name: Metric name
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 确保输出目录存在
|
|
|
+ if output_dir:
|
|
|
+ os.makedirs(output_dir, exist_ok=True)
|
|
|
+ else:
|
|
|
+ output_dir = os.getcwd()
|
|
|
+
|
|
|
+ # 根据指标名称选择不同的图表生成方法
|
|
|
+ if metric_name.lower() == 'latestwarningdistance_ttc_lst':
|
|
|
+ return generate_warning_ttc_chart(function_calculator, output_dir)
|
|
|
+ else:
|
|
|
+ logger.warning(f"Chart generation not implemented for metric [{metric_name}]")
|
|
|
+ return None
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate chart data: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_warning_ttc_chart(function_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate TTC warning chart with data visualization.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ function_calculator: FunctionCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ ego_df = function_calculator.ego_data.copy()
|
|
|
+ scenario_name = function_calculator.data.function_config["function"]["scenario"]["name"]
|
|
|
+ correctwarning = scenario_sign_dict[scenario_name]
|
|
|
+
|
|
|
+ warning_dist = calculate_distance(ego_df, correctwarning)
|
|
|
+ warning_speed = calculate_relative_speed(ego_df, correctwarning)
|
|
|
+
|
|
|
+ if warning_dist.empty:
|
|
|
+ logger.warning("Cannot generate TTC warning chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据
|
|
|
+ csv_filename = os.path.join(output_dir, f"warning_ttc_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': ego_df['simTime'],
|
|
|
+ 'warning_distance': warning_dist,
|
|
|
+ 'warning_speed': warning_speed,
|
|
|
+ 'ttc': warning_dist / warning_speed
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Warning TTC data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 从 CSV 读取数据
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # 图 1：预警距离
|
|
|
+ ax1 = plt.subplot(3, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['warning_distance'], 'b-', label='Warning Distance')
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Distance (m)')
|
|
|
+ ax1.set_title('Warning Distance Over Time')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend()
|
|
|
+
|
|
|
+ # 图 2：相对速度
|
|
|
+ ax2 = plt.subplot(3, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['warning_speed'], 'g-', label='Relative Speed')
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Speed (m/s)')
|
|
|
+ ax2.set_title('Relative Speed Over Time')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend()
|
|
|
+
|
|
|
+ # 图 3：TTC
|
|
|
+ ax3 = plt.subplot(3, 1, 3)
|
|
|
+ ax3.plot(df['simTime'], df['ttc'], 'r-', label='TTC')
|
|
|
+ ax3.set_xlabel('Time (s)')
|
|
|
+ ax3.set_ylabel('TTC (s)')
|
|
|
+ ax3.set_title('Time To Collision (TTC) Over Time')
|
|
|
+ ax3.grid(True)
|
|
|
+ ax3.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"warning_ttc_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Warning TTC chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate warning TTC chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_comfort_chart_data(comfort_calculator, metric_name: str, output_dir: Optional[str] = None) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate chart data for comfort metrics
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ metric_name: Metric name
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 确保输出目录存在
|
|
|
+ if output_dir:
|
|
|
+ os.makedirs(output_dir, exist_ok=True)
|
|
|
+ else:
|
|
|
+ output_dir = os.getcwd()
|
|
|
+
|
|
|
+ # 根据指标名称选择不同的图表生成方法
|
|
|
+ if metric_name.lower() == 'shake':
|
|
|
+ return generate_shake_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'zigzag':
|
|
|
+ return generate_zigzag_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'cadence':
|
|
|
+ return generate_cadence_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'slambrake':
|
|
|
+ return generate_slam_brake_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'slamaccelerate':
|
|
|
+ return generate_slam_accelerate_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'vdv':
|
|
|
+ return generate_vdv_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'ava_vav':
|
|
|
+ return generate_ava_vav_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'msdv':
|
|
|
+ return generate_msdv_chart(comfort_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'motionsickness':
|
|
|
+ return generate_motion_sickness_chart(comfort_calculator, output_dir)
|
|
|
+ else:
|
|
|
+ logger.warning(f"Chart generation not implemented for metric [{metric_name}]")
|
|
|
+ return None
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate chart data: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_shake_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate shake metric chart with orange background for shake events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ shake_events = comfort_calculator.shake_events
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate shake chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"shake_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'lat_acc': df['lat_acc'],
|
|
|
+ 'lat_acc_rate': df['lat_acc_rate'],
|
|
|
+ 'speedH_std': df['speedH_std'],
|
|
|
+ 'lat_acc_threshold': df.get('lat_acc_threshold', pd.Series([None]*len(df))),
|
|
|
+ 'lat_acc_rate_threshold': 0.5,
|
|
|
+ 'speedH_std_threshold': df.get('speedH_threshold', pd.Series([None]*len(df))),
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Shake data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ import matplotlib.pyplot as plt
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # 图 1：横向加速度
|
|
|
+ ax1 = plt.subplot(3, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['lat_acc'], 'b-', label='Lateral Acceleration')
|
|
|
+ if 'lat_acc_threshold' in df.columns:
|
|
|
+ ax1.plot(df['simTime'], df['lat_acc_threshold'], 'r--', label='lat_acc_threshold')
|
|
|
+
|
|
|
+ for idx, event in enumerate(shake_events):
|
|
|
+ label = 'Shake Event' if idx == 0 else None
|
|
|
+ ax1.axvspan(event['start_time'], event['end_time'], alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Lateral Acceleration (m/s²)')
|
|
|
+ ax1.set_title('Shake Event Detection - Lateral Acceleration')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend()
|
|
|
+
|
|
|
+ # 图 2：lat_acc_rate
|
|
|
+ ax2 = plt.subplot(3, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['lat_acc_rate'], 'g-', label='lat_acc_rate')
|
|
|
+ ax2.axhline(
|
|
|
+ y=0.5, color='orange', linestyle='--', linewidth=1.2, label='lat_acc_rate_threshold'
|
|
|
+ )
|
|
|
+
|
|
|
+ for idx, event in enumerate(shake_events):
|
|
|
+ label = 'Shake Event' if idx == 0 else None
|
|
|
+ ax2.axvspan(event['start_time'], event['end_time'], alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Angular Velocity (m/s³)')
|
|
|
+ ax2.set_title('Shake Event Detection - lat_acc_rate')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend()
|
|
|
+
|
|
|
+ # 图 3：speedH_std
|
|
|
+ ax3 = plt.subplot(3, 1, 3)
|
|
|
+ ax3.plot(df['simTime'], df['speedH_std'], 'b-', label='speedH_std')
|
|
|
+ if 'speedH_std_threshold' in df.columns:
|
|
|
+ ax3.plot(df['simTime'], df['speedH_std_threshold'], 'r--', label='speedH_threshold')
|
|
|
+
|
|
|
+ for idx, event in enumerate(shake_events):
|
|
|
+ label = 'Shake Event' if idx == 0 else None
|
|
|
+ ax3.axvspan(event['start_time'], event['end_time'], alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax3.set_xlabel('Time (s)')
|
|
|
+ ax3.set_ylabel('Angular Velocity (deg/s)')
|
|
|
+ ax3.set_title('Shake Event Detection - speedH_std')
|
|
|
+ ax3.grid(True)
|
|
|
+ ax3.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"shake_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Shake chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate shake chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+
|
|
|
+def generate_zigzag_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate zigzag metric chart with orange background for zigzag events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ zigzag_events = comfort_calculator.discomfort_df[
|
|
|
+ comfort_calculator.discomfort_df['type'] == 'zigzag'
|
|
|
+ ].copy()
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate zigzag chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"zigzag_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'speedH': df['speedH'],
|
|
|
+ 'posH': df['posH'],
|
|
|
+ 'min_speedH_threshold': -2.3, # 可替换为动态阈值
|
|
|
+ 'max_speedH_threshold': 2.3
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Zigzag data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ import matplotlib.pyplot as plt
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # ===== 子图1：Yaw Rate =====
|
|
|
+ ax1 = plt.subplot(2, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['speedH'], 'g-', label='Yaw Rate')
|
|
|
+
|
|
|
+ # 添加 speedH 上下限阈值线
|
|
|
+ ax1.axhline(y=2.3, color='m', linestyle='--', linewidth=1.2, label='Max Threshold (+2.3)')
|
|
|
+ ax1.axhline(y=-2.3, color='r', linestyle='--', linewidth=1.2, label='Min Threshold (-2.3)')
|
|
|
+
|
|
|
+ # 添加橙色背景：Zigzag Events
|
|
|
+ for idx, event in zigzag_events.iterrows():
|
|
|
+ label = 'Zigzag Event' if idx == 0 else None
|
|
|
+ ax1.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Angular Velocity (deg/s)')
|
|
|
+ ax1.set_title('Zigzag Event Detection - Yaw Rate')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend(loc='upper left')
|
|
|
+
|
|
|
+ # ===== 子图2：Yaw Angle =====
|
|
|
+ ax2 = plt.subplot(2, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['posH'], 'b-', label='Yaw')
|
|
|
+
|
|
|
+ # 添加橙色背景：Zigzag Events
|
|
|
+ for idx, event in zigzag_events.iterrows():
|
|
|
+ label = 'Zigzag Event' if idx == 0 else None
|
|
|
+ ax2.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Yaw (deg)')
|
|
|
+ ax2.set_title('Zigzag Event Detection - Yaw Angle')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend(loc='upper left')
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"zigzag_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Zigzag chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate zigzag chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_cadence_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate cadence metric chart with orange background for cadence events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ cadence_events = comfort_calculator.discomfort_df[comfort_calculator.discomfort_df['type'] == 'cadence'].copy()
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate cadence chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"cadence_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'lon_acc': df['lon_acc'],
|
|
|
+ 'v': df['v'],
|
|
|
+ 'ip_acc': df.get('ip_acc', pd.Series([None]*len(df))),
|
|
|
+ 'ip_dec': df.get('ip_dec', pd.Series([None]*len(df)))
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Cadence data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ import matplotlib.pyplot as plt
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # 图 1：纵向加速度
|
|
|
+ ax1 = plt.subplot(2, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['lon_acc'], 'b-', label='Longitudinal Acceleration')
|
|
|
+ if 'ip_acc' in df.columns and 'ip_dec' in df.columns:
|
|
|
+ ax1.plot(df['simTime'], df['ip_acc'], 'r--', label='Acceleration Threshold')
|
|
|
+ ax1.plot(df['simTime'], df['ip_dec'], 'g--', label='Deceleration Threshold')
|
|
|
+
|
|
|
+ # 添加橙色背景标识顿挫事件
|
|
|
+ for idx, event in cadence_events.iterrows():
|
|
|
+ label = 'Cadence Event' if idx == 0 else None
|
|
|
+ ax1.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Longitudinal Acceleration (m/s²)')
|
|
|
+ ax1.set_title('Cadence Event Detection - Longitudinal Acceleration')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend()
|
|
|
+
|
|
|
+ # 图 2：速度
|
|
|
+ ax2 = plt.subplot(2, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['v'], 'g-', label='Velocity')
|
|
|
+
|
|
|
+ # 添加橙色背景标识顿挫事件
|
|
|
+ for idx, event in cadence_events.iterrows():
|
|
|
+ label = 'Cadence Event' if idx == 0 else None
|
|
|
+ ax2.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Velocity (m/s)')
|
|
|
+ ax2.set_title('Cadence Event Detection - Vehicle Speed')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"cadence_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Cadence chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate cadence chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_slam_brake_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate slam brake metric chart with orange background for slam brake events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ slam_brake_events = comfort_calculator.discomfort_df[comfort_calculator.discomfort_df['type'] == 'slam_brake'].copy()
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate slam brake chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"slam_brake_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'lon_acc': df['lon_acc'],
|
|
|
+ 'v': df['v'],
|
|
|
+ 'min_threshold': df.get('ip_dec', pd.Series([None]*len(df))),
|
|
|
+ 'max_threshold': 0.0
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Slam brake data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # 图 1：纵向加速度
|
|
|
+ ax1 = plt.subplot(2, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['lon_acc'], 'b-', label='Longitudinal Acceleration')
|
|
|
+ if 'min_threshold' in df.columns:
|
|
|
+ ax1.plot(df['simTime'], df['min_threshold'], 'r--', label='Deceleration Threshold')
|
|
|
+
|
|
|
+ # 添加橙色背景标识急刹车事件
|
|
|
+ for idx, event in slam_brake_events.iterrows():
|
|
|
+ label = 'Slam Brake Event' if idx == 0 else None
|
|
|
+ ax1.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Longitudinal Acceleration (m/s²)')
|
|
|
+ ax1.set_title('Slam Brake Event Detection - Longitudinal Acceleration')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend()
|
|
|
+
|
|
|
+ # 图 2：速度
|
|
|
+ ax2 = plt.subplot(2, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['v'], 'g-', label='Velocity')
|
|
|
+
|
|
|
+ # 添加橙色背景标识急刹车事件
|
|
|
+ for idx, event in slam_brake_events.iterrows():
|
|
|
+ label = 'Slam Brake Event' if idx == 0 else None
|
|
|
+ ax2.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Velocity (m/s)')
|
|
|
+ ax2.set_title('Slam Brake Event Detection - Vehicle Speed')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"slam_brake_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Slam brake chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate slam brake chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_slam_accelerate_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate slam accelerate metric chart with orange background for slam accelerate events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ slam_accel_events = comfort_calculator.discomfort_df[comfort_calculator.discomfort_df['type'] == 'slam_accel'].copy()
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate slam accelerate chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"slam_accel_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'lon_acc': df['lon_acc'],
|
|
|
+ 'v': df['v'],
|
|
|
+ 'min_threshold': 0.0,
|
|
|
+ 'max_threshold': df.get('ip_acc', pd.Series([None]*len(df)))
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"Slam accelerate data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 8), constrained_layout=True)
|
|
|
+
|
|
|
+ # 图 1：纵向加速度
|
|
|
+ ax1 = plt.subplot(2, 1, 1)
|
|
|
+ ax1.plot(df['simTime'], df['lon_acc'], 'b-', label='Longitudinal Acceleration')
|
|
|
+ if 'max_threshold' in df.columns:
|
|
|
+ ax1.plot(df['simTime'], df['max_threshold'], 'r--', label='Acceleration Threshold')
|
|
|
+
|
|
|
+ # 添加橙色背景标识急加速事件
|
|
|
+ for idx, event in slam_accel_events.iterrows():
|
|
|
+ label = 'Slam Accelerate Event' if idx == 0 else None
|
|
|
+ ax1.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax1.set_xlabel('Time (s)')
|
|
|
+ ax1.set_ylabel('Longitudinal Acceleration (m/s²)')
|
|
|
+ ax1.set_title('Slam Accelerate Event Detection - Longitudinal Acceleration')
|
|
|
+ ax1.grid(True)
|
|
|
+ ax1.legend()
|
|
|
+
|
|
|
+ # 图 2：速度
|
|
|
+ ax2 = plt.subplot(2, 1, 2)
|
|
|
+ ax2.plot(df['simTime'], df['v'], 'g-', label='Velocity')
|
|
|
+
|
|
|
+ # 添加橙色背景标识急加速事件
|
|
|
+ for idx, event in slam_accel_events.iterrows():
|
|
|
+ label = 'Slam Accelerate Event' if idx == 0 else None
|
|
|
+ ax2.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ ax2.set_xlabel('Time (s)')
|
|
|
+ ax2.set_ylabel('Velocity (m/s)')
|
|
|
+ ax2.set_title('Slam Accelerate Event Detection - Vehicle Speed')
|
|
|
+ ax2.grid(True)
|
|
|
+ ax2.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"slam_accel_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"Slam accelerate chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate slam accelerate chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def get_metric_thresholds(calculator, metric_name: str) -> dict:
|
|
|
+ """
|
|
|
+ 从配置文件中获取指标的阈值
|
|
|
+
|
|
|
+ Args:
|
|
|
+ calculator: Calculator instance (SafetyCalculator or ComfortCalculator)
|
|
|
+ metric_name: 指标名称
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ dict: 包含min和max阈值的字典
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+ thresholds = {"min": None, "max": None}
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 根据计算器类型获取配置
|
|
|
+ if hasattr(calculator, 'data_processed'):
|
|
|
+ if hasattr(calculator.data_processed, 'safety_config') and 'safety' in calculator.data_processed.safety_config:
|
|
|
+ config = calculator.data_processed.safety_config['safety']
|
|
|
+ metric_type = 'safety'
|
|
|
+ elif hasattr(calculator.data_processed, 'comfort_config') and 'comfort' in calculator.data_processed.comfort_config:
|
|
|
+ config = calculator.data_processed.comfort_config['comfort']
|
|
|
+ metric_type = 'comfort'
|
|
|
+ else:
|
|
|
+ logger.warning(f"无法找到{metric_name}的配置信息")
|
|
|
+ return thresholds
|
|
|
+ else:
|
|
|
+ logger.warning(f"计算器没有data_processed属性")
|
|
|
+ return thresholds
|
|
|
+
|
|
|
+ # 递归查找指标配置
|
|
|
+ def find_metric_config(node, target_name):
|
|
|
+ if isinstance(node, dict):
|
|
|
+ if 'name' in node and node['name'].lower() == target_name.lower() and 'min' in node and 'max' in node:
|
|
|
+ return node
|
|
|
+ for key, value in node.items():
|
|
|
+ result = find_metric_config(value, target_name)
|
|
|
+ if result:
|
|
|
+ return result
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 查找指标配置
|
|
|
+ metric_config = find_metric_config(config, metric_name)
|
|
|
+ if metric_config:
|
|
|
+ thresholds["min"] = metric_config.get("min")
|
|
|
+ thresholds["max"] = metric_config.get("max")
|
|
|
+ logger.info(f"找到{metric_name}的阈值: min={thresholds['min']}, max={thresholds['max']}")
|
|
|
+ else:
|
|
|
+ logger.warning(f"在{metric_type}配置中未找到{metric_name}的阈值信息")
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"获取{metric_name}阈值时出错: {str(e)}", exc_info=True)
|
|
|
+
|
|
|
+ return thresholds
|
|
|
+
|
|
|
+def generate_safety_chart_data(safety_calculator, metric_name: str, output_dir: Optional[str] = None) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate chart data for safety metrics
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ metric_name: Metric name
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 确保输出目录存在
|
|
|
+ if output_dir:
|
|
|
+ os.makedirs(output_dir, exist_ok=True)
|
|
|
+ else:
|
|
|
+ output_dir = os.getcwd()
|
|
|
+
|
|
|
+ # 根据指标名称选择不同的图表生成方法
|
|
|
+ if metric_name.lower() == 'ttc':
|
|
|
+ return generate_ttc_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'mttc':
|
|
|
+ return generate_mttc_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'thw':
|
|
|
+ return generate_thw_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'lonsd':
|
|
|
+ return generate_lonsd_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'latsd':
|
|
|
+ return generate_latsd_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'btn':
|
|
|
+ return generate_btn_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'collisionrisk':
|
|
|
+ return generate_collision_risk_chart(safety_calculator, output_dir)
|
|
|
+ elif metric_name.lower() == 'collisionseverity':
|
|
|
+ return generate_collision_severity_chart(safety_calculator, output_dir)
|
|
|
+ else:
|
|
|
+ logger.warning(f"Chart generation not implemented for metric [{metric_name}]")
|
|
|
+ return None
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate chart data: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_ttc_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate TTC metric chart with orange background for unsafe events.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ ttc_data = safety_calculator.ttc_data
|
|
|
+
|
|
|
+ if not ttc_data:
|
|
|
+ logger.warning("Cannot generate TTC chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(ttc_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'TTC')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"ttc_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'simFrame': df['simFrame'],
|
|
|
+ 'TTC': df['TTC'],
|
|
|
+ 'min_threshold': min_threshold,
|
|
|
+ 'max_threshold': max_threshold
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"TTC data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 检测超阈值事件
|
|
|
+ unsafe_events = []
|
|
|
+ if min_threshold is not None:
|
|
|
+ # 对于TTC，小于最小阈值视为不安全
|
|
|
+ unsafe_condition = df['TTC'] < min_threshold
|
|
|
+ event_groups = (unsafe_condition != unsafe_condition.shift()).cumsum()
|
|
|
+
|
|
|
+ for _, group in df[unsafe_condition].groupby(event_groups):
|
|
|
+ if len(group) >= 2: # 至少2帧才算一次事件
|
|
|
+ start_time = group['simTime'].iloc[0]
|
|
|
+ end_time = group['simTime'].iloc[-1]
|
|
|
+ duration = end_time - start_time
|
|
|
+
|
|
|
+ if duration >= 0.1: # 只记录持续时间超过0.1秒的事件
|
|
|
+ unsafe_events.append({
|
|
|
+ 'start_time': start_time,
|
|
|
+ 'end_time': end_time,
|
|
|
+ 'start_frame': group['simFrame'].iloc[0],
|
|
|
+ 'end_frame': group['simFrame'].iloc[-1],
|
|
|
+ 'duration': duration,
|
|
|
+ 'min_ttc': group['TTC'].min()
|
|
|
+ })
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 8))
|
|
|
+ plt.plot(df['simTime'], df['TTC'], 'b-', label='TTC')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}s)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ # 添加橙色背景标识不安全事件
|
|
|
+ for idx, event in enumerate(unsafe_events):
|
|
|
+ label = 'Unsafe TTC Event' if idx == 0 else None
|
|
|
+ plt.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('TTC (s)')
|
|
|
+ plt.title('Time To Collision (TTC) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"ttc_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 记录不安全事件信息
|
|
|
+ if unsafe_events:
|
|
|
+ logger.info(f"检测到 {len(unsafe_events)} 个TTC不安全事件")
|
|
|
+ for i, event in enumerate(unsafe_events):
|
|
|
+ logger.info(f"TTC不安全事件 #{i+1}: 开始时间={event['start_time']:.2f}s, 结束时间={event['end_time']:.2f}s, 持续时间={event['duration']:.2f}s, 最小TTC={event['min_ttc']:.2f}s")
|
|
|
+
|
|
|
+ logger.info(f"TTC chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate TTC chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_mttc_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate MTTC metric chart with orange background for unsafe events
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ mttc_data = safety_calculator.mttc_data
|
|
|
+
|
|
|
+ if not mttc_data:
|
|
|
+ logger.warning("Cannot generate MTTC chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(mttc_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'MTTC')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 检测超阈值事件
|
|
|
+ unsafe_events = []
|
|
|
+ if min_threshold is not None:
|
|
|
+ # 对于MTTC，小于最小阈值视为不安全
|
|
|
+ unsafe_condition = df['MTTC'] < min_threshold
|
|
|
+ event_groups = (unsafe_condition != unsafe_condition.shift()).cumsum()
|
|
|
+
|
|
|
+ for _, group in df[unsafe_condition].groupby(event_groups):
|
|
|
+ if len(group) >= 2: # 至少2帧才算一次事件
|
|
|
+ start_time = group['simTime'].iloc[0]
|
|
|
+ end_time = group['simTime'].iloc[-1]
|
|
|
+ duration = end_time - start_time
|
|
|
+
|
|
|
+ if duration >= 0.1: # 只记录持续时间超过0.1秒的事件
|
|
|
+ unsafe_events.append({
|
|
|
+ 'start_time': start_time,
|
|
|
+ 'end_time': end_time,
|
|
|
+ 'start_frame': group['simFrame'].iloc[0],
|
|
|
+ 'end_frame': group['simFrame'].iloc[-1],
|
|
|
+ 'duration': duration,
|
|
|
+ 'min_mttc': group['MTTC'].min()
|
|
|
+ })
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['MTTC'], 'g-', label='MTTC')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}s)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ # 添加橙色背景标识不安全事件
|
|
|
+ for idx, event in enumerate(unsafe_events):
|
|
|
+ label = 'Unsafe MTTC Event' if idx == 0 else None
|
|
|
+ plt.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('MTTC (s)')
|
|
|
+ plt.title('Modified Time To Collision (MTTC) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"mttc_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"mttc_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ # 记录不安全事件信息
|
|
|
+ if unsafe_events:
|
|
|
+ logger.info(f"检测到 {len(unsafe_events)} 个MTTC不安全事件")
|
|
|
+ for i, event in enumerate(unsafe_events):
|
|
|
+ logger.info(f"MTTC不安全事件 #{i+1}: 开始时间={event['start_time']:.2f}s, 结束时间={event['end_time']:.2f}s, 持续时间={event['duration']:.2f}s, 最小MTTC={event['min_mttc']:.2f}s")
|
|
|
+
|
|
|
+ logger.info(f"MTTC chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"MTTC data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate MTTC chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_thw_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate THW metric chart with orange background for unsafe events
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ thw_data = safety_calculator.thw_data
|
|
|
+
|
|
|
+ if not thw_data:
|
|
|
+ logger.warning("Cannot generate THW chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(thw_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'THW')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 检测超阈值事件
|
|
|
+ unsafe_events = []
|
|
|
+ if min_threshold is not None:
|
|
|
+ # 对于THW，小于最小阈值视为不安全
|
|
|
+ unsafe_condition = df['THW'] < min_threshold
|
|
|
+ event_groups = (unsafe_condition != unsafe_condition.shift()).cumsum()
|
|
|
+
|
|
|
+ for _, group in df[unsafe_condition].groupby(event_groups):
|
|
|
+ if len(group) >= 2: # 至少2帧才算一次事件
|
|
|
+ start_time = group['simTime'].iloc[0]
|
|
|
+ end_time = group['simTime'].iloc[-1]
|
|
|
+ duration = end_time - start_time
|
|
|
+
|
|
|
+ if duration >= 0.1: # 只记录持续时间超过0.1秒的事件
|
|
|
+ unsafe_events.append({
|
|
|
+ 'start_time': start_time,
|
|
|
+ 'end_time': end_time,
|
|
|
+ 'start_frame': group['simFrame'].iloc[0],
|
|
|
+ 'end_frame': group['simFrame'].iloc[-1],
|
|
|
+ 'duration': duration,
|
|
|
+ 'min_thw': group['THW'].min()
|
|
|
+ })
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['THW'], 'c-', label='THW')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}s)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ # 添加橙色背景标识不安全事件
|
|
|
+ for idx, event in enumerate(unsafe_events):
|
|
|
+ label = 'Unsafe THW Event' if idx == 0 else None
|
|
|
+ plt.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('THW (s)')
|
|
|
+ plt.title('Time Headway (THW) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"thw_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"thw_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ # 记录不安全事件信息
|
|
|
+ if unsafe_events:
|
|
|
+ logger.info(f"检测到 {len(unsafe_events)} 个THW不安全事件")
|
|
|
+ for i, event in enumerate(unsafe_events):
|
|
|
+ logger.info(f"THW不安全事件 #{i+1}: 开始时间={event['start_time']:.2f}s, 结束时间={event['end_time']:.2f}s, 持续时间={event['duration']:.2f}s, 最小THW={event['min_thw']:.2f}s")
|
|
|
+
|
|
|
+ logger.info(f"THW chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"THW data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate THW chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_lonsd_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate Longitudinal Safe Distance metric chart
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ lonsd_data = safety_calculator.lonsd_data
|
|
|
+
|
|
|
+ if not lonsd_data:
|
|
|
+ logger.warning("Cannot generate Longitudinal Safe Distance chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(lonsd_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'LonSD')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['LonSD'], 'm-', label='Longitudinal Safe Distance')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}m)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold}m)')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Distance (m)')
|
|
|
+ plt.title('Longitudinal Safe Distance (LonSD) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"lonsd_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"lonsd_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ logger.info(f"Longitudinal Safe Distance chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"Longitudinal Safe Distance data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate Longitudinal Safe Distance chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_latsd_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate Lateral Safe Distance metric chart with orange background for unsafe events
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ latsd_data = safety_calculator.latsd_data
|
|
|
+
|
|
|
+ if not latsd_data:
|
|
|
+ logger.warning("Cannot generate Lateral Safe Distance chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(latsd_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'LatSD')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 检测超阈值事件
|
|
|
+ unsafe_events = []
|
|
|
+ if min_threshold is not None:
|
|
|
+ # 对于LatSD，小于最小阈值视为不安全
|
|
|
+ unsafe_condition = df['LatSD'] < min_threshold
|
|
|
+ event_groups = (unsafe_condition != unsafe_condition.shift()).cumsum()
|
|
|
+
|
|
|
+ for _, group in df[unsafe_condition].groupby(event_groups):
|
|
|
+ if len(group) >= 2: # 至少2帧才算一次事件
|
|
|
+ start_time = group['simTime'].iloc[0]
|
|
|
+ end_time = group['simTime'].iloc[-1]
|
|
|
+ duration = end_time - start_time
|
|
|
+
|
|
|
+ if duration >= 0.1: # 只记录持续时间超过0.1秒的事件
|
|
|
+ unsafe_events.append({
|
|
|
+ 'start_time': start_time,
|
|
|
+ 'end_time': end_time,
|
|
|
+ 'start_frame': group['simFrame'].iloc[0],
|
|
|
+ 'end_frame': group['simFrame'].iloc[-1],
|
|
|
+ 'duration': duration,
|
|
|
+ 'min_latsd': group['LatSD'].min()
|
|
|
+ })
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['LatSD'], 'y-', label='Lateral Safe Distance')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}m)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold}m)')
|
|
|
+
|
|
|
+ # 添加橙色背景标识不安全事件
|
|
|
+ for idx, event in enumerate(unsafe_events):
|
|
|
+ label = 'Unsafe LatSD Event' if idx == 0 else None
|
|
|
+ plt.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Distance (m)')
|
|
|
+ plt.title('Lateral Safe Distance (LatSD) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"latsd_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"latsd_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ # 记录不安全事件信息
|
|
|
+ if unsafe_events:
|
|
|
+ logger.info(f"检测到 {len(unsafe_events)} 个LatSD不安全事件")
|
|
|
+ for i, event in enumerate(unsafe_events):
|
|
|
+ logger.info(f"LatSD不安全事件 #{i+1}: 开始时间={event['start_time']:.2f}s, 结束时间={event['end_time']:.2f}s, 持续时间={event['duration']:.2f}s, 最小LatSD={event['min_latsd']:.2f}m")
|
|
|
+
|
|
|
+ logger.info(f"Lateral Safe Distance chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"Lateral Safe Distance data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate Lateral Safe Distance chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_btn_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate Brake Threat Number metric chart with orange background for unsafe events
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ btn_data = safety_calculator.btn_data
|
|
|
+
|
|
|
+ if not btn_data:
|
|
|
+ logger.warning("Cannot generate Brake Threat Number chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(btn_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'BTN')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 检测超阈值事件
|
|
|
+ unsafe_events = []
|
|
|
+ if max_threshold is not None:
|
|
|
+ # 对于BTN，大于最大阈值视为不安全
|
|
|
+ unsafe_condition = df['BTN'] > max_threshold
|
|
|
+ event_groups = (unsafe_condition != unsafe_condition.shift()).cumsum()
|
|
|
+
|
|
|
+ for _, group in df[unsafe_condition].groupby(event_groups):
|
|
|
+ if len(group) >= 2: # 至少2帧才算一次事件
|
|
|
+ start_time = group['simTime'].iloc[0]
|
|
|
+ end_time = group['simTime'].iloc[-1]
|
|
|
+ duration = end_time - start_time
|
|
|
+
|
|
|
+ if duration >= 0.1: # 只记录持续时间超过0.1秒的事件
|
|
|
+ unsafe_events.append({
|
|
|
+ 'start_time': start_time,
|
|
|
+ 'end_time': end_time,
|
|
|
+ 'start_frame': group['simFrame'].iloc[0],
|
|
|
+ 'end_frame': group['simFrame'].iloc[-1],
|
|
|
+ 'duration': duration,
|
|
|
+ 'max_btn': group['BTN'].max()
|
|
|
+ })
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['BTN'], 'r-', label='Brake Threat Number')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold})')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ # 添加橙色背景标识不安全事件
|
|
|
+ for idx, event in enumerate(unsafe_events):
|
|
|
+ label = 'Unsafe BTN Event' if idx == 0 else None
|
|
|
+ plt.axvspan(event['start_time'], event['end_time'],
|
|
|
+ alpha=0.3, color='orange', label=label)
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('BTN')
|
|
|
+ plt.title('Brake Threat Number (BTN) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"btn_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"btn_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ # 记录不安全事件信息
|
|
|
+ if unsafe_events:
|
|
|
+ logger.info(f"检测到 {len(unsafe_events)} 个BTN不安全事件")
|
|
|
+ for i, event in enumerate(unsafe_events):
|
|
|
+ logger.info(f"BTN不安全事件 #{i+1}: 开始时间={event['start_time']:.2f}s, 结束时间={event['end_time']:.2f}s, 持续时间={event['duration']:.2f}s, 最大BTN={event['max_btn']:.2f}")
|
|
|
+
|
|
|
+ logger.info(f"Brake Threat Number chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"Brake Threat Number data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate Brake Threat Number chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_collision_risk_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate Collision Risk metric chart
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ risk_data = safety_calculator.collision_risk_data
|
|
|
+
|
|
|
+ if not risk_data:
|
|
|
+ logger.warning("Cannot generate Collision Risk chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(risk_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'collisionRisk')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['collisionRisk'], 'r-', label='Collision Risk')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}%)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold}%)')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Risk Value (%)')
|
|
|
+ plt.title('Collision Risk (collisionRisk) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"collision_risk_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"collisionrisk_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ logger.info(f"Collision Risk chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"Collision Risk data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate Collision Risk chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_collision_severity_chart(safety_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate Collision Severity metric chart
|
|
|
+
|
|
|
+ Args:
|
|
|
+ safety_calculator: SafetyCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ severity_data = safety_calculator.collision_severity_data
|
|
|
+
|
|
|
+ if not severity_data:
|
|
|
+ logger.warning("Cannot generate Collision Severity chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 创建DataFrame
|
|
|
+ df = pd.DataFrame(severity_data)
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(safety_calculator, 'collisionSeverity')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 创建图表
|
|
|
+ plt.figure(figsize=(12, 6))
|
|
|
+ plt.plot(df['simTime'], df['collisionSeverity'], 'r-', label='Collision Severity')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if min_threshold is not None:
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle='--', label=f'Min Threshold ({min_threshold}%)')
|
|
|
+ if max_threshold is not None:
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle='--', label=f'Max Threshold ({max_threshold}%)')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Severity (%)')
|
|
|
+ plt.title('Collision Severity (collisionSeverity) Trend')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 保存图表
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+ chart_filename = os.path.join(output_dir, f"collision_severity_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ # 保存CSV数据，包含阈值信息
|
|
|
+ csv_filename = os.path.join(output_dir, f"collisionseverity_data_{timestamp}.csv")
|
|
|
+ df_csv = df.copy()
|
|
|
+ df_csv['min_threshold'] = min_threshold
|
|
|
+ df_csv['max_threshold'] = max_threshold
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+
|
|
|
+ logger.info(f"Collision Severity chart saved to: {chart_filename}")
|
|
|
+ logger.info(f"Collision Severity data saved to: {csv_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate Collision Severity chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_vdv_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate VDV (Vibration Dose Value) metric chart with data saved to CSV first.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ vdv_value = comfort_calculator.calculated_value.get('vdv', 0)
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate VDV chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 确保有必要的列
|
|
|
+ if 'accelX' not in df.columns or 'accelY' not in df.columns:
|
|
|
+ logger.warning("Missing required columns for VDV chart")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(comfort_calculator, 'vdv')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 将东北天坐标系下的加速度转换为车身坐标系下的加速度
|
|
|
+ if 'posH' not in df.columns:
|
|
|
+ logger.warning("Missing heading angle data for coordinate transformation")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 车身坐标系：X轴指向车头，Y轴指向车辆左侧，Z轴指向车顶
|
|
|
+ df['posH_rad'] = np.radians(df['posH'])
|
|
|
+
|
|
|
+ # 转换加速度到车身坐标系
|
|
|
+ df['a_x_body'] = df['accelX'] * np.sin(df['posH_rad']) + df['accelY'] * np.cos(df['posH_rad'])
|
|
|
+ df['a_y_body'] = df['accelX'] * np.cos(df['posH_rad']) - df['accelY'] * np.sin(df['posH_rad'])
|
|
|
+ df['a_z_body'] = df['accelZ'] if 'accelZ' in df.columns else pd.Series(np.zeros(len(df)))
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"vdv_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'a_x_body': df['a_x_body'],
|
|
|
+ 'a_y_body': df['a_y_body'],
|
|
|
+ 'a_z_body': df['a_z_body'],
|
|
|
+ 'v': df['v'],
|
|
|
+ 'min_threshold': min_threshold,
|
|
|
+ 'max_threshold': max_threshold,
|
|
|
+ 'vdv_value': vdv_value
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"VDV data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 8))
|
|
|
+
|
|
|
+ # 绘制三轴加速度
|
|
|
+ plt.subplot(3, 1, 1)
|
|
|
+ plt.plot(df['simTime'], df['a_x_body'], 'r-', label='X-axis Acceleration')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if 'min_threshold' in df.columns and df['min_threshold'].iloc[0] is not None:
|
|
|
+ min_threshold = df['min_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle=':', label=f'Min Threshold ({min_threshold})')
|
|
|
+ if 'max_threshold' in df.columns and df['max_threshold'].iloc[0] is not None:
|
|
|
+ max_threshold = df['max_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle=':', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body X-axis Acceleration (Longitudinal)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 1, 2)
|
|
|
+ plt.plot(df['simTime'], df['a_y_body'], 'g-', label='Y-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body Y-axis Acceleration (Lateral)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 1, 3)
|
|
|
+ plt.plot(df['simTime'], df['a_z_body'], 'b-', label='Z-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ vdv_value = df['vdv_value'].iloc[0] if 'vdv_value' in df.columns else 0
|
|
|
+ plt.title(f'Body Z-axis Acceleration (Vertical) - VDV value: {vdv_value:.4f}')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.tight_layout()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"vdv_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"VDV chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate VDV chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_ava_vav_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate AVA_VAV (Average Vibration Acceleration Value) metric chart with data saved to CSV first.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ ava_vav_value = comfort_calculator.calculated_value.get('ava_vav', 0)
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate AVA_VAV chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 确保有必要的列
|
|
|
+ if 'accelX' not in df.columns or 'accelY' not in df.columns:
|
|
|
+ logger.warning("Missing required columns for AVA_VAV chart")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(comfort_calculator, 'ava_vav')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 将东北天坐标系下的加速度转换为车身坐标系下的加速度
|
|
|
+ if 'posH' not in df.columns:
|
|
|
+ logger.warning("Missing heading angle data for coordinate transformation")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 车身坐标系：X轴指向车头，Y轴指向车辆左侧，Z轴指向车顶
|
|
|
+ df['posH_rad'] = np.radians(df['posH'])
|
|
|
+
|
|
|
+ # 转换加速度到车身坐标系
|
|
|
+ df['a_x_body'] = df['accelX'] * np.sin(df['posH_rad']) + df['accelY'] * np.cos(df['posH_rad'])
|
|
|
+ df['a_y_body'] = df['accelX'] * np.cos(df['posH_rad']) - df['accelY'] * np.sin(df['posH_rad'])
|
|
|
+ df['a_z_body'] = df['accelZ'] if 'accelZ' in df.columns else pd.Series(np.zeros(len(df)))
|
|
|
+
|
|
|
+ # 角速度数据
|
|
|
+ df['omega_roll'] = df['rollRate'] if 'rollRate' in df.columns else pd.Series(np.zeros(len(df)))
|
|
|
+ df['omega_pitch'] = df['pitchRate'] if 'pitchRate' in df.columns else pd.Series(np.zeros(len(df)))
|
|
|
+ df['omega_yaw'] = df['speedH'] # 使用航向角速度作为偏航角速度
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"ava_vav_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'a_x_body': df['a_x_body'],
|
|
|
+ 'a_y_body': df['a_y_body'],
|
|
|
+ 'a_z_body': df['a_z_body'],
|
|
|
+ 'omega_roll': df['omega_roll'],
|
|
|
+ 'omega_pitch': df['omega_pitch'],
|
|
|
+ 'omega_yaw': df['omega_yaw'],
|
|
|
+ 'min_threshold': min_threshold,
|
|
|
+ 'max_threshold': max_threshold,
|
|
|
+ 'ava_vav_value': ava_vav_value
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"AVA_VAV data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 10))
|
|
|
+
|
|
|
+ # 绘制三轴加速度
|
|
|
+ plt.subplot(3, 2, 1)
|
|
|
+ plt.plot(df['simTime'], df['a_x_body'], 'r-', label='X-axis Acceleration')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if 'min_threshold' in df.columns and df['min_threshold'].iloc[0] is not None:
|
|
|
+ min_threshold = df['min_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle=':', label=f'Min Threshold ({min_threshold})')
|
|
|
+ if 'max_threshold' in df.columns and df['max_threshold'].iloc[0] is not None:
|
|
|
+ max_threshold = df['max_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle=':', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body X-axis Acceleration (Longitudinal)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 2, 3)
|
|
|
+ plt.plot(df['simTime'], df['a_y_body'], 'g-', label='Y-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body Y-axis Acceleration (Lateral)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 2, 5)
|
|
|
+ plt.plot(df['simTime'], df['a_z_body'], 'b-', label='Z-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body Z-axis Acceleration (Vertical)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ # 绘制三轴角速度
|
|
|
+ plt.subplot(3, 2, 2)
|
|
|
+ plt.plot(df['simTime'], df['omega_roll'], 'r-', label='Roll Rate')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Angular Velocity (deg/s)')
|
|
|
+ plt.title('Roll Rate')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 2, 4)
|
|
|
+ plt.plot(df['simTime'], df['omega_pitch'], 'g-', label='Pitch Rate')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Angular Velocity (deg/s)')
|
|
|
+ plt.title('Pitch Rate')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 2, 6)
|
|
|
+ plt.plot(df['simTime'], df['omega_yaw'], 'b-', label='Yaw Rate')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Angular Velocity (deg/s)')
|
|
|
+ ava_vav_value = df['ava_vav_value'].iloc[0] if 'ava_vav_value' in df.columns else 0
|
|
|
+ plt.title(f'Yaw Rate - AVA_VAV value: {ava_vav_value:.4f}')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.tight_layout()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"ava_vav_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"AVA_VAV chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate AVA_VAV chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_msdv_chart(comfort_calculator, output_dir: str) -> Optional[str]:
|
|
|
+ """
|
|
|
+ Generate MSDV (Motion Sickness Dose Value) metric chart with data saved to CSV first.
|
|
|
+ This version first saves data to CSV, then uses the CSV to generate the chart.
|
|
|
+
|
|
|
+ Args:
|
|
|
+ comfort_calculator: ComfortCalculator instance
|
|
|
+ output_dir: Output directory
|
|
|
+
|
|
|
+ Returns:
|
|
|
+ str: Chart file path, or None if generation fails
|
|
|
+ """
|
|
|
+ logger = LogManager().get_logger()
|
|
|
+
|
|
|
+ try:
|
|
|
+ # 获取数据
|
|
|
+ df = comfort_calculator.ego_df.copy()
|
|
|
+ msdv_value = comfort_calculator.calculated_value.get('msdv', 0)
|
|
|
+ motion_sickness_prob = comfort_calculator.calculated_value.get('motionSickness', 0)
|
|
|
+
|
|
|
+ if df.empty:
|
|
|
+ logger.warning("Cannot generate MSDV chart: empty data")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 确保有必要的列
|
|
|
+ if 'accelX' not in df.columns or 'accelY' not in df.columns:
|
|
|
+ logger.warning("Missing required columns for MSDV chart")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 获取阈值
|
|
|
+ thresholds = get_metric_thresholds(comfort_calculator, 'msdv')
|
|
|
+ min_threshold = thresholds.get('min')
|
|
|
+ max_threshold = thresholds.get('max')
|
|
|
+
|
|
|
+ # 将东北天坐标系下的加速度转换为车身坐标系下的加速度
|
|
|
+ if 'posH' not in df.columns:
|
|
|
+ logger.warning("Missing heading angle data for coordinate transformation")
|
|
|
+ return None
|
|
|
+
|
|
|
+ # 车身坐标系：X轴指向车头，Y轴指向车辆左侧，Z轴指向车顶
|
|
|
+ df['posH_rad'] = np.radians(df['posH'])
|
|
|
+
|
|
|
+ # 转换加速度到车身坐标系
|
|
|
+ df['a_x_body'] = df['accelX'] * np.sin(df['posH_rad']) + df['accelY'] * np.cos(df['posH_rad'])
|
|
|
+ df['a_y_body'] = df['accelX'] * np.cos(df['posH_rad']) - df['accelY'] * np.sin(df['posH_rad'])
|
|
|
+ df['a_z_body'] = df['accelZ'] if 'accelZ' in df.columns else pd.Series(np.zeros(len(df)))
|
|
|
+
|
|
|
+ # 生成时间戳
|
|
|
+ import datetime
|
|
|
+ timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
|
|
|
+
|
|
|
+ # 保存 CSV 数据（第一步）
|
|
|
+ csv_filename = os.path.join(output_dir, f"msdv_data_{timestamp}.csv")
|
|
|
+ df_csv = pd.DataFrame({
|
|
|
+ 'simTime': df['simTime'],
|
|
|
+ 'a_x_body': df['a_x_body'],
|
|
|
+ 'a_y_body': df['a_y_body'],
|
|
|
+ 'a_z_body': df['a_z_body'],
|
|
|
+ 'v': df['v'],
|
|
|
+ 'min_threshold': min_threshold,
|
|
|
+ 'max_threshold': max_threshold,
|
|
|
+ 'msdv_value': msdv_value,
|
|
|
+ 'motion_sickness_prob': motion_sickness_prob
|
|
|
+ })
|
|
|
+ df_csv.to_csv(csv_filename, index=False)
|
|
|
+ logger.info(f"MSDV data saved to: {csv_filename}")
|
|
|
+
|
|
|
+ # 第二步：从 CSV 读取（可验证保存数据无误）
|
|
|
+ df = pd.read_csv(csv_filename)
|
|
|
+
|
|
|
+ # 创建图表（第三步）
|
|
|
+ plt.figure(figsize=(12, 8))
|
|
|
+
|
|
|
+ # 绘制三轴加速度
|
|
|
+ plt.subplot(3, 1, 1)
|
|
|
+ plt.plot(df['simTime'], df['a_x_body'], 'r-', label='X-axis Acceleration')
|
|
|
+
|
|
|
+ # 添加阈值线
|
|
|
+ if 'min_threshold' in df.columns and df['min_threshold'].iloc[0] is not None:
|
|
|
+ min_threshold = df['min_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=min_threshold, color='r', linestyle=':', label=f'Min Threshold ({min_threshold})')
|
|
|
+ if 'max_threshold' in df.columns and df['max_threshold'].iloc[0] is not None:
|
|
|
+ max_threshold = df['max_threshold'].iloc[0]
|
|
|
+ plt.axhline(y=max_threshold, color='g', linestyle=':', label=f'Max Threshold ({max_threshold})')
|
|
|
+
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body X-axis Acceleration (Longitudinal)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 1, 2)
|
|
|
+ plt.plot(df['simTime'], df['a_y_body'], 'g-', label='Y-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ plt.title('Body Y-axis Acceleration (Lateral)')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.subplot(3, 1, 3)
|
|
|
+ plt.plot(df['simTime'], df['a_z_body'], 'b-', label='Z-axis Acceleration')
|
|
|
+ plt.xlabel('Time (s)')
|
|
|
+ plt.ylabel('Acceleration (m/s²)')
|
|
|
+ msdv_value = df['msdv_value'].iloc[0] if 'msdv_value' in df.columns else 0
|
|
|
+ motion_sickness_prob = df['motion_sickness_prob'].iloc[0] if 'motion_sickness_prob' in df.columns else 0
|
|
|
+ plt.title(f'Body Z-axis Acceleration (Vertical) - MSDV: {msdv_value:.4f}, Motion Sickness Probability: {motion_sickness_prob:.2f}%')
|
|
|
+ plt.grid(True)
|
|
|
+ plt.legend()
|
|
|
+
|
|
|
+ plt.tight_layout()
|
|
|
+
|
|
|
+ # 保存图像
|
|
|
+ chart_filename = os.path.join(output_dir, f"msdv_chart_{timestamp}.png")
|
|
|
+ plt.savefig(chart_filename, dpi=300)
|
|
|
+ plt.close()
|
|
|
+
|
|
|
+ logger.info(f"MSDV chart saved to: {chart_filename}")
|
|
|
+ return chart_filename
|
|
|
+
|
|
|
+ except Exception as e:
|
|
|
+ logger.error(f"Failed to generate MSDV chart: {str(e)}", exc_info=True)
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_traffic_chart_data(traffic_calculator, metric_name: str, output_dir: Optional[str] = None) -> Optional[str]:
|
|
|
+ """Generate chart data for traffic metrics"""
|
|
|
+ # 待实现
|
|
|
+ return None
|
|
|
+
|
|
|
+def generate_function_chart_data(function_calculator, metric_name: str, output_dir: Optional[str] = None) -> Optional[str]:
|
|
|
+ """Generate chart data for function metrics"""
|
|
|
+ # 待实现
|
|
|
+ return None
|
