16337
37fc48e34d
修复内容： 1. 添加 state_start_time 空值检查（CONFIRMING_INTRUSION 和 CONFIRMING_CLEAR 状态） 2. 移除 get_state() 未使用的 roi_id 参数 3. get_state() 接受 current_time 参数，避免直接调用 datetime.now() 4. 提取魔法数字：ALARM_LEVEL_INTRUSION = 3 Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
1046 lines
44 KiB
Python
1046 lines
44 KiB
Python
import logging
|
||
import os
|
||
import sys
|
||
import threading
|
||
import time
|
||
from collections import deque
|
||
from datetime import datetime, timedelta
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
import cv2
|
||
import numpy as np
|
||
import redis
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||
|
||
|
||
class LeavePostAlgorithm:
|
||
"""
|
||
离岗检测算法（优化版 v2.0）
|
||
|
||
状态机：
|
||
INIT → CONFIRMING_ON_DUTY → ON_DUTY → CONFIRMING_OFF_DUTY
|
||
→ OFF_DUTY_COUNTDOWN → ALARMED → (回岗) → CONFIRMING_ON_DUTY
|
||
|
||
业务流程：
|
||
1. 启动后检测到人 → 上岗确认期（confirm_on_duty_sec，默认10秒）
|
||
2. 确认上岗后 → 在岗状态（ON_DUTY）
|
||
3. 人离开ROI → 离岗确认期（confirm_off_duty_sec，默认30秒）
|
||
4. 确认离岗后 → 离岗倒计时（leave_countdown_sec，默认300秒）
|
||
5. 倒计时结束 → 触发告警（ALARMED状态）
|
||
6. 人员回岗 → 回岗确认期（confirm_return_sec，默认10秒）
|
||
7. 确认回岗 → 发送resolve事件 → 重新上岗确认
|
||
"""
|
||
|
||
# 状态定义
|
||
STATE_INIT = "INIT" # 初始化
|
||
STATE_CONFIRMING_ON_DUTY = "CONFIRMING_ON_DUTY" # 上岗确认中
|
||
STATE_ON_DUTY = "ON_DUTY" # 在岗
|
||
STATE_CONFIRMING_OFF_DUTY = "CONFIRMING_OFF_DUTY" # 离岗确认中
|
||
STATE_OFF_DUTY_COUNTDOWN = "OFF_DUTY_COUNTDOWN" # 离岗倒计时中
|
||
STATE_ALARMED = "ALARMED" # 已告警（等待回岗）
|
||
STATE_NON_WORK_TIME = "NON_WORK_TIME" # 非工作时间
|
||
|
||
def __init__(
|
||
self,
|
||
confirm_on_duty_sec: int = 10, # 上岗确认窗口（持续检测到人的时长）
|
||
confirm_off_duty_sec: int = 30, # 离岗确认窗口（持续未检测到人的时长）
|
||
confirm_return_sec: int = 10, # 回岗确认窗口（告警后回来需确认时长）
|
||
leave_countdown_sec: int = 300, # 离岗倒计时（确认离岗后等待告警的时长）
|
||
cooldown_sec: int = 600, # 告警冷却期（两次告警的最小间隔）
|
||
working_hours: Optional[List[Dict]] = None,
|
||
target_class: Optional[str] = "person",
|
||
# 兼容旧参数名（向后兼容）
|
||
confirm_leave_sec: Optional[int] = None,
|
||
):
|
||
# 时间参数（处理向后兼容）
|
||
self.confirm_on_duty_sec = confirm_on_duty_sec
|
||
self.confirm_off_duty_sec = confirm_leave_sec if confirm_leave_sec is not None else confirm_off_duty_sec
|
||
self.confirm_return_sec = confirm_return_sec
|
||
self.leave_countdown_sec = leave_countdown_sec
|
||
self.cooldown_sec = cooldown_sec
|
||
|
||
# 工作时间和目标类别
|
||
self.working_hours = working_hours or []
|
||
self.target_class = target_class
|
||
|
||
# 状态变量
|
||
self.state: str = self.STATE_INIT
|
||
self.state_start_time: Optional[datetime] = None
|
||
|
||
# 滑动窗口（用于平滑检测结果）
|
||
self.detection_window: deque = deque() # [(timestamp, has_person), ...]
|
||
self.window_size_sec = 10 # 滑动窗口大小：10秒
|
||
|
||
# 告警追踪
|
||
self._last_alarm_id: Optional[str] = None
|
||
self._leave_start_time: Optional[datetime] = None # 人员离开时间（用于计算持续时长）
|
||
self._alarm_triggered_time: Optional[datetime] = None # 告警触发时间
|
||
self.alert_cooldowns: Dict[str, datetime] = {}
|
||
|
||
def _is_in_working_hours(self, dt: Optional[datetime] = None) -> bool:
|
||
"""检查是否在工作时间"""
|
||
if not self.working_hours:
|
||
return True
|
||
|
||
import json
|
||
|
||
working_hours = self.working_hours
|
||
if isinstance(working_hours, str):
|
||
try:
|
||
working_hours = json.loads(working_hours)
|
||
except:
|
||
return True
|
||
|
||
if not working_hours:
|
||
return True
|
||
|
||
dt = dt or datetime.now()
|
||
current_minutes = dt.hour * 60 + dt.minute
|
||
for period in working_hours:
|
||
start_str = period["start"] if isinstance(period, dict) else period
|
||
end_str = period["end"] if isinstance(period, dict) else period
|
||
start_minutes = self._parse_time_to_minutes(start_str)
|
||
end_minutes = self._parse_time_to_minutes(end_str)
|
||
if start_minutes <= current_minutes < end_minutes:
|
||
return True
|
||
return False
|
||
|
||
def _parse_time_to_minutes(self, time_str: str) -> int:
|
||
"""将时间字符串转换为分钟数"""
|
||
if isinstance(time_str, int):
|
||
return time_str
|
||
try:
|
||
parts = time_str.split(":")
|
||
return int(parts[0]) * 60 + int(parts[1])
|
||
except:
|
||
return 0
|
||
|
||
def _check_detection_in_roi(self, detection: Dict, roi_id: str) -> bool:
|
||
"""检查检测结果是否在ROI内"""
|
||
matched_rois = detection.get("matched_rois", [])
|
||
return any(roi.get("roi_id") == roi_id for roi in matched_rois)
|
||
|
||
def _check_target_class(self, detection: Dict, target_class: str) -> bool:
|
||
"""检查是否为目标类别"""
|
||
if not target_class:
|
||
return True
|
||
return detection.get("class") == target_class
|
||
|
||
def _get_latest_bbox(self, tracks: List[Dict], roi_id: str) -> List[float]:
|
||
"""获取ROI内最新的检测框"""
|
||
for det in tracks:
|
||
if self._check_detection_in_roi(det, roi_id) and self._check_target_class(det, self.target_class):
|
||
return det.get("bbox", [])
|
||
return []
|
||
|
||
def _update_detection_window(self, current_time: datetime, has_person: bool):
|
||
"""更新滑动窗口"""
|
||
self.detection_window.append((current_time, has_person))
|
||
|
||
# 移除窗口外的旧数据
|
||
while self.detection_window:
|
||
oldest_time, _ = self.detection_window[0]
|
||
if (current_time - oldest_time).total_seconds() > self.window_size_sec:
|
||
self.detection_window.popleft()
|
||
else:
|
||
break
|
||
|
||
def _get_detection_ratio(self) -> float:
|
||
"""计算滑动窗口内的检测命中率"""
|
||
if not self.detection_window:
|
||
return 0.0
|
||
|
||
person_count = sum(1 for _, has_person in self.detection_window if has_person)
|
||
return person_count / len(self.detection_window)
|
||
|
||
def process(
|
||
self,
|
||
roi_id: str,
|
||
camera_id: str,
|
||
tracks: List[Dict],
|
||
current_time: Optional[datetime] = None,
|
||
) -> List[Dict]:
|
||
"""
|
||
处理单帧检测结果
|
||
|
||
Args:
|
||
roi_id: ROI区域ID
|
||
camera_id: 摄像头ID
|
||
tracks: 检测结果列表
|
||
current_time: 当前时间（用于测试，生产环境传None）
|
||
|
||
Returns:
|
||
告警列表 [{"alert_type": "leave_post", ...}, {"alert_type": "alarm_resolve", ...}]
|
||
"""
|
||
current_time = current_time or datetime.now()
|
||
alerts = []
|
||
|
||
# 检查ROI内是否有目标
|
||
roi_has_person = any(
|
||
self._check_detection_in_roi(det, roi_id) and self._check_target_class(det, self.target_class)
|
||
for det in tracks
|
||
)
|
||
|
||
# 更新滑动窗口
|
||
self._update_detection_window(current_time, roi_has_person)
|
||
detection_ratio = self._get_detection_ratio()
|
||
|
||
# 检查工作时间
|
||
in_working_hours = self._is_in_working_hours(current_time)
|
||
|
||
# === 非工作时间处理 ===
|
||
if not in_working_hours:
|
||
if self.state != self.STATE_NON_WORK_TIME:
|
||
# 进入非工作时间，清理状态
|
||
if self._last_alarm_id and self._leave_start_time:
|
||
# 如果有未结束的告警，发送resolve事件（非工作时间自动关闭）
|
||
duration_ms = int((current_time - self._leave_start_time).total_seconds() * 1000)
|
||
alerts.append({
|
||
"alert_type": "alarm_resolve",
|
||
"resolve_alarm_id": self._last_alarm_id,
|
||
"duration_ms": duration_ms,
|
||
"last_frame_time": current_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
"resolve_type": "non_work_time",
|
||
})
|
||
|
||
self.state = self.STATE_NON_WORK_TIME
|
||
self.state_start_time = None
|
||
self.detection_window.clear()
|
||
self._last_alarm_id = None
|
||
self._leave_start_time = None
|
||
self._alarm_triggered_time = None
|
||
return alerts
|
||
|
||
# === 工作时间处理 ===
|
||
|
||
# 从非工作时间恢复
|
||
if self.state == self.STATE_NON_WORK_TIME:
|
||
self.state = self.STATE_INIT
|
||
self.state_start_time = current_time
|
||
self.detection_window.clear()
|
||
|
||
# === 状态机处理 ===
|
||
|
||
if self.state == self.STATE_INIT:
|
||
# 初始化状态：等待检测到人
|
||
if roi_has_person:
|
||
self.state = self.STATE_CONFIRMING_ON_DUTY
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: INIT → CONFIRMING_ON_DUTY")
|
||
|
||
elif self.state == self.STATE_CONFIRMING_ON_DUTY:
|
||
# 上岗确认中：需要持续检测到人
|
||
elapsed = (current_time - self.state_start_time).total_seconds()
|
||
|
||
if detection_ratio == 0:
|
||
# 人消失了，回到INIT
|
||
self.state = self.STATE_INIT
|
||
self.state_start_time = current_time
|
||
self.detection_window.clear()
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_ON_DUTY → INIT (人消失)")
|
||
elif elapsed >= self.confirm_on_duty_sec and detection_ratio >= 0.7:
|
||
# 上岗确认成功（命中率>=70%）
|
||
self.state = self.STATE_ON_DUTY
|
||
self.state_start_time = current_time
|
||
self.alert_cooldowns.clear() # 确认在岗后清除冷却记录
|
||
logger.info(f"ROI {roi_id}: CONFIRMING_ON_DUTY → ON_DUTY (上岗确认成功)")
|
||
|
||
elif self.state == self.STATE_ON_DUTY:
|
||
# 在岗状态：监控是否离岗
|
||
if detection_ratio == 0:
|
||
# 滑动窗口内完全没有人，进入离岗确认
|
||
self.state = self.STATE_CONFIRMING_OFF_DUTY
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: ON_DUTY → CONFIRMING_OFF_DUTY")
|
||
|
||
elif self.state == self.STATE_CONFIRMING_OFF_DUTY:
|
||
# 离岗确认中：需要持续未检测到人
|
||
elapsed = (current_time - self.state_start_time).total_seconds()
|
||
|
||
if roi_has_person:
|
||
# 人回来了，回到ON_DUTY
|
||
self.state = self.STATE_ON_DUTY
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_OFF_DUTY → ON_DUTY (人回来了)")
|
||
elif elapsed >= self.confirm_off_duty_sec and detection_ratio == 0:
|
||
# 离岗确认成功，进入倒计时
|
||
self.state = self.STATE_OFF_DUTY_COUNTDOWN
|
||
self.state_start_time = current_time
|
||
self._leave_start_time = self.state_start_time # 记录离开时间
|
||
logger.info(f"ROI {roi_id}: CONFIRMING_OFF_DUTY → OFF_DUTY_COUNTDOWN (离岗确认成功)")
|
||
|
||
elif self.state == self.STATE_OFF_DUTY_COUNTDOWN:
|
||
# 离岗倒计时中：等待告警触发
|
||
elapsed = (current_time - self.state_start_time).total_seconds()
|
||
|
||
if roi_has_person:
|
||
# 倒计时期间人回来了，回到ON_DUTY（未触发告警）
|
||
self.state = self.STATE_ON_DUTY
|
||
self.state_start_time = current_time
|
||
self._leave_start_time = None
|
||
logger.info(f"ROI {roi_id}: OFF_DUTY_COUNTDOWN → ON_DUTY (倒计时期间回来)")
|
||
elif elapsed >= self.leave_countdown_sec:
|
||
# 倒计时结束，触发告警
|
||
cooldown_key = f"{camera_id}_{roi_id}"
|
||
if cooldown_key not in self.alert_cooldowns or \
|
||
(current_time - self.alert_cooldowns[cooldown_key]).total_seconds() > self.cooldown_sec:
|
||
|
||
bbox = self._get_latest_bbox(tracks, roi_id)
|
||
|
||
alerts.append({
|
||
"track_id": roi_id,
|
||
"camera_id": camera_id,
|
||
"bbox": bbox,
|
||
"alert_type": "leave_post",
|
||
"message": "人员离岗告警",
|
||
"first_frame_time": self._leave_start_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
})
|
||
|
||
self.alert_cooldowns[cooldown_key] = current_time
|
||
self._alarm_triggered_time = current_time
|
||
self.state = self.STATE_ALARMED
|
||
# _last_alarm_id 由 main.py 通过 set_last_alarm_id() 回填
|
||
logger.warning(f"ROI {roi_id}: OFF_DUTY_COUNTDOWN → ALARMED (告警触发)")
|
||
|
||
elif self.state == self.STATE_ALARMED:
|
||
# 已告警状态：等待人员回岗
|
||
if roi_has_person:
|
||
# 检测到人，进入回岗确认
|
||
self.state = self.STATE_CONFIRMING_ON_DUTY # 复用上岗确认状态
|
||
self.state_start_time = current_time
|
||
logger.info(f"ROI {roi_id}: ALARMED → CONFIRMING_ON_DUTY (检测到人回岗)")
|
||
|
||
# 特殊处理：从CONFIRMING_ON_DUTY再次确认上岗时，如果有未结束的告警，发送resolve
|
||
if self.state == self.STATE_ON_DUTY and self._last_alarm_id:
|
||
# 回岗确认成功，发送resolve事件
|
||
duration_ms = int((current_time - self._leave_start_time).total_seconds() * 1000)
|
||
alerts.append({
|
||
"alert_type": "alarm_resolve",
|
||
"resolve_alarm_id": self._last_alarm_id,
|
||
"duration_ms": duration_ms,
|
||
"last_frame_time": current_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
"resolve_type": "person_returned",
|
||
})
|
||
|
||
# 清理告警追踪信息
|
||
self._last_alarm_id = None
|
||
self._leave_start_time = None
|
||
self._alarm_triggered_time = None
|
||
logger.info(f"ROI {roi_id}: 告警已解决（人员回岗）")
|
||
|
||
return alerts
|
||
|
||
def set_last_alarm_id(self, alarm_id: str):
|
||
"""由 main.py 在告警生成后回填 alarm_id"""
|
||
self._last_alarm_id = alarm_id
|
||
|
||
def reset(self):
|
||
"""重置算法状态"""
|
||
self.state = self.STATE_INIT
|
||
self.state_start_time = None
|
||
self.detection_window.clear()
|
||
self._last_alarm_id = None
|
||
self._leave_start_time = None
|
||
self._alarm_triggered_time = None
|
||
self.alert_cooldowns.clear()
|
||
|
||
def get_state(self, roi_id: str) -> Dict[str, Any]:
|
||
"""获取当前状态（用于调试和监控）"""
|
||
state_info = {
|
||
"state": self.state,
|
||
"state_start_time": self.state_start_time.isoformat() if self.state_start_time else None,
|
||
"detection_ratio": self._get_detection_ratio(),
|
||
"window_size": len(self.detection_window),
|
||
}
|
||
|
||
# 添加状态特定信息
|
||
if self.state == self.STATE_OFF_DUTY_COUNTDOWN and self.state_start_time:
|
||
elapsed = (datetime.now() - self.state_start_time).total_seconds()
|
||
state_info["countdown_remaining_sec"] = max(0, self.leave_countdown_sec - elapsed)
|
||
|
||
if self.state == self.STATE_ALARMED and self._leave_start_time:
|
||
total_off_duty_sec = (datetime.now() - self._leave_start_time).total_seconds()
|
||
state_info["total_off_duty_sec"] = total_off_duty_sec
|
||
state_info["alarm_id"] = self._last_alarm_id
|
||
|
||
return state_info
|
||
|
||
|
||
class IntrusionAlgorithm:
|
||
"""
|
||
周界入侵检测算法（状态机版本 v2.0）
|
||
|
||
状态机：
|
||
IDLE → CONFIRMING_INTRUSION → ALARMED → CONFIRMING_CLEAR → IDLE
|
||
|
||
业务流程：
|
||
1. 检测到人 → 入侵确认期（confirm_seconds，默认5秒）
|
||
2. 确认入侵 → 触发告警（ALARMED状态）
|
||
3. 人离开ROI → 入侵消失确认期（confirm_seconds，默认5秒）
|
||
4. 确认消失 → 发送resolve事件 → 回到空闲状态
|
||
"""
|
||
|
||
# 状态定义
|
||
STATE_IDLE = "IDLE" # 空闲（无入侵）
|
||
STATE_CONFIRMING_INTRUSION = "CONFIRMING_INTRUSION" # 入侵确认中
|
||
STATE_ALARMED = "ALARMED" # 已告警（等待入侵消失）
|
||
STATE_CONFIRMING_CLEAR = "CONFIRMING_CLEAR" # 入侵消失确认中
|
||
|
||
# 告警级别常量
|
||
ALARM_LEVEL_INTRUSION = 3
|
||
|
||
def __init__(
|
||
self,
|
||
cooldown_seconds: int = 300,
|
||
confirm_seconds: int = 5,
|
||
target_class: Optional[str] = None,
|
||
):
|
||
self.cooldown_seconds = cooldown_seconds
|
||
self.confirm_seconds = confirm_seconds
|
||
self.target_class = target_class
|
||
|
||
# 状态变量
|
||
self.state: str = self.STATE_IDLE
|
||
self.state_start_time: Optional[datetime] = None
|
||
|
||
# 告警追踪
|
||
self._last_alarm_id: Optional[str] = None
|
||
self._intrusion_start_time: Optional[datetime] = None
|
||
|
||
# 冷却期管理
|
||
self.alert_cooldowns: Dict[str, datetime] = {}
|
||
|
||
# 向后兼容：保留旧变量（不再使用）
|
||
self.last_alert_time: Dict[str, datetime] = {}
|
||
self.alert_triggered: Dict[str, bool] = {}
|
||
self.detection_start: Dict[str, Optional[datetime]] = {}
|
||
|
||
def _check_detection_in_roi(self, detection: Dict, roi_id: str) -> bool:
|
||
matched_rois = detection.get("matched_rois", [])
|
||
for roi in matched_rois:
|
||
if roi.get("roi_id") == roi_id:
|
||
return True
|
||
return False
|
||
|
||
def _check_target_class(self, detection: Dict, target_class: Optional[str]) -> bool:
|
||
if not target_class:
|
||
return True
|
||
return detection.get("class") == target_class
|
||
|
||
def _get_latest_bbox(self, tracks: List[Dict], roi_id: str) -> List[float]:
|
||
for det in tracks:
|
||
if self._check_detection_in_roi(det, roi_id):
|
||
return det.get("bbox", [])
|
||
return []
|
||
|
||
def process(
|
||
self,
|
||
roi_id: str,
|
||
camera_id: str,
|
||
tracks: List[Dict],
|
||
current_time: Optional[datetime] = None,
|
||
) -> List[Dict]:
|
||
"""
|
||
处理单帧检测结果
|
||
|
||
Args:
|
||
roi_id: ROI区域ID
|
||
camera_id: 摄像头ID
|
||
tracks: 检测结果列表
|
||
current_time: 当前时间（用于测试，生产环境传None）
|
||
|
||
Returns:
|
||
告警列表 [{"alert_type": "intrusion", ...}, {"alert_type": "alarm_resolve", ...}]
|
||
"""
|
||
current_time = current_time or datetime.now()
|
||
alerts = []
|
||
|
||
# 检查ROI内是否有目标
|
||
roi_has_person = any(
|
||
self._check_detection_in_roi(det, roi_id) and self._check_target_class(det, self.target_class)
|
||
for det in tracks
|
||
)
|
||
|
||
# === 状态机处理 ===
|
||
|
||
if self.state == self.STATE_IDLE:
|
||
# 空闲状态：等待检测到入侵
|
||
if roi_has_person:
|
||
self.state = self.STATE_CONFIRMING_INTRUSION
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: IDLE → CONFIRMING_INTRUSION")
|
||
|
||
elif self.state == self.STATE_CONFIRMING_INTRUSION:
|
||
# 入侵确认中：需要持续检测到人
|
||
if self.state_start_time is None:
|
||
# 防御性编程：如果状态时间为空，重置到IDLE
|
||
self.state = self.STATE_IDLE
|
||
logger.error(f"ROI {roi_id}: CONFIRMING_INTRUSION 状态异常，state_start_time为None，重置到IDLE")
|
||
else:
|
||
elapsed = (current_time - self.state_start_time).total_seconds()
|
||
|
||
if not roi_has_person:
|
||
# 人消失了，回到IDLE
|
||
self.state = self.STATE_IDLE
|
||
self.state_start_time = None
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_INTRUSION → IDLE (人消失)")
|
||
elif elapsed >= self.confirm_seconds:
|
||
# 入侵确认成功，检查冷却期
|
||
cooldown_key = f"{camera_id}_{roi_id}"
|
||
if cooldown_key not in self.alert_cooldowns or \
|
||
(current_time - self.alert_cooldowns[cooldown_key]).total_seconds() > self.cooldown_seconds:
|
||
|
||
bbox = self._get_latest_bbox(tracks, roi_id)
|
||
self._intrusion_start_time = self.state_start_time # 记录入侵开始时间
|
||
|
||
alerts.append({
|
||
"roi_id": roi_id,
|
||
"camera_id": camera_id,
|
||
"bbox": bbox,
|
||
"alert_type": "intrusion",
|
||
"alarm_level": self.ALARM_LEVEL_INTRUSION,
|
||
"message": "检测到周界入侵",
|
||
"first_frame_time": self._intrusion_start_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
})
|
||
|
||
self.alert_cooldowns[cooldown_key] = current_time
|
||
self.state = self.STATE_ALARMED
|
||
# _last_alarm_id 由 main.py 通过 set_last_alarm_id() 回填
|
||
logger.warning(f"ROI {roi_id}: CONFIRMING_INTRUSION → ALARMED (告警触发)")
|
||
else:
|
||
# 冷却期内，回到IDLE
|
||
self.state = self.STATE_IDLE
|
||
self.state_start_time = None
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_INTRUSION → IDLE (冷却期内)")
|
||
|
||
elif self.state == self.STATE_ALARMED:
|
||
# 已告警状态：等待入侵消失
|
||
if not roi_has_person:
|
||
# 检测到无人，进入消失确认
|
||
self.state = self.STATE_CONFIRMING_CLEAR
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: ALARMED → CONFIRMING_CLEAR")
|
||
|
||
elif self.state == self.STATE_CONFIRMING_CLEAR:
|
||
# 入侵消失确认中：需要持续未检测到人
|
||
if self.state_start_time is None:
|
||
# 防御性编程：如果状态时间为空，重置到IDLE
|
||
self.state = self.STATE_IDLE
|
||
logger.error(f"ROI {roi_id}: CONFIRMING_CLEAR 状态异常，state_start_time为None，重置到IDLE")
|
||
else:
|
||
elapsed = (current_time - self.state_start_time).total_seconds()
|
||
|
||
if roi_has_person:
|
||
# 人又出现了，回到ALARMED
|
||
self.state = self.STATE_ALARMED
|
||
self.state_start_time = current_time
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_CLEAR → ALARMED (人又出现)")
|
||
elif elapsed >= self.confirm_seconds:
|
||
# 消失确认成功，发送resolve事件
|
||
if self._last_alarm_id and self._intrusion_start_time:
|
||
duration_ms = int((current_time - self._intrusion_start_time).total_seconds() * 1000)
|
||
alerts.append({
|
||
"alert_type": "alarm_resolve",
|
||
"resolve_alarm_id": self._last_alarm_id,
|
||
"duration_ms": duration_ms,
|
||
"last_frame_time": current_time.strftime('%Y-%m-%d %H:%M:%S'),
|
||
"resolve_type": "intrusion_cleared",
|
||
})
|
||
|
||
logger.info(f"ROI {roi_id}: 告警已解决（入侵消失）")
|
||
|
||
# 重置状态
|
||
self.state = self.STATE_IDLE
|
||
self.state_start_time = None
|
||
self._last_alarm_id = None
|
||
self._intrusion_start_time = None
|
||
logger.debug(f"ROI {roi_id}: CONFIRMING_CLEAR → IDLE (消失确认成功)")
|
||
|
||
return alerts
|
||
|
||
def set_last_alarm_id(self, alarm_id: str):
|
||
"""由 main.py 在告警生成后回填 alarm_id"""
|
||
self._last_alarm_id = alarm_id
|
||
|
||
def reset(self):
|
||
"""重置算法状态"""
|
||
self.state = self.STATE_IDLE
|
||
self.state_start_time = None
|
||
self._last_alarm_id = None
|
||
self._intrusion_start_time = None
|
||
self.alert_cooldowns.clear()
|
||
# 向后兼容
|
||
self.last_alert_time.clear()
|
||
self.alert_triggered.clear()
|
||
self.detection_start.clear()
|
||
|
||
def get_state(self, current_time: Optional[datetime] = None) -> Dict[str, Any]:
|
||
"""获取当前状态（用于调试和监控）"""
|
||
current_time = current_time or datetime.now()
|
||
|
||
state_info = {
|
||
"state": self.state,
|
||
"state_start_time": self.state_start_time.isoformat() if self.state_start_time else None,
|
||
}
|
||
|
||
# 添加状态特定信息
|
||
if self.state == self.STATE_ALARMED and self._intrusion_start_time:
|
||
total_intrusion_sec = (current_time - self._intrusion_start_time).total_seconds()
|
||
state_info["total_intrusion_sec"] = total_intrusion_sec
|
||
state_info["alarm_id"] = self._last_alarm_id
|
||
|
||
return state_info
|
||
|
||
|
||
# class CrowdDetectionAlgorithm:
|
||
# """人群聚集检测算法 - 暂时注释，后续需要时再启用"""
|
||
#
|
||
# def __init__(
|
||
# self,
|
||
# max_count: int = 10,
|
||
# cooldown_seconds: int = 300,
|
||
# target_class: Optional[str] = "person",
|
||
# ):
|
||
# self.max_count = max_count
|
||
# self.cooldown_seconds = cooldown_seconds
|
||
# self.target_class = target_class
|
||
#
|
||
# self.last_alert_time: Dict[str, datetime] = {}
|
||
# self.alert_triggered: Dict[str, bool] = {}
|
||
#
|
||
# def _check_detection_in_roi(self, detection: Dict, roi_id: str) -> bool:
|
||
# matched_rois = detection.get("matched_rois", [])
|
||
# for roi in matched_rois:
|
||
# if roi.get("roi_id") == roi_id:
|
||
# return True
|
||
# return False
|
||
#
|
||
# def _check_target_class(self, detection: Dict, target_class: Optional[str]) -> bool:
|
||
# if not target_class:
|
||
# return True
|
||
# return detection.get("class") == target_class
|
||
#
|
||
# def _get_bboxes(self, tracks: List[Dict], roi_id: str) -> List[List[float]]:
|
||
# bboxes = []
|
||
# for det in tracks:
|
||
# if self._check_detection_in_roi(det, roi_id) and self._check_target_class(det, self.target_class):
|
||
# bboxes.append(det.get("bbox", []))
|
||
# return bboxes
|
||
#
|
||
# def process(
|
||
# self,
|
||
# roi_id: str,
|
||
# camera_id: str,
|
||
# tracks: List[Dict],
|
||
# current_time: Optional[datetime] = None,
|
||
# ) -> List[Dict]:
|
||
# current_time = current_time or datetime.now()
|
||
# key = f"{camera_id}_{roi_id}"
|
||
#
|
||
# person_count = 0
|
||
# for det in tracks:
|
||
# if self._check_detection_in_roi(det, roi_id) and self._check_target_class(det, self.target_class):
|
||
# person_count += 1
|
||
#
|
||
# if person_count <= self.max_count:
|
||
# self.alert_triggered[key] = False
|
||
# return []
|
||
#
|
||
# if self.alert_triggered.get(key, False):
|
||
# elapsed_since_alert = (current_time - self.last_alert_time.get(key, datetime.min)).total_seconds()
|
||
# if elapsed_since_alert < self.cooldown_seconds:
|
||
# return []
|
||
# self.alert_triggered[key] = False
|
||
#
|
||
# bboxes = self._get_bboxes(tracks, roi_id)
|
||
# self.last_alert_time[key] = current_time
|
||
# self.alert_triggered[key] = True
|
||
#
|
||
# return [{
|
||
# "roi_id": roi_id,
|
||
# "camera_id": camera_id,
|
||
# "bbox": bboxes[0] if bboxes else [],
|
||
# "alert_type": "crowd_detection",
|
||
# "message": f"检测到人群聚集，当前人数: {person_count}",
|
||
# "count": person_count,
|
||
# }]
|
||
#
|
||
# def reset(self):
|
||
# self.last_alert_time.clear()
|
||
# self.alert_triggered.clear()
|
||
|
||
|
||
class AlgorithmManager:
|
||
def __init__(self, working_hours: Optional[List[Dict]] = None):
|
||
self.algorithms: Dict[str, Dict[str, Any]] = {}
|
||
self.working_hours = working_hours or []
|
||
self._update_lock = threading.Lock()
|
||
self._registered_keys: set = set() # 已注册的 (roi_id, bind_id, algo_type) 缓存
|
||
|
||
self.default_params = {
|
||
"leave_post": {
|
||
"confirm_on_duty_sec": 10,
|
||
"confirm_leave_sec": 30,
|
||
"cooldown_sec": 600,
|
||
"target_class": "person",
|
||
},
|
||
"intrusion": {
|
||
"cooldown_seconds": 300,
|
||
"confirm_seconds": 5,
|
||
"target_class": None,
|
||
},
|
||
# "crowd_detection": {
|
||
# "max_count": 10,
|
||
# "cooldown_seconds": 300,
|
||
# "target_class": "person",
|
||
# },
|
||
}
|
||
|
||
self._pubsub = None
|
||
self._pubsub_thread = None
|
||
self._running = False
|
||
|
||
def start_config_subscription(self):
|
||
"""启动配置变更订阅"""
|
||
try:
|
||
from config.settings import get_settings
|
||
settings = get_settings()
|
||
if settings.config_sync_mode != "REDIS":
|
||
logger.info("CONFIG_SYNC_MODE=LOCAL: 跳过 Redis 配置订阅")
|
||
return
|
||
redis_client = redis.Redis(
|
||
host=settings.redis.host,
|
||
port=settings.redis.port,
|
||
db=settings.redis.db,
|
||
password=settings.redis.password,
|
||
decode_responses=True,
|
||
)
|
||
|
||
self._pubsub = redis_client.pubsub()
|
||
self._pubsub.subscribe("config_update")
|
||
|
||
self._running = True
|
||
self._pubsub_thread = threading.Thread(
|
||
target=self._config_update_worker,
|
||
name="ConfigUpdateSub",
|
||
daemon=True
|
||
)
|
||
self._pubsub_thread.start()
|
||
logger.info("已启动配置变更订阅")
|
||
except Exception as e:
|
||
logger.error(f"启动配置订阅失败: {e}")
|
||
|
||
def _config_update_worker(self):
|
||
"""配置更新订阅工作线程"""
|
||
try:
|
||
for message in self._pubsub.listen():
|
||
if not self._running:
|
||
break
|
||
if message["type"] == "message":
|
||
try:
|
||
import json
|
||
data = json.loads(message["data"])
|
||
update_type = data.get("type", "full")
|
||
if update_type == "roi":
|
||
roi_ids = data.get("ids", [])
|
||
if roi_ids:
|
||
for roi_id in roi_ids:
|
||
self.reload_algorithm(roi_id)
|
||
else:
|
||
self.reload_all_algorithms()
|
||
elif update_type == "bind":
|
||
bind_ids = data.get("ids", [])
|
||
if bind_ids:
|
||
for bind_id in bind_ids:
|
||
self.reload_bind_algorithm(bind_id)
|
||
else:
|
||
self.reload_all_algorithms()
|
||
else:
|
||
# type="full" / "camera" / unknown → 全量重载
|
||
self.reload_all_algorithms()
|
||
except Exception as e:
|
||
logger.error(f"处理配置更新消息失败: {e}")
|
||
except Exception as e:
|
||
logger.error(f"配置订阅线程异常: {e}")
|
||
|
||
def stop_config_subscription(self):
|
||
"""停止配置变更订阅"""
|
||
self._running = False
|
||
if self._pubsub:
|
||
self._pubsub.close()
|
||
if self._pubsub_thread and self._pubsub_thread.is_alive():
|
||
self._pubsub_thread.join(timeout=5)
|
||
logger.info("配置订阅已停止")
|
||
|
||
def load_bind_from_redis(self, bind_id: str) -> bool:
|
||
"""从Redis加载单个绑定配置的算法"""
|
||
try:
|
||
from core.config_sync import get_config_sync_manager
|
||
config_manager = get_config_sync_manager()
|
||
bind_config = config_manager.get_algo_bind_from_redis(bind_id)
|
||
|
||
if not bind_config:
|
||
return False
|
||
|
||
with self._update_lock:
|
||
roi_id = bind_config.get("roi_id")
|
||
algo_code = bind_config.get("algo_code", "leave_post")
|
||
raw_params = bind_config.get("params")
|
||
if isinstance(raw_params, str):
|
||
try:
|
||
import json
|
||
params = json.loads(raw_params) or {}
|
||
except Exception:
|
||
params = {}
|
||
elif isinstance(raw_params, dict):
|
||
params = raw_params
|
||
else:
|
||
params = {}
|
||
|
||
if roi_id not in self.algorithms:
|
||
self.algorithms[roi_id] = {}
|
||
|
||
key = f"{roi_id}_{bind_id}"
|
||
|
||
if algo_code == "leave_post":
|
||
algo_params = {
|
||
"confirm_on_duty_sec": params.get("confirm_on_duty_sec", 10),
|
||
"confirm_leave_sec": params.get("confirm_leave_sec", 30),
|
||
"cooldown_sec": params.get("cooldown_sec", 600),
|
||
"working_hours": params.get("working_hours", []),
|
||
"target_class": params.get("target_class", bind_config.get("target_class", "person")),
|
||
}
|
||
if key in self.algorithms.get(roi_id, {}) and "leave_post" in self.algorithms[roi_id].get(key, {}):
|
||
algo = self.algorithms[roi_id][key]["leave_post"]
|
||
algo.confirm_on_duty_sec = algo_params["confirm_on_duty_sec"]
|
||
algo.confirm_leave_sec = algo_params["confirm_leave_sec"]
|
||
algo.cooldown_sec = algo_params["cooldown_sec"]
|
||
algo.target_class = algo_params["target_class"]
|
||
if algo_params["working_hours"]:
|
||
algo.working_hours = algo_params["working_hours"]
|
||
logger.info(f"已热更新算法参数: {key}")
|
||
else:
|
||
self.algorithms[roi_id][key] = {}
|
||
self.algorithms[roi_id][key]["leave_post"] = LeavePostAlgorithm(
|
||
confirm_on_duty_sec=algo_params["confirm_on_duty_sec"],
|
||
confirm_leave_sec=algo_params["confirm_leave_sec"],
|
||
leave_countdown_sec=algo_params.get("leave_countdown_sec", 300), # 离岗倒计时，默认5分钟
|
||
cooldown_sec=algo_params["cooldown_sec"],
|
||
working_hours=algo_params["working_hours"],
|
||
target_class=algo_params["target_class"],
|
||
)
|
||
logger.info(f"已从Redis加载算法: {key}")
|
||
elif algo_code == "intrusion":
|
||
algo_params = {
|
||
"cooldown_seconds": params.get("cooldown_seconds", 300),
|
||
"confirm_seconds": params.get("confirm_seconds", 5),
|
||
"target_class": params.get("target_class", bind_config.get("target_class")),
|
||
}
|
||
self.algorithms[roi_id][key] = {}
|
||
self.algorithms[roi_id][key]["intrusion"] = IntrusionAlgorithm(
|
||
cooldown_seconds=algo_params["cooldown_seconds"],
|
||
confirm_seconds=algo_params["confirm_seconds"],
|
||
target_class=algo_params["target_class"],
|
||
)
|
||
logger.info(f"已从Redis加载算法: {key}")
|
||
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"从Redis加载算法配置失败: {e}")
|
||
return False
|
||
|
||
def reload_bind_algorithm(self, bind_id: str) -> bool:
|
||
"""重新加载单个绑定的算法配置"""
|
||
return self.load_bind_from_redis(bind_id)
|
||
|
||
def reload_algorithm(self, roi_id: str) -> bool:
|
||
"""重新加载单个ROI的所有算法绑定配置"""
|
||
try:
|
||
from core.config_sync import get_config_sync_manager
|
||
config_manager = get_config_sync_manager()
|
||
bindings = config_manager.get_bindings_from_redis(roi_id)
|
||
|
||
if not bindings:
|
||
return False
|
||
|
||
for bind in bindings:
|
||
bind_id = bind.get("bind_id")
|
||
self.reset_algorithm(roi_id, bind_id)
|
||
self.load_bind_from_redis(bind_id)
|
||
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"重新加载ROI算法配置失败: {e}")
|
||
return False
|
||
|
||
def reload_all_algorithms(self) -> int:
|
||
"""重新加载所有算法配置"""
|
||
count = 0
|
||
try:
|
||
from core.config_sync import get_config_sync_manager
|
||
config_manager = get_config_sync_manager()
|
||
bindings = config_manager.get_bindings_from_redis("")
|
||
|
||
for bind in bindings:
|
||
bind_id = bind.get("bind_id")
|
||
roi_id = bind.get("roi_id")
|
||
self.reset_algorithm(roi_id, bind_id)
|
||
if self.load_bind_from_redis(bind_id):
|
||
count += 1
|
||
|
||
logger.info(f"已重新加载 {count} 个算法配置")
|
||
return count
|
||
except Exception as e:
|
||
logger.error(f"重新加载所有算法配置失败: {e}")
|
||
return count
|
||
|
||
def register_algorithm(
|
||
self,
|
||
roi_id: str,
|
||
bind_id: str,
|
||
algorithm_type: str,
|
||
params: Optional[Dict[str, Any]] = None,
|
||
):
|
||
"""注册算法（支持绑定ID），使用缓存避免每帧重复查询"""
|
||
cache_key = (roi_id, bind_id, algorithm_type)
|
||
|
||
# 快速路径：已注册直接返回
|
||
if cache_key in self._registered_keys:
|
||
return
|
||
|
||
key = f"{roi_id}_{bind_id}"
|
||
|
||
if roi_id not in self.algorithms:
|
||
self.algorithms[roi_id] = {}
|
||
|
||
if key not in self.algorithms[roi_id]:
|
||
self.algorithms[roi_id][key] = {}
|
||
|
||
algo_params = self.default_params.get(algorithm_type, {}).copy()
|
||
if params:
|
||
algo_params.update(params)
|
||
|
||
if algorithm_type == "leave_post":
|
||
roi_working_hours = algo_params.get("working_hours") or self.working_hours
|
||
self.algorithms[roi_id][key]["leave_post"] = LeavePostAlgorithm(
|
||
confirm_on_duty_sec=algo_params.get("confirm_on_duty_sec", 10),
|
||
confirm_leave_sec=algo_params.get("confirm_leave_sec", 30),
|
||
leave_countdown_sec=algo_params.get("leave_countdown_sec", 300), # 离岗倒计时，默认5分钟
|
||
cooldown_sec=algo_params.get("cooldown_sec", 600),
|
||
working_hours=roi_working_hours,
|
||
target_class=algo_params.get("target_class", "person"),
|
||
)
|
||
elif algorithm_type == "intrusion":
|
||
self.algorithms[roi_id][key]["intrusion"] = IntrusionAlgorithm(
|
||
cooldown_seconds=algo_params.get("cooldown_seconds", 300),
|
||
confirm_seconds=algo_params.get("confirm_seconds", 5),
|
||
target_class=algo_params.get("target_class"),
|
||
)
|
||
# elif algorithm_type == "crowd_detection":
|
||
# from algorithms import CrowdDetectionAlgorithm
|
||
# self.algorithms[roi_id][key]["crowd_detection"] = CrowdDetectionAlgorithm(
|
||
# max_count=algo_params.get("max_count", 10),
|
||
# cooldown_seconds=algo_params.get("cooldown_seconds", 300),
|
||
# target_class=algo_params.get("target_class", "person"),
|
||
# )
|
||
|
||
self._registered_keys.add(cache_key)
|
||
|
||
def process(
|
||
self,
|
||
roi_id: str,
|
||
bind_id: str,
|
||
camera_id: str,
|
||
algorithm_type: str,
|
||
tracks: List[Dict],
|
||
current_time: Optional[datetime] = None,
|
||
) -> List[Dict]:
|
||
"""处理检测结果（支持绑定ID）"""
|
||
key = f"{roi_id}_{bind_id}"
|
||
algo = self.algorithms.get(roi_id, {}).get(key, {}).get(algorithm_type)
|
||
if algo is None:
|
||
return []
|
||
return algo.process(roi_id, camera_id, tracks, current_time)
|
||
|
||
def update_roi_params(
|
||
self,
|
||
roi_id: str,
|
||
bind_id: str,
|
||
algorithm_type: str,
|
||
params: Dict[str, Any],
|
||
):
|
||
"""更新算法参数（支持绑定ID）"""
|
||
key = f"{roi_id}_{bind_id}"
|
||
if roi_id in self.algorithms and key in self.algorithms[roi_id] and algorithm_type in self.algorithms[roi_id][key]:
|
||
algo = self.algorithms[roi_id][key][algorithm_type]
|
||
for param_key, value in params.items():
|
||
if hasattr(algo, param_key):
|
||
setattr(algo, param_key, value)
|
||
|
||
def reset_algorithm(self, roi_id: str, bind_id: Optional[str] = None):
|
||
"""重置算法状态（支持绑定ID）"""
|
||
if roi_id not in self.algorithms:
|
||
return
|
||
|
||
if bind_id:
|
||
key = f"{roi_id}_{bind_id}"
|
||
if key in self.algorithms[roi_id]:
|
||
for algo in self.algorithms[roi_id][key].values():
|
||
algo.reset()
|
||
# 清除注册缓存
|
||
self._registered_keys = {
|
||
k for k in self._registered_keys
|
||
if not (k[0] == roi_id and k[1] == bind_id)
|
||
}
|
||
else:
|
||
for key in self.algorithms[roi_id]:
|
||
for algo in self.algorithms[roi_id][key].values():
|
||
algo.reset()
|
||
# 清除该 roi 的所有注册缓存
|
||
self._registered_keys = {
|
||
k for k in self._registered_keys if k[0] != roi_id
|
||
}
|
||
|
||
def reset_all(self):
|
||
"""重置所有算法"""
|
||
for roi_algorithms in self.algorithms.values():
|
||
for bind_algorithms in roi_algorithms.values():
|
||
for algo in bind_algorithms.values():
|
||
algo.reset()
|
||
|
||
def remove_roi(self, roi_id: str):
|
||
"""移除ROI的所有算法"""
|
||
if roi_id in self.algorithms:
|
||
for key in list(self.algorithms[roi_id].keys()):
|
||
self.reset_algorithm(roi_id, key.split("_")[-1] if "_" in key else None)
|
||
del self.algorithms[roi_id]
|
||
|
||
def remove_bind(self, roi_id: str, bind_id: str):
|
||
"""移除绑定的算法"""
|
||
key = f"{roi_id}_{bind_id}"
|
||
if roi_id in self.algorithms and key in self.algorithms[roi_id]:
|
||
for algo in self.algorithms[roi_id][key].values():
|
||
algo.reset()
|
||
del self.algorithms[roi_id][key]
|
||
|
||
def get_status(self, roi_id: str) -> Dict[str, Any]:
|
||
"""获取算法状态"""
|
||
status = {}
|
||
if roi_id in self.algorithms:
|
||
for key, bind_algorithms in self.algorithms[roi_id].items():
|
||
bind_id = key.split("_", 1)[-1] if "_" in key else ""
|
||
for algo_type, algo in bind_algorithms.items():
|
||
if algo_type == "leave_post":
|
||
status[f"{algo_type}_{bind_id}"] = {
|
||
"state": getattr(algo, "state", "WAITING"),
|
||
"alarm_sent": getattr(algo, "alarm_sent", False),
|
||
}
|
||
else:
|
||
status[f"{algo_type}_{bind_id}"] = {
|
||
"detection_count": len(getattr(algo, "detection_start", {})),
|
||
}
|
||
return status
|