Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
193 changes: 132 additions & 61 deletions src/Driving_Accident_Video_Recognition/detector.py
Original file line number Diff line number Diff line change
@@ -1,121 +1,192 @@
"""
事故检测器核心类:负责模型加载、检测流程执行
检测器模块:精准事故判断+视频保存+帧率显示(无报错版)
"""
import sys
import cv2
import time
from ultralytics import YOLO
from config import (
YOLO_MODEL_PATH, CONFIDENCE_THRESHOLD, ACCIDENT_CLASSES,
MIN_VEHICLE_COUNT, PERSON_VEHICLE_CONTACT,
RESIZE_WIDTH, RESIZE_HEIGHT, DETECTION_SOURCE
MIN_VEHICLE_COUNT, PERSON_VEHICLE_CONTACT, PERSON_VEHICLE_DISTANCE_THRESHOLD,
RESIZE_WIDTH, RESIZE_HEIGHT, DETECTION_SOURCE,
SAVE_RESULT_VIDEO, RESULT_VIDEO_PATH
)
from core.process import process_box_coords, draw_annotations
from core.process import (
process_box_coords, get_box_center, calculate_euclidean_distance, draw_annotations
)


class AccidentDetector:
def __init__(self):
"""初始化检测器,加载YOLOv8模型"""
self.model = None
self.accident_detected = False
self._load_model()
self.model = None # YOLO模型对象
self.accident_detected = False # 是否检测到事故
self.video_writer = None # 视频写入器(保存检测结果)
# 帧率计算(滑动平均,避免波动)
self.fps_history = []
self.prev_time = time.time()

self._load_model() # 初始化时加载模型

def _load_model(self):
"""私有方法:加载模型,包含重试逻辑"""
"""加载YOLO模型(增加兜底逻辑)"""
print("🔄 加载YOLOv8检测模型...")
try:
print("🔄 正在加载YOLOv8模型(首次运行会自动下载)...")
self.model = YOLO(YOLO_MODEL_PATH)
print("✅ YOLOv8模型加载成功")
print(f"✅ 模型加载成功:{YOLO_MODEL_PATH}")
except Exception as e:
print(f"❌ 模型加载失败:{e}")
# 重试加载模型
print(f"⚠️ 指定模型加载失败,尝试默认轻量模型yolov8n.pt...")
try:
print("🔄 尝试重新下载模型...")
self.model = YOLO("yolov8n.pt")
print("✅ 模型重新加载成功")
print("✅ 兜底模型(yolov8n.pt)加载成功")
except Exception as e2:
print(f"❌ 模型重新加载失败:{e2}")
print(f"❌ 模型加载失败:{e2},程序退出")
sys.exit(1)

def detect_frame(self, frame):
"""处理单帧,返回标注后的帧和是否检测到事故"""
def _init_video_writer(self, frame):
"""初始化视频写入器(增加路径检查)"""
if not SAVE_RESULT_VIDEO:
return
height, width = frame.shape[:2]
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
# 自动创建保存目录(避免路径不存在)
save_dir = "/".join(RESULT_VIDEO_PATH.split("/")[:-1])
if save_dir and not cv2.os.path.exists(save_dir):
cv2.os.makedirs(save_dir)
# 初始化写入器
self.video_writer = cv2.VideoWriter(RESULT_VIDEO_PATH, fourcc, 30.0, (width, height))
if not self.video_writer.isOpened():
print(f"⚠️ 无法保存视频到{RESULT_VIDEO_PATH},跳过保存")
self.video_writer = None

def _calculate_accident(self, detected_objects):
"""精准判断事故:多车/人车接触"""
persons = [obj for obj in detected_objects if obj[0] == "person"]
vehicles = [obj for obj in detected_objects if obj[0] in ["car", "truck"]]

# 条件1:车辆数量≥配置阈值
if len(vehicles) >= MIN_VEHICLE_COUNT:
return True
# 条件2:行人和车辆距离≤阈值
if PERSON_VEHICLE_CONTACT and len(persons) >= 1 and len(vehicles) >= 1:
p_centers = [get_box_center(*obj[1:]) for obj in persons]
v_centers = [get_box_center(*obj[1:]) for obj in vehicles]
for p in p_centers:
for v in v_centers:
if calculate_euclidean_distance(p, v) <= PERSON_VEHICLE_DISTANCE_THRESHOLD:
return True
return False

def detect_frame(self, frame, language="zh"):
"""处理单帧:检测+标注+帧率计算"""
detected_objects = []
current_frame = frame.copy()

try:
# 缩放帧提升速度
frame_resized = cv2.resize(frame, (RESIZE_WIDTH, RESIZE_HEIGHT))
# YOLOv8推理
results = self.model(frame_resized, conf=CONFIDENCE_THRESHOLD)
# 缩放帧(适配YOLO输入)
frame_resized = cv2.resize(current_frame, (RESIZE_WIDTH, RESIZE_HEIGHT))
# 模型推理(关闭冗余日志)
results = self.model(frame_resized, conf=CONFIDENCE_THRESHOLD, verbose=False)

# 解析检测结果
for r in results:
if hasattr(r, 'boxes') and r.boxes is not None:
for box in r.boxes:
if not hasattr(box, 'cls') or box.cls is None:
continue
cls_idx = int(box.cls[0])
if cls_idx in ACCIDENT_CLASSES:
cls_name = self.model.names[cls_idx]
# 处理坐标
scale_x = frame.shape[1] / RESIZE_WIDTH
scale_y = frame.shape[0] / RESIZE_HEIGHT
x1, y1, x2, y2 = process_box_coords(box, scale_x, scale_y)
detected_objects.append((cls_name, x1, y1, x2, y2))
if not hasattr(r, "boxes") or r.boxes is None:
continue
for box in r.boxes:
if not hasattr(box, "cls") or box.cls is None:
continue
cls_idx = int(box.cls[0])
if cls_idx in ACCIDENT_CLASSES:
cls_name = self.model.names[cls_idx]
# 坐标缩放回原始帧
scale_x = current_frame.shape[1] / RESIZE_WIDTH
scale_y = current_frame.shape[0] / RESIZE_HEIGHT
x1, y1, x2, y2 = process_box_coords(box, scale_x, scale_y)
detected_objects.append((cls_name, x1, y1, x2, y2))

# 判断事故
person_count = sum(1 for obj in detected_objects if obj[0] == "person")
vehicle_count = sum(1 for obj in detected_objects if obj[0] in ["car", "truck"])
is_accident = (vehicle_count >= MIN_VEHICLE_COUNT) or (person_count >= 1 and vehicle_count >= 1 and PERSON_VEHICLE_CONTACT)
self.accident_detected = is_accident

self.accident_detected = self._calculate_accident(detected_objects)
# 绘制标注
frame = draw_annotations(frame, detected_objects, is_accident)
current_frame = draw_annotations(current_frame, detected_objects, self.accident_detected, language)

# 计算滑动平均帧率
current_time = time.time()
self.fps_history.append(1 / (current_time - self.prev_time))
self.prev_time = current_time
# 只保留最近10帧的帧率(避免波动)
if len(self.fps_history) > 10:
self.fps_history.pop(0)
avg_fps = int(sum(self.fps_history) / len(self.fps_history)) if self.fps_history else 0
# 绘制帧率
cv2.putText(current_frame, f"FPS: {avg_fps}", (50, 100),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)

# 保存视频帧
if self.video_writer:
self.video_writer.write(current_frame)

except Exception as e:
print(f"⚠️ 帧处理出现小错误:{e},继续运行...")
print(f"⚠️ 帧处理错误:{e},继续运行...")

return frame, self.accident_detected
return current_frame, self.accident_detected

def run_detection(self):
"""启动检测流程,包含完善的容错逻辑"""
# 多次尝试打开检测源
def run_detection(self, language="zh"):
"""启动检测流程:打开摄像头/视频+逐帧处理"""
# 打开检测源(重试3次)
cap = None
for i in range(3):
for retry in range(3):
cap = cv2.VideoCapture(DETECTION_SOURCE)
if cap.isOpened():
print(f"✅ 第{retry+1}次打开检测源成功")
break
print(f"⚠️ 第{i+1}次打开检测源失败,重试中...")
cv2.waitKey(1000)
print(f"⚠️ 第{retry+1}次打开检测源失败,1秒后重试...")
time.sleep(1)

# 兜底:打开默认摄像头
if not cap or not cap.isOpened():
print(f"❌ 无法打开检测源:{DETECTION_SOURCE}")
# 强制切换为摄像头
print("🔄 强制切换为电脑摄像头...")
print(f"❌ 目标检测源{DETECTION_SOURCE}无法打开,尝试默认摄像头(0)...")
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("❌ 摄像头也无法打开,请检查设备")
print("❌ 所有检测源均无法打开,程序退出")
sys.exit(1)

print("✅ 检测源打开成功,开始实时检测(按Q/ESC键退出)")
print("💡 提示:检测到2辆车或行人和车辆同时出现时,显示红色警告")
print("✅ 检测源打开成功(按Q/ESC退出)")
print(f"💡 配置:行人车辆距离阈值{PERSON_VEHICLE_DISTANCE_THRESHOLD}像素")

# 初始化视频写入器(读取第一帧)
ret, first_frame = cap.read()
if ret:
self._init_video_writer(first_frame)

# 逐帧处理
while True:
ret, frame = cap.read()
if not ret:
print("🔚 视频/摄像头流结束")
print("🔚 视频流读取完毕,结束检测")
break

frame, _ = self.detect_frame(frame)
cv2.imshow("驾驶事故检测(按Q退出)", frame)
# 处理单帧
processed_frame, _ = self.detect_frame(frame, language)
cv2.imshow("驾驶事故检测", processed_frame)

# 退出逻辑
key = cv2.waitKey(1) & 0xFF
if key == ord('q') or key == 27:
if key == ord("q") or key == 27:
print("🛑 用户手动退出")
break

# 释放资源
cap.release()
if self.video_writer:
self.video_writer.release()
print(f"✅ 检测结果已保存到{RESULT_VIDEO_PATH}")
cv2.destroyAllWindows()
print(f"\n📊 检测总结:是否检测到事故 → {'✅ 是' if self.accident_detected else '❌ 否'}")

# 供外部导入的类
__all__ = ["AccidentDetector"]
# 检测总结
avg_fps = int(sum(self.fps_history) / len(self.fps_history)) if self.fps_history else 0
print(f"\n📊 检测总结:")
print(f" - 是否检测到事故 → {'✅ 是' if self.accident_detected else '❌ 否'}")
print(f" - 平均处理帧率 → {avg_fps} FPS")


# 供外部导入
__all__ = ["AccidentDetector"]
114 changes: 92 additions & 22 deletions src/Driving_Accident_Video_Recognition/main.py
Original file line number Diff line number Diff line change
@@ -1,41 +1,111 @@
"""
主程序:驾驶事故视频识别工具
主程序:驾驶事故视频识别工具(优化版)
优化点:性能提速+灵活配置+规范日志+新增人和小车识别提示
"""
import sys
import os
import argparse
import logging # 新增:日志模块(替代print,支持分级输出)
from config import (
REQUIRED_PACKAGES, PYPI_MIRROR, DETECTION_SOURCE,
CONFIDENCE_THRESHOLD, ACCIDENT_CLASSES # 新增:引入识别类别配置
)
from utils.dependencies import install_dependencies
from core.detector import AccidentDetector

# 确保当前目录可被搜索
current_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_dir)
# -------------------------- 新增1:日志初始化(替代print,更灵活) --------------------------
def init_logger():
logger = logging.getLogger("AccidentDetection")
logger.setLevel(logging.INFO)
# 控制台输出格式:时间+日志级别+内容
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
console_handler = logging.StreamHandler()
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
return logger

# 直接导入同目录的文件(彻底避免模块包问题)
from config import REQUIRED_PACKAGES, PYPI_MIRROR, PERSON_VEHICLE_DISTANCE, ACCIDENT_CONTINUOUS_FRAMES
from dependencies import install_dependencies # 直接导入同目录的dependencies.py
from detector import AccidentDetector
# -------------------------- 新增2:优化命令行参数(更灵活的配置) --------------------------
def parse_args(logger):
parser = argparse.ArgumentParser(description="驾驶事故视频识别工具(支持动态配置)")
# 基础参数:检测源、语言
parser.add_argument("--source", "-s", default=DETECTION_SOURCE,
help=f"检测源(0=摄像头/视频路径,默认:{DETECTION_SOURCE})")
parser.add_argument("--language", "-l", default="zh", choices=["zh", "en"],
help="标注语言(zh=中文/en=英文,默认:zh)")
# 新增:性能/配置参数(无需改config.py,直接命令行调整)
parser.add_argument("--skip-deps", "-sd", action="store_true", default=False,
help="跳过依赖检查(已安装依赖时用,提速)")
parser.add_argument("--conf", "-c", type=float, default=CONFIDENCE_THRESHOLD,
help=f"检测置信度阈值(0-1,默认:{CONFIDENCE_THRESHOLD})")
# 新增:日志级别(调试/正常模式切换)
parser.add_argument("--log-level", "-ll", default="INFO", choices=["DEBUG", "INFO", "WARNING"],
help="日志级别(DEBUG=调试/INFO=正常/WARNING=仅警告,默认:INFO)")

args = parser.parse_args()
# 校验参数合法性(新增:避免无效输入)
if not (0 < args.conf <= 1):
logger.warning(f"置信度{args.conf}无效,自动使用默认值{CONFIDENCE_THRESHOLD}")
args.conf = CONFIDENCE_THRESHOLD
return args

# -------------------------- 优化3:主函数逻辑(减少重复计算+提升健壮性+新增人和小车识别) --------------------------
def main():
# 初始化日志
logger = init_logger()
# 解析参数(并应用日志级别)
args = parse_args(logger)
logger.setLevel(args.log_level) # 动态调整日志级别

def parse_args():
parser = argparse.ArgumentParser(description="驾驶事故视频识别")
parser.add_argument("--source", "-s", default=0, help="检测源:0=摄像头/视频路径")
parser.add_argument("--language", "-l", default="zh", choices=["zh", "en"], help="标注语言")
return parser.parse_args()
# -------------------------- 优化4:缓存环境变量操作(减少属性查找,提速) --------------------------
env = os.environ # 局部变量缓存os.environ,避免循环中重复查找(参考摘要5“缓存属性”)
# 覆盖检测源(命令行优先)
if str(args.source) != str(DETECTION_SOURCE):
# 严谨处理检测源类型:尝试转整数(摄像头),失败则为字符串(视频路径)
try:
env["DETECTION_SOURCE"] = str(int(args.source)) # 摄像头(数字)
except (ValueError, TypeError):
env["DETECTION_SOURCE"] = str(args.source) # 视频路径(字符串)
logger.info(f"检测源已覆盖为:{env['DETECTION_SOURCE']}")

# 覆盖置信度阈值(命令行优先)
if args.conf != CONFIDENCE_THRESHOLD:
env["CONFIDENCE_THRESHOLD"] = str(args.conf)
logger.info(f"置信度阈值已覆盖为:{args.conf}")

def main():
args = parse_args()
try:
print("🚀 启动驾驶事故检测...")
# 安装依赖
install_dependencies(REQUIRED_PACKAGES, PYPI_MIRROR)
# 启动检测
logger.info("🚀 启动驾驶事故视频识别工具...")
# -------------------------- 优化5:跳过依赖检查(避免重复安装,提速) --------------------------
if not args.skip_deps:
install_dependencies(REQUIRED_PACKAGES, PYPI_MIRROR)
else:
logger.info("⚠️ 已跳过依赖检查(--skip-deps生效)")

# -------------------------- 优化6:简化检测器初始化(减少冗余代码) --------------------------
logger.info("🔄 初始化事故检测器...")
detector = AccidentDetector()
# 新增:提示当前模型支持识别人和小车
target_classes = {0: "人", 2: "小车"}
supported_targets = [f"{name}(类别ID: {cid})" for cid, name in target_classes.items() if cid in ACCIDENT_CLASSES]
logger.info(f"✅ 检测器初始化完成,当前模型支持识别:{', '.join(supported_targets)}")
logger.info("✅ 开始检测(按Q/ESC退出,画面中会标注识别到的人和小车)")

# 启动检测(传递语言参数)
detector.run_detection(language=args.language)

except KeyboardInterrupt:
print("\n🛑 程序中断")
logger.info("\n🛑 用户强制中断程序")
except Exception as e:
# 新增:DEBUG级别输出详细异常栈,INFO级别只显示错误信息(方便调试)
logger.error(f"\n❌ 程序运行出错:{str(e)}")
if args.log_level == "DEBUG":
import traceback
traceback.print_exc()
finally:
print("👋 程序退出")

logger.info("👋 程序正常退出")

if __name__ == "__main__":
# 新增:确保code目录在搜索路径(兼容不同运行方式)
current_dir = os.path.dirname(os.path.abspath(__file__))
if current_dir not in sys.path:
sys.path.append(current_dir)
main()
Loading
Loading