kamera geht

halloween/detection.py

@@ -0,0 +1,351 @@
+"""Lokale Personendetektion und zeitlich begrenzte Linienverfolgung."""
+
+import base64
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import tempfile
+import threading
+import time
+from io import BytesIO
+
+from PIL import Image
+
+
+DEFAULT_CONFIG = {"enabled": False, "line": [[0.2, 0.55], [0.8, 0.55]],
+                  "direction": 1, "region": [0.1, 0.15, 0.9, 0.95]}
+
+
+def validate_config(value):
+    if set(value) != set(DEFAULT_CONFIG) or type(value["enabled"]) is not bool:
+        raise ValueError("Ungültige Erkennungseinstellungen")
+    if type(value["direction"]) is not int or value["direction"] not in (-1, 1):
+        raise ValueError("Richtung muss -1 oder 1 sein")
+    line, region = value["line"], value["region"]
+    if len(line) != 2 or any(len(p) != 2 for p in line) or len(region) != 4:
+        raise ValueError("Linie und Bereich benötigen gültige Koordinaten")
+    coords = [*line[0], *line[1], *region]
+    if any(type(x) not in (int, float) or not math.isfinite(x) or not 0 <= x <= 1 for x in coords):
+        raise ValueError("Koordinaten müssen zwischen 0 und 1 liegen")
+    x1, y1, x2, y2 = region
+    if x2 - x1 < 0.05 or y2 - y1 < 0.05:
+        raise ValueError("Auslösebereich ist zu klein")
+    if math.dist(*line) < 0.05 or any(not (x1 <= x <= x2 and y1 <= y <= y2) for x, y in line):
+        raise ValueError("Linie muss im Auslösebereich liegen und ausreichend lang sein")
+    return json.loads(json.dumps(value))
+
+
+class NanoDet:
+    """ONNX-Decoder für OpenCV Zoo NanoDet-m-plus-1.5x_416 (November 2022)."""
+
+    def __init__(self, path: Path):
+        manifest = json.loads((Path(__file__).parent / "nanodet-model.json").read_text())
+        if not path.is_file():
+            raise FileNotFoundError("NanoDet fehlt; tools/install_detection_model.py ausführen")
+        if hashlib.sha256(path.read_bytes()).hexdigest() != manifest["sha256"]:
+            raise ValueError("NanoDet-Prüfsumme stimmt nicht")
+        import cv2
+        import numpy as np
+        self.cv, self.np = cv2, np
+        self.net = cv2.dnn.readNetFromONNX(str(path))
+        self.net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
+        self.net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)
+
+    def detect(self, jpeg):
+        cv, np = self.cv, self.np
+        rgb = np.asarray(Image.open(BytesIO(jpeg)).convert("RGB"))
+        h, w = rgb.shape[:2]
+        scale = min(416 / w, 416 / h)
+        nw, nh = round(w * scale), round(h * scale)
+        left, top = (416 - nw) // 2, (416 - nh) // 2
+        image = np.zeros((416, 416, 3), dtype=np.float32)
+        image[:] = [103.53, 116.28, 123.675]
+        image[top:top+nh, left:left+nw] = cv.resize(rgb[:, :, ::-1], (nw, nh))
+        image = (image - np.array([103.53, 116.28, 123.675], np.float32)) / np.array([57.375, 57.12, 58.395], np.float32)
+        self.net.setInput(cv.dnn.blobFromImage(image))
+        outputs = self.net.forward(self.net.getUnconnectedOutLayersNames())
+        if len(outputs) != 6:
+            raise ValueError("Unerwartete NanoDet-Ausgänge")
+        boxes, scores = [], []
+        for level, stride in enumerate((8, 16, 32)):
+            classes = outputs[2 * level].reshape(-1, 80)
+            logits = outputs[2 * level + 1].reshape(-1, 4, 8)
+            side = 416 // stride
+            if len(classes) != side * side or len(logits) != len(classes):
+                raise ValueError("Unerwartete NanoDet-Dimensionen")
+            candidates = np.flatnonzero((classes[:, 0] >= 0.6) & (classes.argmax(axis=1) == 0))
+            for index in candidates:
+                values = logits[index]
+                weights = np.exp(values - values.max(axis=1, keepdims=True))
+                distances = (weights / weights.sum(axis=1, keepdims=True)) @ np.arange(8) * stride
+                cx = (index % side) * stride + (stride - 1) / 2
+                cy = (index // side) * stride + (stride - 1) / 2
+                x1 = max(0., min(1., (cx - distances[0] - left) / (scale * w)))
+                y1 = max(0., min(1., (cy - distances[1] - top) / (scale * h)))
+                x2 = max(0., min(1., (cx + distances[2] - left) / (scale * w)))
+                y2 = max(0., min(1., (cy + distances[3] - top) / (scale * h)))
+                if x2 > x1 and y2 > y1:
+                    boxes.append([float(x1), float(y1), float(x2 - x1), float(y2 - y1)])
+                    scores.append(float(classes[index, 0]))
+        indices = cv.dnn.NMSBoxes(boxes, scores, 0.6, 0.6)
+        return [{"box": [boxes[i][0], boxes[i][1], boxes[i][0]+boxes[i][2], boxes[i][1]+boxes[i][3]],
+                 "score": scores[i]} for i in np.asarray(indices).reshape(-1)]
+
+
+class LineTracker:
+    def __init__(self):
+        self.tracks = {}
+        self.next_id = 1
+
+    def update(self, people, config, now, aspect=4/3):
+        # Fehlende Frames unterbrechen die Bestätigung; kurze Lücken behalten
+        # lediglich die räumliche Identität, niemals einen alten Linienübergang.
+        old = {k: v for k, v in self.tracks.items() if now - v["seen"] <= 0.8}
+        available = set(old)
+        result, crossed = [], False
+        a, b = config["line"]
+        ax, ay, bx, by = a[0]*aspect, a[1], b[0]*aspect, b[1]
+        dx, dy = bx-ax, by-ay
+        length = math.hypot(dx, dy)
+        for person in people:
+            x1, y1, x2, y2 = person["box"]
+            point = ((x1+x2)/2, y2)
+            def distance(key):
+                p = old[key]["point"]
+                return math.hypot((point[0]-p[0])*aspect, point[1]-p[1])
+            key = min(available, key=distance) if available else None
+            if key is None or distance(key) > 0.25:
+                key = self.next_id
+                self.next_id += 1
+                track = {"count": 0, "side": None, "point": point}
+            else:
+                available.remove(key)
+                track = old[key]
+            previous = track["point"]
+            track["count"] += 1
+            px, py = point[0]*aspect, point[1]
+            signed = ((dx*(py-ay)-dy*(px-ax))/length) * config["direction"]
+            side = -1 if signed < -0.03 else (1 if signed > 0.03 else 0)
+            rx1, ry1, rx2, ry2 = config["region"]
+            inside = rx1 <= point[0] <= rx2 and ry1 <= point[1] <= ry2
+            if track["count"] >= 3 and inside:
+                if side == 1 and track["side"] == -1:
+                    # Schnitt der Bewegung mit dem endlichen Liniensegment.
+                    start = track.get("arrival", previous)
+                    sx, sy = start[0]*aspect, start[1]
+                    vx, vy = px-sx, py-sy
+                    den = vx*dy-vy*dx
+                    if abs(den) > 1e-9:
+                        t = ((ax-sx)*dy-(ay-sy)*dx)/den
+                        u = ((ax-sx)*vy-(ay-sy)*vx)/den
+                        crossed |= 0 <= t <= 1 and 0 <= u <= 1
+                if side:
+                    track["side"] = side
+                    if side == -1:
+                        track["arrival"] = point
+            elif not inside:
+                track["side"] = None
+            track.update(point=point, seen=now)
+            result.append({**person, "track_id": key, "confirmed": track["count"] >= 3})
+            old[key] = track
+        active = {p["track_id"] for p in result}
+        for key in set(old)-active:
+            old[key].update(count=0, side=None)
+        self.tracks = old
+        return result, crossed
+
+
+class DetectionService:
+    def __init__(self, camera, controller, events, directory, detector_factory=NanoDet, clock=time.monotonic):
+        self.camera, self.controller, self.events = camera, controller, events
+        self.clock, self.factory = clock, detector_factory
+        self.path = directory / "detection.json"
+        self.model_path = directory / "models" / "object_detection_nanodet_2022nov.onnx"
+        self.lock = threading.RLock()
+        self.stop_event = threading.Event()
+        self.thread = None
+        self.error = None
+        self.fault = False
+        self.config_error = None
+        self.config = json.loads(json.dumps(DEFAULT_CONFIG))
+        try:
+            if self.path.exists():
+                self.config = validate_config(json.loads(self.path.read_text()))
+        except (ValueError, TypeError, KeyError, OSError) as exc:
+            self.config_error = f"Erkennungseinstellungen beschädigt: {exc}"
+        self.revision = 0
+        self.reset_state()
+        self.last_valid = None
+        self.started = self.clock()
+        self.fps = 0.
+        self.result = {"frame_number": 0, "people": [], "image_base64": None}
+
+    def reset_state(self):
+        self.revision += 1
+        self.tracker = LineTracker()
+        self.free_since = None
+        self.armed = False
+        self.generation = self.controller.generation
+
+    def configure(self, value):
+        config = validate_config(value)
+        with self.lock:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            with tempfile.NamedTemporaryFile(mode="w", dir=self.path.parent, delete=False) as file:
+                temp = Path(file.name)
+                try:
+                    json.dump(config, file)
+                    file.flush()
+                    os.fsync(file.fileno())
+                except Exception:
+                    temp.unlink(missing_ok=True)
+                    raise
+            try:
+                os.replace(temp, self.path)
+            finally:
+                temp.unlink(missing_ok=True)
+            self.config = config
+            self.config_error = None
+            self.reset_state()
+            self.started = self.clock()
+            self.last_valid = None
+            self.result = {"frame_number": 0, "people": [], "image_base64": None}
+            return self.get_config()
+
+    def get_config(self):
+        with self.lock:
+            return json.loads(json.dumps(self.config))
+
+    def reset(self):
+        with self.lock:
+            self.fault = False
+            self.error = None
+            self.reset_state()
+            self.started = self.clock()
+            self.last_valid = None
+
+    def fail(self, message):
+        with self.lock:
+            self.error = message
+            self.armed = False
+            self.free_since = None
+            if self.config["enabled"]:
+                self.fault = True
+                self.controller.stop()
+
+    def watchdog(self):
+        with self.lock:
+            if self.config["enabled"] and not self.fault:
+                if self.camera.error:
+                    self.fail(self.camera.error)
+                elif self.clock() - (self.last_valid if self.last_valid is not None else self.started) > 2:
+                    self.fail("Keine gültige Erkennung seit mehr als zwei Sekunden; zurücksetzen")
+
+    def process(self, people, number, jpeg, captured_at, version):
+        event_mode = None
+        with self.lock:
+            now = self.clock()
+            if self.stop_event.is_set():
+                return
+            if self.controller.generation != self.generation:
+                self.reset_state()
+                return
+            if version != self.revision:
+                return
+            if now - captured_at > 2:
+                self.fail("Erkennungsbild ist veraltet; zurücksetzen")
+                return
+            self.last_valid = now
+            if not self.fault:
+                self.error = None
+            image = Image.open(BytesIO(jpeg))
+            people, crossing = self.tracker.update(people, self.config, now, image.width/image.height)
+            self.result = {"frame_number": number, "people": people,
+                           "image_base64": base64.b64encode(jpeg).decode("ascii")}
+            if not self.config["enabled"] or self.fault or self.controller.stopped:
+                self.armed = False
+                self.free_since = None
+                return
+            rx1, ry1, rx2, ry2 = self.config["region"]
+            # Auch unbestätigte Personenrahmen verhindern eine falsche Freigabe.
+            occupied = any(p["box"][0] <= rx2 and p["box"][2] >= rx1 and
+                           p["box"][1] <= ry2 and p["box"][3] >= ry1 for p in people)
+            if occupied:
+                self.free_since = None
+            else:
+                if self.free_since is None:
+                    self.free_since = now
+                if now-self.free_since >= 2 and self.controller.status()["cooldown_seconds"] == 0:
+                    self.armed = True
+            if crossing and self.armed:
+                # Controller bleibt die gemeinsame letzte Schranke, unabhängig
+                # von manueller Bereichsfreigabe oder parallelem Browser-Stopp.
+                self.controller.zone_clear()
+                accepted, _ = self.controller.trigger()
+                self.armed = False
+                self.free_since = None
+                if accepted:
+                    event_mode = self.controller.last_event["mode"]
+        # SQLite darf UI und unabhängigen Watchdog nicht blockieren.
+        if event_mode is not None:
+            try:
+                self.events.record_detection_trigger(event_mode)
+            except Exception as exc:
+                self.fail(f"Ereignis nicht gespeichert: {exc}")
+
+    def status(self):
+        with self.lock:
+            age = None if self.last_valid is None else self.clock()-self.last_valid
+            return {"enabled": self.config["enabled"], "ready": age is not None and age <= 2 and not self.error,
+                    "error": self.config_error or self.error, "reset_required": self.fault,
+                    "armed": self.armed and not self.fault and not self.controller.stopped
+                    and self.controller.generation == self.generation
+                    and self.controller.status()["cooldown_seconds"] == 0,
+                    "fps": round(self.fps, 2), "result_age_seconds": age}
+
+    def snapshot(self):
+        with self.lock:
+            status = self.status()
+            fresh = status["ready"]
+            return {**self.result, "people": self.result["people"] if fresh else [],
+                    "image_base64": self.result["image_base64"] if fresh else None,
+                    "status": status}
+
+    def start(self):
+        self.started = self.clock()
+        self.thread = threading.Thread(target=self._run, name="person-detection", daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        self.stop_event.set()
+        self.controller.stop()
+        if self.thread:
+            self.thread.join(timeout=3)
+
+    def _run(self):
+        detector, last_number, last_completed = None, 0, None
+        while not self.stop_event.is_set():
+            began = self.clock()
+            try:
+                if detector is None:
+                    detector = self.factory(self.model_path)
+                with self.lock:
+                    if self.controller.generation != self.generation:
+                        self.reset_state()
+                    version = self.revision
+                number, jpeg, captured_at = self.camera.latest_timed()
+                if jpeg is not None and number != last_number:
+                    last_number = number
+                    people = detector.detect(jpeg)
+                    self.process(people, number, jpeg, captured_at, version)
+                    completed = self.clock()
+                    with self.lock:
+                        self.fps = 0. if last_completed is None else 1/max(0.001, completed-last_completed)
+                    last_completed = completed
+            except Exception as exc:
+                self.fail(f"Personenerkennung nicht verfügbar: {exc}")
+                detector = None
+                self.stop_event.wait(1)
+            self.stop_event.wait(max(0, 0.2-(self.clock()-began)))