Decidir quién es intruso por el centro del cuerpo, no por los pies

Con la cámara en ángulo, la regla de los pies marcaba como intruso a
quien tenía el cuerpo afuera y apenas pisaba el borde, y no marcaba a
quien tenía el cuerpo sobre la zona pero los pies un poco afuera (7 de
~30 errores en cuadros del ejemplo). El centro del recuadro coincide con
lo que ve quien mira el video.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

camguard/__init__.py

@@ -4,7 +4,7 @@ Todo corre local, en CPU: el video nunca sale de la máquina.
 
 Módulos:
     config: perillas ajustables (fps analizados, tope de duración, confianza).
-    zone: de lo que pinta el usuario a una máscara, y quién la pisa.
+    zone: de lo que pinta el usuario a una máscara, y quién está sobre ella.
     events: de cuadros sueltos a eventos de entrada y salida.
     video: lectura submuestreada y escritura H.264.
     detection: detección (RF-DETR) y seguimiento (ByteTrack) de personas.

camguard/annotate.py

@@ -15,7 +15,7 @@ def annotate(
     Args:
         frame_bgr: Cuadro original en BGR. No se modifica.
         detections: Personas detectadas, con ``tracker_id``.
-        inside: Array booleano: True para las personas con los pies en la zona.
+        inside: Array booleano: True para las personas que están sobre la zona.
         zone: Máscara booleana de la zona.
 
     Returns:

camguard/events.py

@@ -36,7 +36,7 @@ def build_events(
 
     Args:
         frames_in_zone: Para cada persona, los índices (crecientes) de los cuadros analizados
-            en que tuvo los pies en la zona.
+            en que estuvo sobre la zona.
         fps: Cuadros analizados por segundo, para pasar de índices a segundos.
         max_gap_s: Tolerancia en segundos antes de considerar que la persona salió.
 

camguard/pipeline.py

@@ -19,7 +19,7 @@ from camguard.config import FPS, MAX_SECONDS
 from camguard.detection import PersonTracker
 from camguard.events import Event, build_events
 from camguard.video import H264Writer, frame_limit, probe, sample_frames, sampling_step
-from camguard.zone import feet_in_zone, zone_from_layers
+from camguard.zone import points_in_zone, zone_from_layers
 
 
 class Tracker(Protocol):
@@ -100,8 +100,9 @@ def analyze(
     with H264Writer(out_path, fps, info.width, info.height) as writer:
         for i, frame in enumerate(sample_frames(video_path, step, max_frames)):
             detections = tracker.update(frame)
-            feet = detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
-            inside = feet_in_zone(feet, zone)
+            # Intruso = el centro de su cuerpo está sobre la zona (ver points_in_zone).
+            centers = detections.get_anchors_coordinates(sv.Position.CENTER)
+            inside = points_in_zone(centers, zone)
             annotated = annotate(frame, detections, inside, zone)
             for track_id in detections.tracker_id[inside].tolist():
                 if track_id not in frames_in_zone:

camguard/zone.py

@@ -1,4 +1,4 @@
-"""Zona restringida: de lo que pinta el usuario a una máscara, y quién la pisa.
+"""Zona restringida: de lo que pinta el usuario a una máscara, y quién está sobre ella.
 
 La zona es una máscara booleana del tamaño del video (True = restringido) en vez de un
 polígono, porque el usuario la pinta a mano: puede tener cualquier forma o ser varias zonas.
@@ -79,22 +79,23 @@ def fill_outlines(mask: np.ndarray) -> np.ndarray:
     return cv2.erode(filled, _disk(half_stroke)).astype(bool)
 
 
-def feet_in_zone(feet_xy: np.ndarray, zone: np.ndarray) -> np.ndarray:
-    """Indica qué personas tienen los pies dentro de la zona.
+def points_in_zone(points_xy: np.ndarray, zone: np.ndarray) -> np.ndarray:
+    """Indica qué puntos caen dentro de la zona.
 
-    Se usan los pies (centro del borde inferior del recuadro) y no el recuadro entero porque,
-    con la cámara en perspectiva, alguien que pasa delante de una puerta la tapa con el cuerpo
-    sin estar en ella: los pies dicen dónde está parado de verdad.
+    El pipeline pasa el centro del recuadro de cada persona: es lo que usa el ojo para decir
+    si alguien "está" sobre la zona en la imagen. Primero se usaron los pies, más fieles a
+    dónde pisa, pero con la cámara en ángulo marcaban como intruso a quien tenía el cuerpo
+    afuera y apenas pisaba el borde, y al revés (7 de ~30 errores en cuadros del ejemplo).
 
     Args:
-        feet_xy: Array (N, 2) con las coordenadas (x, y) de los pies de cada persona.
+        points_xy: Array (N, 2) con coordenadas (x, y), una por persona.
         zone: Máscara booleana (alto, ancho).
 
     Returns:
-        Array booleano (N,): True si los pies de esa persona caen en la zona.
+        Array booleano (N,): True si ese punto cae en la zona.
     """
     h, w = zone.shape
     # clip: un punto justo en el borde (x == ancho) se saldría del array al indexar.
-    x = np.clip(feet_xy[:, 0].astype(int), 0, w - 1)
-    y = np.clip(feet_xy[:, 1].astype(int), 0, h - 1)
+    x = np.clip(points_xy[:, 0].astype(int), 0, w - 1)
+    y = np.clip(points_xy[:, 1].astype(int), 0, h - 1)
     return zone[y, x]

tests/test_pipeline.py

@@ -17,7 +17,7 @@ class FakeTracker:
         self.frame = 0
 
     def update(self, frame_bgr):
-        x = 75 if 2 <= self.frame <= 5 else 25  # pies en (x, 75)
+        x = 75 if 2 <= self.frame <= 5 else 25  # centro del cuerpo en (x, 65)
         self.frame += 1
         # Como el tracker real: solo personas (class_id = PERSON_ID) y con número de seguimiento.
         return sv.Detections(
@@ -56,6 +56,26 @@ def test_analyze_detects_the_intrusion(video, zone_layers):
     assert progress[-1] == 1.0
 
 
+class StraddlingTracker:
+    """Una persona parada sobre el borde de arriba: pies apenas adentro, cuerpo afuera."""
+
+    def __init__(self, fps):
+        pass
+
+    def update(self, frame_bgr):
+        return sv.Detections(
+            xyxy=np.array([[65.0, 20.0, 85.0, 55.0]]),  # centro en y=37 (afuera); pies en y=55
+            class_id=np.array([PERSON_ID]),
+            tracker_id=np.array([1]),
+        )
+
+
+def test_person_counts_by_body_center_not_feet(video, zone_layers):
+    # En la imagen se la ve afuera de la zona, que es lo que importa a quien mira el video.
+    result = analyze(video, zone_layers, make_tracker=StraddlingTracker)
+    assert result.events == []
+
+
 def test_analyze_respects_max_seconds(video, zone_layers, monkeypatch):
     monkeypatch.setattr("camguard.pipeline.MAX_SECONDS", 1)
     result = analyze(video, zone_layers, make_tracker=FakeTracker)

tests/test_zone.py

@@ -4,7 +4,7 @@ import cv2
 import numpy as np
 import pytest
 
-from camguard.zone import feet_in_zone, fill_outlines, zone_from_layers
+from camguard.zone import fill_outlines, points_in_zone, zone_from_layers
 
 
 def outline(gap=0):
@@ -67,7 +67,7 @@ def zone():
 
 
 @pytest.mark.parametrize(
-    ("feet", "expected"),
+    ("point", "expected"),
     [
         pytest.param((7, 7), True, id="adentro"),
         pytest.param((2, 2), False, id="afuera"),
@@ -77,12 +77,12 @@ def zone():
         pytest.param((50, 50), True, id="fuera-de-la-imagen-se-lleva-al-borde"),
     ],
 )
-def test_feet_in_zone(zone, feet, expected):
-    assert feet_in_zone(np.array([feet]), zone).tolist() == [expected]
+def test_points_in_zone(zone, point, expected):
+    assert points_in_zone(np.array([point]), zone).tolist() == [expected]
 
 
-def test_feet_in_zone_without_people(zone):
-    assert feet_in_zone(np.empty((0, 2)), zone).tolist() == []
+def test_points_in_zone_without_people(zone):
+    assert points_in_zone(np.empty((0, 2)), zone).tolist() == []
 
 
 def test_zone_from_layers_combines_all_layers():