diff --git a/src/autonomus_drone_hand_gesture_project/gesture_config.json b/src/autonomus_drone_hand_gesture_project/gesture_config.json index 7286a11db4..fb3da8e6fd 100644 --- a/src/autonomus_drone_hand_gesture_project/gesture_config.json +++ b/src/autonomus_drone_hand_gesture_project/gesture_config.json @@ -18,11 +18,11 @@ }, "gesture": { "skin_lower_h": 0, - "skin_upper_h": 180, + "skin_upper_h": 175, "skin_lower_s": 0, - "skin_upper_s": 165, - "skin_lower_v": 16, - "skin_upper_v": 255, + "skin_upper_s": 87, + "skin_lower_v": 0, + "skin_upper_v": 95, "min_hand_area": 3000, "max_hand_area": 30000, "hand_ratio_threshold": 1.5, @@ -111,8 +111,8 @@ "target_fps": 30, "resize_factor": 1.0, "enable_multiprocessing": false, - "mode": "balanced", - "current_mode_index": 1, + "mode": "accurate", + "current_mode_index": 2, "modes": [ "fast", "balanced", @@ -138,7 +138,7 @@ "min_calibration_samples": 50 }, "speech": { - "enabled": true, + "enabled": false, "volume": 1.0, "rate": 150, "announce_gestures": true, diff --git a/src/autonomus_drone_hand_gesture_project/gesture_recognizer.py b/src/autonomus_drone_hand_gesture_project/gesture_recognizer.py index 7f7c93840c..aa8baee682 100644 --- a/src/autonomus_drone_hand_gesture_project/gesture_recognizer.py +++ b/src/autonomus_drone_hand_gesture_project/gesture_recognizer.py @@ -132,8 +132,15 @@ def __init__(self, speech_manager=None, config=None): self.performance_mode_color = self.mode_config['color'] self.performance_mode_name = self.mode_config['name'] + # UI渲染器引用(稍后设置) + self.ui_renderer = None + print(f"✓ 增强的手势识别器已初始化 - 性能模式: {self.performance_mode_name}") + def set_ui_renderer(self, ui_renderer): + """设置UI渲染器""" + self.ui_renderer = ui_renderer + def set_performance_mode(self, mode): """设置性能模式""" self.performance_mode = mode @@ -656,27 +663,72 @@ def visualize_detection(self, frame, hand_data, gesture, confidence): # 显示手势标签 label = f"{gesture}" if self.config.get('display', 'show_confidence'): - label += f" ({confidence:.0%})" + # 使用UI渲染器绘制文本,避免字体问题 + if self.ui_renderer: + # 首先绘制手势名称 + gesture_text = f"{gesture}" + + # 计算文本位置 + (text_width, text_height), baseline = cv2.getTextSize( + gesture_text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2 + ) + + # 绘制文本背景 + cv2.rectangle(frame, + (x1, y1 - text_height - 10), + (x1 + text_width, y1), + color, -1) + + # 使用UI渲染器绘制手势名称 + frame = self.ui_renderer.draw_text(frame, gesture_text, + (x1, y1 - 5), + size=16, color=(255, 255, 255)) + + # 绘制置信度(使用UI渲染器确保正确显示) + confidence_text = f"{confidence:.0%}" + # 计算置信度文本位置 + frame = self.ui_renderer.draw_text(frame, confidence_text, + (x1 + text_width + 5, y1 - 5), + size=16, color=(255, 255, 255)) + else: + # 备用方案 + label += f" ({confidence:.0%})" + (text_width, text_height), baseline = cv2.getTextSize( + label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2 + ) + + cv2.rectangle(frame, + (x1, y1 - text_height - 10), + (x1 + text_width, y1), + color, -1) + cv2.putText(frame, label, (x1, y1 - 5), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) + else: + # 不使用置信度显示 + (text_width, text_height), baseline = cv2.getTextSize( + label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2 + ) + + cv2.rectangle(frame, + (x1, y1 - text_height - 10), + (x1 + text_width, y1), + color, -1) + cv2.putText(frame, label, (x1, y1 - 5), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) # 显示手势状态 if self.gesture_state != "none": - state_text = {"starting": "开始", "active": "活跃", "ending": "结束"} - label += f" [{state_text.get(self.gesture_state, '')}]" - - # 计算文本大小 - (text_width, text_height), baseline = cv2.getTextSize( - label, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2 - ) - - # 绘制文本背景 - cv2.rectangle(frame, - (x1, y1 - text_height - 10), - (x1 + text_width, y1), - color, -1) - - # 绘制文本 - cv2.putText(frame, label, (x1, y1 - 5), - cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) + state_text = {"starting": "Starting", "active": "Active", "ending": "Ending"} + state_label = f" [{state_text.get(self.gesture_state, '')}]" + + # 使用UI渲染器绘制状态文本 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, state_label, + (x1, y1 - 30), + size=14, color=color) + else: + cv2.putText(frame, state_label, (x1, y1 - 30), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1) # 绘制手掌中心 if show_palm_center and 'palm_center' in hand_data: @@ -684,15 +736,27 @@ def visualize_detection(self, frame, hand_data, gesture, confidence): palm_radius = hand_data.get('palm_radius', 20) cv2.circle(frame, (cx, cy), 5, (0, 0, 255), -1) cv2.circle(frame, (cx, cy), palm_radius, (0, 0, 255), 1) - cv2.putText(frame, "Palm", (cx + 10, cy), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) + # 使用UI渲染器绘制"Palm"文本 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, "Palm", + (cx + 10, cy), + size=14, color=(0, 0, 255)) + else: + cv2.putText(frame, "Palm", (cx + 10, cy), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1) # 绘制指尖 if show_fingertips and 'fingertips' in hand_data: for i, point in enumerate(hand_data['fingertips']): cv2.circle(frame, point, 4, (255, 0, 0), -1) - cv2.putText(frame, f"F{i + 1}", (point[0] + 5, point[1]), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1) + # 使用UI渲染器绘制指尖编号 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, f"F{i+1}", + (point[0] + 5, point[1]), + size=14, color=(255, 0, 0)) + else: + cv2.putText(frame, f"F{i+1}", (point[0] + 5, point[1]), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 1) # 绘制手部方向 if show_hand_direction and 'direction' in hand_data and 'center' in hand_data: @@ -707,8 +771,14 @@ def visualize_detection(self, frame, hand_data, gesture, confidence): cv2.arrowedLine(frame, (cx, cy), end_point, (255, 255, 0), 2) angle_text = f"Dir: {direction:.0f}°" - cv2.putText(frame, angle_text, (cx, cy - 20), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1) + # 使用UI渲染器绘制方向文本 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, angle_text, + (cx, cy - 20), + size=14, color=(255, 255, 0)) + else: + cv2.putText(frame, angle_text, (cx, cy - 20), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1) # 绘制稳定性指示器 if show_stability_indicator: @@ -738,8 +808,13 @@ def visualize_detection(self, frame, hand_data, gesture, confidence): (indicator_x + 5 + bar_length, indicator_y + 10), bar_color, -1) # 绘制稳定性文本 - cv2.putText(frame, "稳定度", (indicator_x, indicator_y - 5), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, "稳定度", + (indicator_x, indicator_y - 5), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, "稳定度", (indicator_x, indicator_y - 5), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) # 绘制手势历史 if show_gesture_history and len(self.gesture_history) > 0: @@ -748,35 +823,69 @@ def visualize_detection(self, frame, hand_data, gesture, confidence): # 绘制历史背景 cv2.rectangle(frame, (10, history_y - 20), (200, history_y + 10), (0, 0, 0), -1) - cv2.putText(frame, "手势历史:", (15, history_y), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + + # 使用UI渲染器绘制历史标题 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, "手势历史:", + (15, history_y), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, "手势历史:", (15, history_y), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) # 显示最近几个手势 recent_gestures = list(self.gesture_history)[-5:] if len(self.gesture_history) >= 5 else list( self.gesture_history) for i, gest in enumerate(recent_gestures): color = self.gesture_colors.get(gest, (255, 255, 255)) - cv2.putText(frame, gest[0], (85 + i * 20, history_y), - cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2) + # 使用UI渲染器绘制手势历史 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, gest[0], + (85 + i * 20, history_y), + size=16, color=color) + else: + cv2.putText(frame, gest[0], (85 + i * 20, history_y), + cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2) # 显示调试信息 if show_debug_info: finger_count = len(hand_data.get('fingers', [])) finger_text = f"Fingers: {finger_count}" - cv2.putText(frame, finger_text, (10, frame.shape[0] - 30), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + # 使用UI渲染器绘制调试信息 + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, finger_text, + (10, frame.shape[0] - 30), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, finger_text, (10, frame.shape[0] - 30), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) pos_text = f"Pos: ({hand_data['position'][0]:.2f}, {hand_data['position'][1]:.2f})" - cv2.putText(frame, pos_text, (10, frame.shape[0] - 10), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, pos_text, + (10, frame.shape[0] - 10), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, pos_text, (10, frame.shape[0] - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) state_text = f"State: {self.gesture_state}" - cv2.putText(frame, state_text, (150, frame.shape[0] - 30), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, state_text, + (150, frame.shape[0] - 30), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, state_text, (150, frame.shape[0] - 30), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) stability_text = f"Stability: {self.gesture_stability_counter}" - cv2.putText(frame, stability_text, (150, frame.shape[0] - 10), - cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) + if self.ui_renderer: + frame = self.ui_renderer.draw_text(frame, stability_text, + (150, frame.shape[0] - 10), + size=14, color=(255, 255, 255)) + else: + cv2.putText(frame, stability_text, (150, frame.shape[0] - 10), + cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1) return frame diff --git a/src/autonomus_drone_hand_gesture_project/main.py b/src/autonomus_drone_hand_gesture_project/main.py index 0c193452d7..15368704bf 100644 --- a/src/autonomus_drone_hand_gesture_project/main.py +++ b/src/autonomus_drone_hand_gesture_project/main.py @@ -239,6 +239,9 @@ def main(): drone_controller = SimpleDroneController(libs['airsim'], speech_manager, config) ui_renderer = ChineseUIRenderer(speech_manager, config) + # 设置手势识别器的UI渲染器引用 + gesture_recognizer.set_ui_renderer(ui_renderer) + # 初始化性能分析器 print("初始化性能分析器...") performance_analyzer = PerformanceAnalyzer(speech_manager, libs.get('psutil'), config) @@ -449,6 +452,8 @@ def main(): # 重置手势识别 print("重置手势识别...") gesture_recognizer = EnhancedGestureRecognizer(speech_manager, config) + # 重新设置UI渲染器引用 + gesture_recognizer.set_ui_renderer(ui_renderer) print("✓ 手势识别已重置") # 语音提示 diff --git a/src/autonomus_drone_hand_gesture_project/performance_analyzer.py b/src/autonomus_drone_hand_gesture_project/performance_analyzer.py index 6ae0ab4c1c..c7a8d7cd8c 100644 --- a/src/autonomus_drone_hand_gesture_project/performance_analyzer.py +++ b/src/autonomus_drone_hand_gesture_project/performance_analyzer.py @@ -10,9 +10,10 @@ import numpy as np from datetime import datetime from collections import deque, Counter +import statistics class PerformanceAnalyzer: - """性能分析器 - 监控和报告系统性能""" + """增强的性能分析器 - 监控和报告系统性能""" def __init__(self, speech_manager=None, psutil_lib=None, config=None): self.speech_manager = speech_manager @@ -22,63 +23,97 @@ def __init__(self, speech_manager=None, psutil_lib=None, config=None): self.session_start_time = time.time() # 帧率统计 - self.frame_times = deque(maxlen=300) + self.frame_times = deque(maxlen=500) # 增加到500 self.frame_count = 0 - self.fps_history = deque(maxlen=100) + self.fps_history = deque(maxlen=200) # 增加到200 + self.frame_time_history = deque(maxlen=100) # 新增:帧时间历史 # 手势识别性能 - self.gesture_recognition_times = deque(maxlen=100) + self.gesture_recognition_times = deque(maxlen=200) self.avg_recognition_time = 0 self.max_recognition_time = 0 + self.min_recognition_time = float('inf') + self.recognition_time_std = 0 # 系统资源监控 - self.cpu_usage_history = deque(maxlen=100) - self.memory_usage_history = deque(maxlen=100) + self.cpu_usage_history = deque(maxlen=200) + self.memory_usage_history = deque(maxlen=200) + self.cpu_trend = deque(maxlen=50) # CPU使用趋势 + self.memory_trend = deque(maxlen=50) # 内存使用趋势 # 性能事件记录 self.performance_events = [] self.performance_snapshots = [] + self.performance_anomalies = [] # 新增:性能异常记录 # 手势统计 self.gesture_counts = {} self.gesture_confidence_sum = {} self.gesture_confidence_count = {} + self.gesture_recognition_latency = {} # 新增:手势识别延迟 # 错误统计 self.error_count = 0 self.warning_count = 0 + self.critical_count = 0 # 无人机控制统计 self.drone_commands = 0 self.successful_commands = 0 self.failed_commands = 0 + self.command_latency_history = deque(maxlen=100) # 新增:命令延迟 # 轨迹记录统计 self.recording_sessions = 0 self.total_trajectory_points = 0 + self.trajectory_recording_time = 0 # 性能日志 self.performance_log = [] + self.anomaly_log = [] # 新增:异常日志 self.log_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'performance_log.csv') + self.anomaly_log_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'anomaly_log.csv') # 性能阈值 self.performance_thresholds = { + 'fps_excellent': 30, + 'fps_good': 20, 'fps_warning': 15, 'fps_critical': 5, + 'cpu_excellent': 40, + 'cpu_good': 60, 'cpu_warning': 80, 'cpu_critical': 90, + 'memory_excellent': 50, + 'memory_good': 70, 'memory_warning': 85, 'memory_critical': 95, + 'recognition_excellent': 20, + 'recognition_good': 35, 'recognition_warning': 50, - 'recognition_critical': 100 + 'recognition_critical': 100, + 'frame_time_excellent': 33, # 对应30fps + 'frame_time_warning': 66, # 对应15fps + 'frame_time_critical': 200, # 对应5fps } # 性能状态 - self.performance_status = "良好" + self.performance_status = "优秀" + self.performance_score = 100 # 新增:性能评分 self.last_performance_report = 0 self.auto_report_interval = 60 - print("✓ 性能分析器已初始化") + # 趋势分析 + self.fps_trend = "稳定" + self.cpu_trend = "稳定" + self.memory_trend = "稳定" + + # 异常检测 + self.anomaly_detection_enabled = True + self.last_anomaly_check = 0 + self.anomaly_check_interval = 10 + + print("✓ 增强的性能分析器已初始化") def update_frame(self): """更新帧统计""" @@ -93,14 +128,98 @@ def update_frame(self): current_fps = (len(self.frame_times) - 1) / time_span self.fps_history.append(current_fps) + # 计算帧时间(毫秒) + if len(self.frame_times) >= 2: + frame_time = (self.frame_times[-1] - self.frame_times[-2]) * 1000 + self.frame_time_history.append(frame_time) + + # 更新性能评分 + self.update_performance_score() + + def update_performance_score(self): + """更新性能评分""" + score = 100 + + # 基于FPS评分 + if len(self.fps_history) > 0: + avg_fps = self.get_average_fps() + if avg_fps >= self.performance_thresholds['fps_excellent']: + score -= 0 + elif avg_fps >= self.performance_thresholds['fps_good']: + score -= 10 + elif avg_fps >= self.performance_thresholds['fps_warning']: + score -= 25 + elif avg_fps >= self.performance_thresholds['fps_critical']: + score -= 50 + else: + score -= 70 + + # 基于CPU评分 + cpu_usage = self.get_current_cpu_usage() + if cpu_usage <= self.performance_thresholds['cpu_excellent']: + score -= 0 + elif cpu_usage <= self.performance_thresholds['cpu_good']: + score -= 5 + elif cpu_usage <= self.performance_thresholds['cpu_warning']: + score -= 15 + elif cpu_usage <= self.performance_thresholds['cpu_critical']: + score -= 30 + else: + score -= 50 + + # 基于内存评分 + memory_usage = self.get_current_memory_usage() + if memory_usage <= self.performance_thresholds['memory_excellent']: + score -= 0 + elif memory_usage <= self.performance_thresholds['memory_good']: + score -= 5 + elif memory_usage <= self.performance_thresholds['memory_warning']: + score -= 15 + elif memory_usage <= self.performance_thresholds['memory_critical']: + score -= 30 + else: + score -= 50 + + # 基于识别时间评分 + if self.avg_recognition_time > 0: + if self.avg_recognition_time <= self.performance_thresholds['recognition_excellent']: + score -= 0 + elif self.avg_recognition_time <= self.performance_thresholds['recognition_good']: + score -= 5 + elif self.avg_recognition_time <= self.performance_thresholds['recognition_warning']: + score -= 15 + elif self.avg_recognition_time <= self.performance_thresholds['recognition_critical']: + score -= 30 + else: + score -= 50 + + self.performance_score = max(0, min(100, score)) + + # 更新性能状态 + if self.performance_score >= 90: + self.performance_status = "优秀" + elif self.performance_score >= 70: + self.performance_status = "良好" + elif self.performance_score >= 50: + self.performance_status = "一般" + elif self.performance_score >= 30: + self.performance_status = "警告" + else: + self.performance_status = "严重" + def update_gesture_recognition_time(self, recognition_time_ms): """更新手势识别时间""" self.gesture_recognition_times.append(recognition_time_ms) - # 更新平均识别时间 + # 更新识别时间统计 if len(self.gesture_recognition_times) > 0: - self.avg_recognition_time = np.mean(list(self.gesture_recognition_times)) + times_list = list(self.gesture_recognition_times) + self.avg_recognition_time = np.mean(times_list) self.max_recognition_time = max(self.max_recognition_time, recognition_time_ms) + self.min_recognition_time = min(self.min_recognition_time, recognition_time_ms) + + if len(times_list) >= 2: + self.recognition_time_std = np.std(times_list) def update_system_resources(self): """更新系统资源使用情况""" @@ -112,53 +231,158 @@ def update_system_resources(self): self.cpu_usage_history.append(cpu_percent) self.memory_usage_history.append(memory_percent) - # 检查性能问题 + # 更新趋势 + if len(self.cpu_usage_history) >= 10: + recent_cpu = list(self.cpu_usage_history)[-10:] + self.cpu_trend.append(statistics.mean(recent_cpu)) + + if len(self.memory_usage_history) >= 10: + recent_memory = list(self.memory_usage_history)[-10:] + self.memory_trend.append(statistics.mean(recent_memory)) + + # 检查性能问题和异常 self.check_performance_issues(cpu_percent, memory_percent) + self.detect_anomalies() except: pass + def detect_anomalies(self): + """检测性能异常""" + if not self.anomaly_detection_enabled: + return + + current_time = time.time() + if current_time - self.last_anomaly_check < self.anomaly_check_interval: + return + + self.last_anomaly_check = current_time + + anomalies = [] + + # 检测FPS异常 + if len(self.fps_history) >= 10: + recent_fps = list(self.fps_history)[-10:] + avg_fps = statistics.mean(recent_fps) + std_fps = statistics.stdev(recent_fps) if len(recent_fps) > 1 else 0 + + # 如果FPS突然下降超过50% + if len(self.fps_history) >= 20: + older_fps = list(self.fps_history)[-20:-10] + if len(older_fps) > 0: + older_avg = statistics.mean(older_fps) + if older_avg > 0 and avg_fps / older_avg < 0.5: + anomalies.append(("FPS骤降", f"FPS从{older_avg:.1f}降至{avg_fps:.1f}")) + + # 检测CPU使用率异常 + if len(self.cpu_usage_history) >= 10: + recent_cpu = list(self.cpu_usage_history)[-10:] + avg_cpu = statistics.mean(recent_cpu) + + # CPU使用率突然飙升 + if len(self.cpu_usage_history) >= 20: + older_cpu = list(self.cpu_usage_history)[-20:-10] + if len(older_cpu) > 0: + older_avg = statistics.mean(older_cpu) + if avg_cpu - older_avg > 30: # 突然增加30%以上 + anomalies.append(("CPU飙升", f"CPU从{older_avg:.1f}%升至{avg_cpu:.1f}%")) + + # 检测内存泄漏迹象 + if len(self.memory_usage_history) >= 30: + memory_values = list(self.memory_usage_history) + # 检查内存是否持续增长 + if len(memory_values) >= 30: + first_half = memory_values[:15] + second_half = memory_values[15:] + if len(first_half) > 0 and len(second_half) > 0: + first_avg = statistics.mean(first_half) + second_avg = statistics.mean(second_half) + if second_avg - first_avg > 10: # 内存增长超过10% + anomalies.append(("内存增长", f"内存从{first_avg:.1f}%增长到{second_avg:.1f}%")) + + # 记录异常 + for anomaly_type, message in anomalies: + anomaly = { + 'timestamp': current_time, + 'type': anomaly_type, + 'message': message, + 'fps': self.get_current_fps(), + 'cpu': self.get_current_cpu_usage(), + 'memory': self.get_current_memory_usage(), + 'recognition_time': self.avg_recognition_time + } + self.performance_anomalies.append(anomaly) + self.log_anomaly(anomaly) + + # 语音提示严重异常 + if (self.speech_manager and + self.speech_manager.enabled and + "骤降" in anomaly_type or "飙升" in anomaly_type): + self.speech_manager.speak_direct(f"检测到性能{anomaly_type}") + def check_performance_issues(self, cpu_percent, memory_percent): """检查性能问题""" issues = [] # 检查FPS if len(self.fps_history) > 0: - avg_fps = np.mean(list(self.fps_history[-10:])) if len(self.fps_history) >= 10 else self.fps_history[-1] + avg_fps = self.get_average_fps() + current_fps = self.get_current_fps() - if avg_fps < self.performance_thresholds['fps_critical']: - issues.append(("严重", f"帧率过低: {avg_fps:.1f} FPS")) + if current_fps < self.performance_thresholds['fps_critical']: + issues.append(("严重", f"帧率极低: {current_fps:.1f} FPS")) self.performance_status = "严重" - elif avg_fps < self.performance_thresholds['fps_warning']: - issues.append(("警告", f"帧率较低: {avg_fps:.1f} FPS")) - if self.performance_status == "良好": + self.critical_count += 1 + elif current_fps < self.performance_thresholds['fps_warning']: + issues.append(("警告", f"帧率较低: {current_fps:.1f} FPS")) + if self.performance_status == "优秀" or self.performance_status == "良好": self.performance_status = "警告" + self.warning_count += 1 # 检查CPU使用率 if cpu_percent > self.performance_thresholds['cpu_critical']: - issues.append(("严重", f"CPU使用率过高: {cpu_percent:.1f}%")) + issues.append(("严重", f"CPU使用率极高: {cpu_percent:.1f}%")) self.performance_status = "严重" + self.critical_count += 1 elif cpu_percent > self.performance_thresholds['cpu_warning']: issues.append(("警告", f"CPU使用率较高: {cpu_percent:.1f}%")) - if self.performance_status == "良好": + if self.performance_status == "优秀" or self.performance_status == "良好": self.performance_status = "警告" + self.warning_count += 1 # 检查内存使用率 if memory_percent > self.performance_thresholds['memory_critical']: - issues.append(("严重", f"内存使用率过高: {memory_percent:.1f}%")) + issues.append(("严重", f"内存使用率极高: {memory_percent:.1f}%")) self.performance_status = "严重" + self.critical_count += 1 elif memory_percent > self.performance_thresholds['memory_warning']: issues.append(("警告", f"内存使用率较高: {memory_percent:.1f}%")) - if self.performance_status == "良好": + if self.performance_status == "优秀" or self.performance_status == "良好": self.performance_status = "警告" + self.warning_count += 1 # 检查手势识别时间 if self.avg_recognition_time > self.performance_thresholds['recognition_critical']: - issues.append(("严重", f"手势识别时间过长: {self.avg_recognition_time:.1f}ms")) + issues.append(("严重", f"手势识别时间极长: {self.avg_recognition_time:.1f}ms")) self.performance_status = "严重" + self.critical_count += 1 elif self.avg_recognition_time > self.performance_thresholds['recognition_warning']: issues.append(("警告", f"手势识别时间较长: {self.avg_recognition_time:.1f}ms")) - if self.performance_status == "良好": + if self.performance_status == "优秀" or self.performance_status == "良好": self.performance_status = "警告" + self.warning_count += 1 + + # 检查帧时间 + if len(self.frame_time_history) > 0: + avg_frame_time = statistics.mean(list(self.frame_time_history)) if self.frame_time_history else 0 + if avg_frame_time > self.performance_thresholds['frame_time_critical']: + issues.append(("严重", f"帧处理时间极长: {avg_frame_time:.1f}ms")) + self.performance_status = "严重" + self.critical_count += 1 + elif avg_frame_time > self.performance_thresholds['frame_time_warning']: + issues.append(("警告", f"帧处理时间较长: {avg_frame_time:.1f}ms")) + if self.performance_status == "优秀" or self.performance_status == "良好": + self.performance_status = "警告" + self.warning_count += 1 # 记录性能事件 if issues: @@ -180,7 +404,11 @@ def add_performance_event(self, level, message): 'timestamp': time.time(), 'level': level, 'message': message, - 'session_time': time.time() - self.session_start_time + 'session_time': time.time() - self.session_start_time, + 'fps': self.get_current_fps(), + 'cpu': self.get_current_cpu_usage(), + 'memory': self.get_current_memory_usage(), + 'recognition_time': self.avg_recognition_time } self.performance_events.append(event) @@ -198,22 +426,48 @@ def log_performance_event(self, event): 'timestamp': datetime.fromtimestamp(event['timestamp']).strftime('%Y-%m-%d %H:%M:%S'), 'session_time': f"{event['session_time']:.1f}", 'level': event['level'], - 'message': event['message'] + 'message': event['message'], + 'fps': f"{event['fps']:.1f}", + 'cpu': f"{event['cpu']:.1f}", + 'memory': f"{event['memory']:.1f}", + 'recognition_time': f"{event['recognition_time']:.1f}" } self.performance_log.append(log_entry) + def log_anomaly(self, anomaly): + """记录异常到日志""" + log_entry = { + 'timestamp': datetime.fromtimestamp(anomaly['timestamp']).strftime('%Y-%m-%d %H:%M:%S'), + 'type': anomaly['type'], + 'message': anomaly['message'], + 'fps': f"{anomaly['fps']:.1f}", + 'cpu': f"{anomaly['cpu']:.1f}", + 'memory': f"{anomaly['memory']:.1f}", + 'recognition_time': f"{anomaly['recognition_time']:.1f}" + } + self.anomaly_log.append(log_entry) + def record_gesture(self, gesture, confidence): """记录手势统计""" if gesture not in self.gesture_counts: self.gesture_counts[gesture] = 0 self.gesture_confidence_sum[gesture] = 0 self.gesture_confidence_count[gesture] = 0 + self.gesture_recognition_latency[gesture] = [] self.gesture_counts[gesture] += 1 self.gesture_confidence_sum[gesture] += confidence self.gesture_confidence_count[gesture] += 1 - def record_drone_command(self, success=True): + # 记录最近一次识别时间 + if len(self.gesture_recognition_times) > 0: + last_time = self.gesture_recognition_times[-1] + self.gesture_recognition_latency[gesture].append(last_time) + # 只保留最近20个 + if len(self.gesture_recognition_latency[gesture]) > 20: + self.gesture_recognition_latency[gesture].pop(0) + + def record_drone_command(self, success=True, latency=0): """记录无人机命令""" self.drone_commands += 1 if success: @@ -221,10 +475,15 @@ def record_drone_command(self, success=True): else: self.failed_commands += 1 + if latency > 0: + self.command_latency_history.append(latency) + def record_recording_session(self, points_count=0): """记录录制会话""" self.recording_sessions += 1 self.total_trajectory_points += points_count + if points_count > 0: + self.trajectory_recording_time = time.time() - self.session_start_time def take_snapshot(self, label=""): """拍摄性能快照""" @@ -233,14 +492,23 @@ def take_snapshot(self, label=""): 'label': label, 'fps': self.get_current_fps(), 'avg_fps': self.get_average_fps(), + 'fps_history': list(self.fps_history)[-20:] if len(self.fps_history) >= 20 else list(self.fps_history), 'avg_recognition_time': self.avg_recognition_time, 'max_recognition_time': self.max_recognition_time, + 'min_recognition_time': self.min_recognition_time if self.min_recognition_time != float('inf') else 0, + 'recognition_time_std': self.recognition_time_std, 'cpu_usage': self.get_current_cpu_usage(), 'memory_usage': self.get_current_memory_usage(), + 'cpu_history': list(self.cpu_usage_history)[-20:] if len(self.cpu_usage_history) >= 20 else list(self.cpu_usage_history), + 'memory_history': list(self.memory_usage_history)[-20:] if len(self.memory_usage_history) >= 20 else list(self.memory_usage_history), 'gesture_counts': dict(self.gesture_counts), 'performance_status': self.performance_status, + 'performance_score': self.performance_score, 'frame_count': self.frame_count, - 'session_duration': time.time() - self.session_start_time + 'session_duration': time.time() - self.session_start_time, + 'warning_count': self.warning_count, + 'error_count': self.error_count, + 'critical_count': self.critical_count } self.performance_snapshots.append(snapshot) @@ -259,6 +527,13 @@ def get_average_fps(self): return np.mean(list(self.fps_history)) return 0 + def get_fps_percentile(self, percentile): + """获取FPS百分位数""" + if len(self.fps_history) >= 10: + fps_values = list(self.fps_history) + return np.percentile(fps_values, percentile) + return 0 + def get_current_cpu_usage(self): """获取当前CPU使用率""" if len(self.cpu_usage_history) > 0: @@ -271,6 +546,42 @@ def get_current_memory_usage(self): return self.memory_usage_history[-1] return 0 + def get_cpu_trend(self): + """获取CPU使用趋势""" + if len(self.cpu_trend) >= 3: + recent = list(self.cpu_trend)[-3:] + if recent[-1] > recent[0] + 5: + return "上升" + elif recent[-1] < recent[0] - 5: + return "下降" + return "稳定" + + def get_memory_trend(self): + """获取内存使用趋势""" + if len(self.memory_trend) >= 3: + recent = list(self.memory_trend)[-3:] + if recent[-1] > recent[0] + 3: + return "上升" + elif recent[-1] < recent[0] - 3: + return "下降" + return "稳定" + + def get_fps_trend(self): + """获取FPS趋势""" + if len(self.fps_history) >= 10: + recent = list(self.fps_history)[-10:] + older = list(self.fps_history)[-20:-10] if len(self.fps_history) >= 20 else recent[:5] + + if len(recent) > 0 and len(older) > 0: + recent_avg = statistics.mean(recent) + older_avg = statistics.mean(older) + + if recent_avg > older_avg + 5: + return "上升" + elif recent_avg < older_avg - 5: + return "下降" + return "稳定" + def generate_report(self, detailed=True): """生成性能报告""" report_time = time.time() @@ -283,22 +594,35 @@ def generate_report(self, detailed=True): '总帧数': self.frame_count, '平均FPS': f"{self.get_average_fps():.1f}", '当前FPS': f"{self.get_current_fps():.1f}", + '最低FPS': f"{min(self.fps_history) if self.fps_history else 0:.1f}", + 'FPS稳定性': f"{self.get_fps_percentile(90) - self.get_fps_percentile(10):.1f}", '平均手势识别时间': f"{self.avg_recognition_time:.1f}ms", - '最大手势识别时间': f"{self.max_recognition_time:.1f}ms", + '最快识别时间': f"{self.min_recognition_time if self.min_recognition_time != float('inf') else 0:.1f}ms", + '最慢识别时间': f"{self.max_recognition_time:.1f}ms", + '识别时间标准差': f"{self.recognition_time_std:.1f}ms", '当前CPU使用率': f"{self.get_current_cpu_usage():.1f}%", '当前内存使用率': f"{self.get_current_memory_usage():.1f}%", '性能状态': self.performance_status, + '性能评分': f"{self.performance_score:.0f}", '警告数量': self.warning_count, '错误数量': self.error_count, + '严重问题数量': self.critical_count, '无人机命令': { '总数': self.drone_commands, '成功': self.successful_commands, '失败': self.failed_commands, - '成功率': f"{(self.successful_commands / self.drone_commands * 100 if self.drone_commands > 0 else 0):.1f}%" + '成功率': f"{(self.successful_commands / self.drone_commands * 100 if self.drone_commands > 0 else 0):.1f}%", + '平均延迟': f"{statistics.mean(self.command_latency_history) if self.command_latency_history else 0:.1f}ms" }, '录制统计': { '会话数': self.recording_sessions, - '总轨迹点数': self.total_trajectory_points + '总轨迹点数': self.total_trajectory_points, + '录制时长': f"{self.trajectory_recording_time:.1f}秒" + }, + '趋势分析': { + 'FPS趋势': self.get_fps_trend(), + 'CPU趋势': self.get_cpu_trend(), + '内存趋势': self.get_memory_trend() } } @@ -313,10 +637,16 @@ def generate_report(self, detailed=True): else: avg_confidence = 0 + # 计算手势识别延迟 + avg_latency = 0 + if gesture in self.gesture_recognition_latency and self.gesture_recognition_latency[gesture]: + avg_latency = statistics.mean(self.gesture_recognition_latency[gesture]) + gesture_stats[gesture] = { '次数': count, '占比': f"{(count / self.frame_count * 100 if self.frame_count > 0 else 0):.1f}%", - '平均置信度': f"{avg_confidence:.1%}" + '平均置信度': f"{avg_confidence:.2f}", + '平均延迟': f"{avg_latency:.1f}ms" } report['手势统计'] = gesture_stats @@ -328,20 +658,47 @@ def generate_report(self, detailed=True): { '时间': datetime.fromtimestamp(e['timestamp']).strftime('%H:%M:%S'), '级别': e['level'], - '消息': e['message'] + '消息': e['message'], + 'FPS': f"{e['fps']:.1f}", + 'CPU': f"{e['cpu']:.1f}%", + '内存': f"{e['memory']:.1f}%" } for e in recent_events ] + # 性能异常 + if self.performance_anomalies: + recent_anomalies = list(self.performance_anomalies)[-5:] + report['最近性能异常'] = [ + { + '时间': datetime.fromtimestamp(a['timestamp']).strftime('%H:%M:%S'), + '类型': a['type'], + '消息': a['message'] + } + for a in recent_anomalies + ] + # 性能快照 if self.performance_snapshots: report['性能快照数'] = len(self.performance_snapshots) + report['最近快照时间'] = datetime.fromtimestamp(self.performance_snapshots[-1]['timestamp']).strftime('%H:%M:%S') # 系统建议 suggestions = self.generate_suggestions() if suggestions: report['优化建议'] = suggestions + # 性能分布 + if len(self.fps_history) >= 20: + fps_values = list(self.fps_history) + report['FPS分布'] = { + 'P10': f"{np.percentile(fps_values, 10):.1f}", + 'P50': f"{np.percentile(fps_values, 50):.1f}", + 'P90': f"{np.percentile(fps_values, 90):.1f}", + 'P95': f"{np.percentile(fps_values, 95):.1f}", + '标准差': f"{np.std(fps_values):.1f}" + } + return report def generate_suggestions(self): @@ -351,21 +708,39 @@ def generate_suggestions(self): # 检查FPS avg_fps = self.get_average_fps() if avg_fps < self.performance_thresholds['fps_warning']: - suggestions.append(f"帧率较低({avg_fps:.1f}FPS),建议切换到'最快'性能模式") + suggestions.append(f"帧率较低({avg_fps:.1f}FPS),建议切换到'最快'性能模式,或降低摄像头分辨率") + if self.performance_score < 50: + suggestions.append("考虑升级硬件配置(CPU/GPU)以提升性能") # 检查CPU cpu_usage = self.get_current_cpu_usage() if cpu_usage > self.performance_thresholds['cpu_warning']: suggestions.append(f"CPU使用率较高({cpu_usage:.1f}%),请关闭其他占用CPU的程序") + if cpu_usage > 90: + suggestions.append("考虑优化手势识别算法或使用硬件加速") # 检查内存 memory_usage = self.get_current_memory_usage() if memory_usage > self.performance_thresholds['memory_warning']: suggestions.append(f"内存使用率较高({memory_usage:.1f}%),请关闭不必要的程序") + if memory_usage > 90: + suggestions.append("考虑增加系统内存或优化内存使用") # 检查识别时间 if self.avg_recognition_time > self.performance_thresholds['recognition_warning']: suggestions.append(f"手势识别时间较长({self.avg_recognition_time:.1f}ms),建议调整摄像头位置或光线") + if self.avg_recognition_time > 80: + suggestions.append("考虑使用更简单的手势识别算法或优化当前算法") + + # 检查FPS稳定性 + if len(self.fps_history) >= 20: + fps_std = np.std(list(self.fps_history)[-20:]) + if fps_std > 10: + suggestions.append(f"帧率不稳定(标准差{fps_std:.1f}FPS),建议检查系统负载和网络连接") + + # 检查性能趋势 + if self.get_fps_trend() == "下降": + suggestions.append("FPS呈下降趋势,建议重启程序或检查系统资源") return suggestions @@ -373,9 +748,9 @@ def print_report(self, detailed=True): """打印性能报告""" report = self.generate_report(detailed) - print("\n" + "=" * 80) - print("📊 性能分析报告") - print("=" * 80) + print("\n" + "=" * 100) + print("📊 增强性能分析报告") + print("=" * 100) # 基础信息 print(f"生成时间: {report['生成时间']}") @@ -383,11 +758,26 @@ def print_report(self, detailed=True): print(f"总帧数: {report['总帧数']}") print(f"平均FPS: {report['平均FPS']}") print(f"当前FPS: {report['当前FPS']}") + print(f"最低FPS: {report['最低FPS']}") + print(f"FPS稳定性: {report['FPS稳定性']}") print(f"平均手势识别时间: {report['平均手势识别时间']}") - print(f"最大手势识别时间: {report['最大手势识别时间']}") + print(f"最快识别时间: {report['最快识别时间']}") + print(f"最慢识别时间: {report['最慢识别时间']}") + print(f"识别时间标准差: {report['识别时间标准差']}") print(f"当前CPU使用率: {report['当前CPU使用率']}") print(f"当前内存使用率: {report['当前内存使用率']}") print(f"性能状态: {report['性能状态']}") + print(f"性能评分: {report['性能评分']}") + print(f"警告数量: {report['警告数量']}") + print(f"错误数量: {report['错误数量']}") + print(f"严重问题数量: {report['严重问题数量']}") + + # 趋势分析 + trends = report['趋势分析'] + print(f"\n趋势分析:") + print(f" FPS趋势: {trends['FPS趋势']}") + print(f" CPU趋势: {trends['CPU趋势']}") + print(f" 内存趋势: {trends['内存趋势']}") # 无人机命令统计 cmd_stats = report['无人机命令'] @@ -396,24 +786,39 @@ def print_report(self, detailed=True): print(f" 成功: {cmd_stats['成功']}") print(f" 失败: {cmd_stats['失败']}") print(f" 成功率: {cmd_stats['成功率']}") + print(f" 平均延迟: {cmd_stats['平均延迟']}") # 录制统计 rec_stats = report['录制统计'] print(f"\n录制统计:") print(f" 会话数: {rec_stats['会话数']}") print(f" 总轨迹点数: {rec_stats['总轨迹点数']}") + print(f" 录制时长: {rec_stats['录制时长']}") # 详细报告 if detailed and '手势统计' in report: print(f"\n手势统计:") for gesture, stats in report['手势统计'].items(): - print(f" {gesture}: {stats['次数']}次 ({stats['占比']}), 平均置信度: {stats['平均置信度']}") + print(f" {gesture}: {stats['次数']}次 ({stats['占比']}), 平均置信度: {stats['平均置信度']}, 平均延迟: {stats['平均延迟']}") + + # FPS分布 + if detailed and 'FPS分布' in report: + fps_dist = report['FPS分布'] + print(f"\nFPS分布:") + print(f" P10: {fps_dist['P10']} FPS, P50: {fps_dist['P50']} FPS, P90: {fps_dist['P90']} FPS") + print(f" P95: {fps_dist['P95']} FPS, 标准差: {fps_dist['标准差']} FPS") # 性能事件 if detailed and '最近性能事件' in report and report['最近性能事件']: print(f"\n最近性能事件:") for event in report['最近性能事件']: - print(f" [{event['时间']}] {event['级别']}: {event['消息']}") + print(f" [{event['时间']}] {event['级别']}: {event['消息']} (FPS:{event['FPS']}, CPU:{event['CPU']}, 内存:{event['内存']})") + + # 性能异常 + if detailed and '最近性能异常' in report and report['最近性能异常']: + print(f"\n最近性能异常:") + for anomaly in report['最近性能异常']: + print(f" [{anomaly['时间']}] {anomaly['类型']}: {anomaly['消息']}") # 优化建议 if detailed and '优化建议' in report and report['优化建议']: @@ -421,12 +826,12 @@ def print_report(self, detailed=True): for i, suggestion in enumerate(report['优化建议'], 1): print(f" {i}. {suggestion}") - print("=" * 80) + print("=" * 100) # 语音播报摘要 if self.speech_manager and self.speech_manager.enabled: summary = (f"性能报告: 平均帧率{report['平均FPS']},识别时间{report['平均手势识别时间']}," - f"性能状态{report['性能状态']},无人机命令成功率{cmd_stats['成功率']}") + f"性能状态{report['性能状态']},评分{report['性能评分']}") self.speech_manager.speak_direct(summary) def export_log(self, filename=None): @@ -451,6 +856,28 @@ def export_log(self, filename=None): print(f"❌ 导出性能日志失败: {e}") return False + def export_anomaly_log(self, filename=None): + """导出异常日志""" + import os + current_dir = os.path.dirname(os.path.abspath(__file__)) + if filename is None: + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename = os.path.join(current_dir, f'anomaly_log_{timestamp}.csv') + + try: + with open(filename, 'w', newline='', encoding='utf-8') as f: + if self.anomaly_log: + fieldnames = self.anomaly_log[0].keys() + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + writer.writerows(self.anomaly_log) + + print(f"📤 异常日志已导出到: {filename}") + return True + except Exception as e: + print(f"❌ 导出异常日志失败: {e}") + return False + def auto_report(self): """自动性能报告(定期执行)""" current_time = time.time() @@ -461,16 +888,18 @@ def auto_report(self): # 检查是否需要报告 if (self.performance_status == "严重" or self.warning_count > 5 or - self.error_count > 0): + self.error_count > 0 or + self.performance_score < 40): - print(f"⚠ 自动性能检查: {report['性能状态']}, FPS: {report['当前FPS']}, " - f"CPU: {report['当前CPU使用率']}, 内存: {report['当前内存使用率']}") + print(f"⚠ 自动性能检查: {report['性能状态']}({report['性能评分']}分), " + f"FPS: {report['当前FPS']}, CPU: {report['当前CPU使用率']}, " + f"内存: {report['当前内存使用率']}, 识别时间: {report['平均手势识别时间']}") # 语音提示 if (self.speech_manager and self.speech_manager.enabled and self.performance_status == "严重"): - self.speech_manager.speak_direct(f"系统性能{self.performance_status},建议检查") + self.speech_manager.speak_direct(f"系统性能{self.performance_status},建议立即检查") self.last_performance_report = current_time @@ -478,16 +907,25 @@ def reset_session(self): """重置会话统计""" self.session_start_time = time.time() self.performance_events = [] + self.performance_anomalies = [] self.performance_snapshots = [] self.gesture_counts = {} self.gesture_confidence_sum = {} self.gesture_confidence_count = {} + self.gesture_recognition_latency = {} self.error_count = 0 self.warning_count = 0 + self.critical_count = 0 self.drone_commands = 0 self.successful_commands = 0 self.failed_commands = 0 - self.performance_status = "良好" + self.command_latency_history.clear() + self.performance_status = "优秀" + self.performance_score = 100 + self.frame_time_history.clear() + self.recording_sessions = 0 + self.total_trajectory_points = 0 + self.trajectory_recording_time = 0 print("✓ 性能统计会话已重置") @@ -496,10 +934,42 @@ def get_stats_summary(self): return { 'fps': self.get_current_fps(), 'avg_fps': self.get_average_fps(), + 'min_fps': min(self.fps_history) if self.fps_history else 0, 'recognition_time': self.avg_recognition_time, 'cpu_usage': self.get_current_cpu_usage(), 'memory_usage': self.get_current_memory_usage(), 'performance_status': self.performance_status, + 'performance_score': self.performance_score, 'gesture_count': sum(self.gesture_counts.values()), - 'unique_gestures': len(self.gesture_counts) + 'unique_gestures': len(self.gesture_counts), + 'fps_trend': self.get_fps_trend(), + 'cpu_trend': self.get_cpu_trend(), + 'memory_trend': self.get_memory_trend(), + 'warning_count': self.warning_count, + 'error_count': self.error_count + } + + def get_detailed_stats(self): + """获取详细统计""" + return { + 'frame_time_stats': { + 'avg': statistics.mean(self.frame_time_history) if self.frame_time_history else 0, + 'min': min(self.frame_time_history) if self.frame_time_history else 0, + 'max': max(self.frame_time_history) if self.frame_time_history else 0, + 'std': statistics.stdev(self.frame_time_history) if len(self.frame_time_history) >= 2 else 0 + }, + 'recognition_time_stats': { + 'avg': self.avg_recognition_time, + 'min': self.min_recognition_time if self.min_recognition_time != float('inf') else 0, + 'max': self.max_recognition_time, + 'std': self.recognition_time_std + }, + 'resource_usage': { + 'cpu_avg': statistics.mean(self.cpu_usage_history) if self.cpu_usage_history else 0, + 'memory_avg': statistics.mean(self.memory_usage_history) if self.memory_usage_history else 0, + 'cpu_max': max(self.cpu_usage_history) if self.cpu_usage_history else 0, + 'memory_max': max(self.memory_usage_history) if self.memory_usage_history else 0 + }, + 'anomaly_count': len(self.performance_anomalies), + 'snapshot_count': len(self.performance_snapshots) } \ No newline at end of file diff --git a/src/autonomus_drone_hand_gesture_project/ui_renderer.py b/src/autonomus_drone_hand_gesture_project/ui_renderer.py index cb52a20513..524f45c67f 100644 --- a/src/autonomus_drone_hand_gesture_project/ui_renderer.py +++ b/src/autonomus_drone_hand_gesture_project/ui_renderer.py @@ -59,6 +59,14 @@ def __init__(self, speech_manager=None, config=None): 'flight_mode_eight': (255, 0, 255), 'flight_mode_square': (255, 255, 0), 'flight_mode_return_home': (0, 128, 128), + # 性能图表颜色 + 'chart_fps': (0, 255, 0), + 'chart_cpu': (255, 165, 0), + 'chart_memory': (0, 165, 255), + 'chart_recognition': (255, 0, 255), + 'chart_background': (30, 30, 30), + 'chart_grid': (60, 60, 60), + 'chart_text': (200, 200, 200), } print("✓ 中文UI渲染器已初始化") @@ -123,7 +131,7 @@ def draw_status_bar(self, frame, drone_controller, gesture, confidence, fps, pro frame = cv2.addWeighted(overlay, 0.7, frame, 0.3, 0) # 标题 - title = "手势控制无人机系统 - 高级飞行模式版" + title = "手势控制无人机系统 - 增强性能监控版" frame = self.draw_text(frame, title, (10, 10), size=20, color=self.colors['title']) # 连接状态 @@ -146,7 +154,8 @@ def draw_status_bar(self, frame, drone_controller, gesture, confidence, fps, pro gesture_text = f"当前手势: {gesture}" if self.config.get('display', 'show_confidence'): - gesture_text += f" ({confidence:.0%})" + # 显示为小数,避免字体问题 + gesture_text += f" ({confidence:.2f})" frame = self.draw_text(frame, gesture_text, (w // 2, 40), size=16, color=gesture_color) @@ -190,14 +199,18 @@ def draw_status_bar(self, frame, drone_controller, gesture, confidence, fps, pro perf_stats = performance_analyzer.get_stats_summary() # 性能状态颜色 - if perf_stats['performance_status'] == "良好": - perf_color = self.colors['performance_good'] + if perf_stats['performance_status'] == "优秀": + perf_color = (0, 255, 0) # 绿色 + elif perf_stats['performance_status'] == "良好": + perf_color = (100, 255, 100) # 浅绿色 + elif perf_stats['performance_status'] == "一般": + perf_color = (255, 255, 0) # 黄色 elif perf_stats['performance_status'] == "警告": - perf_color = self.colors['performance_warning'] + perf_color = (255, 165, 0) # 橙色 else: - perf_color = self.colors['performance_bad'] + perf_color = (255, 0, 0) # 红色 - perf_text = f"性能: {perf_stats['performance_status']} ({perf_stats['fps']:.0f}FPS)" + perf_text = f"性能: {perf_stats['performance_status']}({perf_stats['performance_score']:.0f}分) {perf_stats['fps']:.0f}FPS" frame = self.draw_text(frame, perf_text, (w // 2, 90), size=12, color=perf_color) # 系统资源显示 @@ -222,7 +235,7 @@ def draw_status_bar(self, frame, drone_controller, gesture, confidence, fps, pro mem_color = self.colors['memory_critical'] # 绘制系统资源信息 - sys_text = f"CPU:{cpu_usage:.0f}% 内存:{memory_usage:.0f}%" + sys_text = f"CPU:{cpu_usage:.0f}%({performance_analyzer.get_cpu_trend()}) 内存:{memory_usage:.0f}%({performance_analyzer.get_memory_trend()})" frame = self.draw_text(frame, sys_text, (w // 2, 110), size=11, color=self.colors['info']) # 语音状态 @@ -256,7 +269,7 @@ def draw_status_bar(self, frame, drone_controller, gesture, confidence, fps, pro # 性能快捷键提示 if performance_analyzer: - perf_tip = "P:报告 L:快照 K:导出" + perf_tip = "P:详细报告 L:快照 K:导出" frame = self.draw_text(frame, perf_tip, (10, 110), size=11, color=self.colors['help']) return frame @@ -363,10 +376,10 @@ def draw_performance_chart(self, frame, performance_analyzer): cv2.rectangle(frame, (chart_x, chart_y), (chart_x + chart_width, chart_y + chart_height), - (30, 30, 30), -1) + self.colors['chart_background'], -1) cv2.rectangle(frame, (chart_x, chart_y), (chart_x + chart_width, chart_y + chart_height), - (100, 100, 100), 1) + self.colors['chart_grid'], 1) # 绘制标题 frame = self.draw_text(frame, "性能监控", (chart_x + 10, chart_y + 20), @@ -392,7 +405,7 @@ def draw_performance_chart(self, frame, performance_analyzer): # 连接点形成曲线 for i in range(len(points) - 1): - cv2.line(frame, points[i], points[i + 1], (0, 255, 0), 2) + cv2.line(frame, points[i], points[i + 1], self.colors['chart_fps'], 2) # 显示当前FPS值 current_fps = fps_values[-1] if fps_values else 0 @@ -404,4 +417,107 @@ def draw_performance_chart(self, frame, performance_analyzer): (chart_x + 120, chart_y + 40), size=12, color=fps_color) + return frame + + def draw_detailed_performance_charts(self, frame, performance_analyzer): + """绘制详细性能图表""" + if not performance_analyzer: + return frame + + h, w = frame.shape[:2] + + # 绘制多个图表区域 + chart_height = 100 + chart_spacing = 10 + + # FPS图表 + fps_chart_y = 130 + frame = self.draw_chart(frame, w - 250, fps_chart_y, 240, chart_height, + "FPS监控", performance_analyzer.fps_history, + self.colors['chart_fps'], "FPS") + + # CPU图表 + cpu_chart_y = fps_chart_y + chart_height + chart_spacing + frame = self.draw_chart(frame, w - 250, cpu_chart_y, 240, chart_height, + "CPU使用率", performance_analyzer.cpu_usage_history, + self.colors['chart_cpu'], "%", max_val=100) + + # 内存图表 + memory_chart_y = cpu_chart_y + chart_height + chart_spacing + frame = self.draw_chart(frame, w - 250, memory_chart_y, 240, chart_height, + "内存使用率", performance_analyzer.memory_usage_history, + self.colors['chart_memory'], "%", max_val=100) + + # 识别时间图表 + if len(performance_analyzer.gesture_recognition_times) > 1: + recognition_chart_y = memory_chart_y + chart_height + chart_spacing + frame = self.draw_chart(frame, w - 250, recognition_chart_y, 240, chart_height, + "识别时间", performance_analyzer.gesture_recognition_times, + self.colors['chart_recognition'], "ms") + + return frame + + def draw_chart(self, frame, x, y, width, height, title, data, color, unit="", max_val=None): + """绘制单个图表""" + # 绘制图表背景 + cv2.rectangle(frame, (x, y), (x + width, y + height), + self.colors['chart_background'], -1) + cv2.rectangle(frame, (x, y), (x + width, y + height), + self.colors['chart_grid'], 1) + + # 绘制标题 + frame = self.draw_text(frame, title, (x + 10, y + 15), + size=12, color=self.colors['chart_text']) + + if len(data) < 2: + return frame + + # 获取数据 + values = list(data)[-min(20, len(data)):] # 最多显示20个点 + if not values: + return frame + + # 计算最大值和最小值 + data_max = max(values) if max_val is None else max_val + data_min = min(values) + + if data_max == data_min: + data_max = data_min + 1 + + # 绘制网格线 + grid_color = self.colors['chart_grid'] + for i in range(1, 4): + grid_y = y + height - 20 - i * (height - 40) // 4 + cv2.line(frame, (x + 10, grid_y), (x + width - 10, grid_y), grid_color, 1) + + # 绘制刻度值 + tick_value = data_min + (data_max - data_min) * i / 4 + tick_text = f"{tick_value:.0f}{unit}" + frame = self.draw_text(frame, tick_text, (x + width - 35, grid_y - 5), + size=10, color=self.colors['chart_text']) + + # 绘制数据曲线 + points = [] + for i, value in enumerate(values): + point_x = x + 10 + i * (width - 20) / (len(values) - 1) if len(values) > 1 else x + 10 + point_y = y + height - 20 - (value - data_min) * (height - 40) / (data_max - data_min) + points.append((int(point_x), int(point_y))) + + # 连接点形成曲线 + for i in range(len(points) - 1): + cv2.line(frame, points[i], points[i + 1], color, 2) + + # 绘制当前值 + if values: + current_value = values[-1] + current_text = f"当前: {current_value:.1f}{unit}" + frame = self.draw_text(frame, current_text, (x + 10, y + 30), + size=11, color=color) + + # 绘制平均值 + avg_value = sum(values) / len(values) + avg_text = f"平均: {avg_value:.1f}{unit}" + frame = self.draw_text(frame, avg_text, (x + width - 80, y + 30), + size=11, color=self.colors['chart_text']) + return frame \ No newline at end of file