yovision/Brain/yovision_brain/runtime.py

from __future__ import annotations

import math
import threading
import time
from collections import deque
from datetime import datetime, timezone
from typing import Any

from .domain import Detection, Point, Zone, ZoneEntryEvaluator, zone_from_payload
from .source import CentroidTracker, HOGPersonDetector, require_opencv

try:
    import cv2  # type: ignore
except ImportError:  # pragma: no cover
    cv2 = None


DEFAULT_ZONE = Zone(
    "zone-demo-01",
    "楼梯口危险区",
    1,
    (Point(0.55, 0.30), Point(0.90, 0.30), Point(0.90, 0.88), Point(0.55, 0.88)),
)


class EventIngressUnavailable(RuntimeError):
    pass


class DemoEngine:
    def __init__(self, source: Any, fps: float = 2.0, event_limit: int = 100, event_ingress: Any | None = None) -> None:
        if not math.isfinite(fps) or fps <= 0.0 or fps > 30.0:
            raise ValueError("fps must be within (0, 30]")
        if not 1 <= event_limit <= 100:
            raise ValueError("event_limit must be within [1, 100]")
        require_opencv()
        self._source = source
        self._fps = fps
        self._detector = None if source.fixture else HOGPersonDetector()
        self._tracker = CentroidTracker()
        self._evaluator = ZoneEntryEvaluator(source.source_ref, source.fixture)
        self._event_ingress = event_ingress
        self._zone = DEFAULT_ZONE
        self._events: deque[dict[str, object]] = deque(maxlen=event_limit)
        self._lock = threading.RLock()
        self._stop = threading.Event()
        self._thread: threading.Thread | None = None
        self._sequence = 0
        self._frame_jpeg: bytes | None = None
        self._frame_width = 0
        self._frame_height = 0
        self._captured_at: str | None = None
        self._detections: list[dict[str, object]] = []
        self._latency_ms: float | None = None
        self._connected = False
        self._last_error_code: str | None = None

    def start(self) -> None:
        if self._thread is not None:
            return
        if self._event_ingress is not None:
            self._event_ingress.start()
        self._thread = threading.Thread(target=self._run, name="brain-demo", daemon=True)
        self._thread.start()

    def stop(self) -> None:
        self._stop.set()
        if self._thread is not None:
            self._thread.join(timeout=3.0)
            self._thread = None
        if self._event_ingress is not None:
            self._event_ingress.stop()
        self._source.close()

    def _run(self) -> None:
        interval = 1.0 / self._fps
        while not self._stop.is_set():
            started = time.perf_counter()
            try:
                self.step()
            except EventIngressUnavailable:
                with self._lock:
                    self._last_error_code = "event_outbox_unavailable"
            except RuntimeError:
                with self._lock:
                    self._connected = False
                    self._last_error_code = "source_unavailable"
            elapsed = time.perf_counter() - started
            self._stop.wait(max(0.0, interval - elapsed))

    def step(self) -> None:
        started = time.perf_counter()
        packet = self._source.read()
        self._sequence += 1
        if packet.scripted_detections is not None:
            detections = list(packet.scripted_detections)
        else:
            raw_boxes = self._detector.detect(packet.frame) if self._detector is not None else []
            detections = self._tracker.update(raw_boxes, self._sequence)
        with self._lock:
            zone = self._zone
        new_events, inside_by_track = self._evaluator.evaluate(self._sequence, packet.captured_at, zone, detections)
        if self._event_ingress is not None:
            try:
                for item in new_events:
                    self._event_ingress.submit(item)
            except Exception as exc:
                raise EventIngressUnavailable("persist event candidate") from exc
        ok, encoded = cv2.imencode(".jpg", packet.frame, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
        if not ok:
            raise RuntimeError("frame encoding failed")
        height, width = packet.frame.shape[:2]
        serialized_detections = [self._serialize_detection(item, inside_by_track.get(item.track_id, False)) for item in detections]
        with self._lock:
            for event in new_events:
                serialized_event = event.as_dict()
                if self._event_ingress is not None:
                    # This is an immutable handoff fact, not a live delivery
                    # status. Current counts live under event_ingress.
                    serialized_event["delivery_status"] = "outbox_persisted"
                self._events.appendleft(serialized_event)
            self._frame_jpeg = encoded.tobytes()
            self._frame_width = int(width)
            self._frame_height = int(height)
            self._captured_at = packet.captured_at.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
            self._detections = serialized_detections
            self._latency_ms = round((time.perf_counter() - started) * 1000.0, 1)
            self._connected = True
            self._last_error_code = None

    @staticmethod
    def _serialize_detection(detection: Detection, inside: bool) -> dict[str, object]:
        return {
            "track_id": detection.track_id,
            "class": detection.class_name,
            "bbox": [detection.box.x1, detection.box.y1, detection.box.x2, detection.box.y2],
            "detector_score": detection.detector_score,
            "inside_zone": inside,
        }

    def update_zone(self, payload: object) -> Zone:
        with self._lock:
            updated = zone_from_payload(payload, self._zone)
            self._zone = updated
            self._evaluator.reset()
            return updated

    def frame_jpeg(self) -> bytes | None:
        with self._lock:
            return self._frame_jpeg

    def state(self) -> dict[str, object]:
        with self._lock:
            zone = self._zone
            if self._event_ingress is None:
                ingress_status: dict[str, object] = {"enabled": False}
            else:
                try:
                    ingress_status = self._event_ingress.status()
                except Exception:
                    ingress_status = {"enabled": True, "last_error_code": "event_outbox_unavailable"}
            return {
                "prototype": True,
                "notice": "工程原型；合成回放不是模型输出，HOG 适配器不是生产检测模型。",
                "source": {
                    "mode": self._source.mode,
                    "label": self._source.label,
                    "fixture": self._source.fixture,
                    "connected": self._connected,
                    "ref": self._source.source_ref,
                },
                "detector": {
                    "name": "scripted_fixture" if self._source.fixture else self._detector.name,
                    "production_ready": False,
                },
                "frame": {
                    "sequence": self._sequence,
                    "width": self._frame_width,
                    "height": self._frame_height,
                    "captured_at": self._captured_at,
                },
                "inference": {"target_fps": self._fps, "latency_ms": self._latency_ms},
                "zone": {
                    "id": zone.zone_id,
                    "name": zone.name,
                    "version": zone.version,
                    "points": [{"x": point.x, "y": point.y} for point in zone.points],
                },
                "detections": list(self._detections),
                "events": list(self._events),
                "event_ingress": ingress_status,
                "last_error_code": self._last_error_code,
                "generated_at": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
            }