Rellenar la zona cuando se marca dibujando su contorno

Solo lo pintado contaba como zona: con un contorno, quien tocaba la
línea por afuera era intruso y quien estaba adentro no (se detectaba al
~14% de la gente de adentro). fill_outlines cierra huecos chicos del
trazo, rellena lo encerrado y recorta el medio trazo que sobresale hacia
afuera. Si se pintó el área entera, no cambia nada. El cierre de huecos
tiene un radio máximo (MAX_GAP_PX): sin él, un área grande tardaba ~100 s.

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

camguard/zone.py

@@ -9,6 +9,10 @@ import numpy as np
 
 NO_ZONE_MSG = "Pintá la zona restringida sobre la imagen antes de analizar."
 
+# Hueco máximo (en píxeles) que se cierra en un contorno dibujado a mano antes de rellenarlo.
+# También acota el costo: cerrar con un radio grande sobre un área pintada tarda minutos.
+MAX_GAP_PX = 60
+
 
 def zone_from_layers(layers: list[np.ndarray], shape: tuple[int, int]) -> np.ndarray:
     """Combina las capas pintadas en el editor en una sola máscara del tamaño del video.
@@ -32,7 +36,47 @@ def zone_from_layers(layers: list[np.ndarray], shape: tuple[int, int]) -> np.nda
         # INTER_NEAREST mantiene los bordes nítidos (sí/no) en vez de difuminarlos.
         size = (shape[1], shape[0])  # OpenCV pide (ancho, alto)
         mask = cv2.resize(mask.astype(np.uint8), size, interpolation=cv2.INTER_NEAREST) > 0
-    return mask
+    return fill_outlines(mask)
+
+
+def _disk(radius: int) -> np.ndarray:
+    return cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * radius + 1, 2 * radius + 1))
+
+
+def fill_outlines(mask: np.ndarray) -> np.ndarray:
+    """Si la zona se marcó dibujando su contorno, devuelve el área encerrada.
+
+    Lo natural es marcar un área dibujando su borde, pero solo lo pintado cuenta como zona:
+    con un contorno, quien tocaba la línea por afuera era "intruso" y quien estaba adentro no.
+    Medido en el video de ejemplo, con contorno se detectaba solo al ~15% de los de adentro.
+
+    Pasos:
+        1. Cierra huecos de hasta ~2 grosores de trazo, con un máximo de ``MAX_GAP_PX`` (un
+           contorno a mano rara vez cierra justo).
+        2. Rellena lo que quedó encerrado.
+        3. Recorta medio trazo hacia adentro: el trazo se dibuja centrado sobre el borde que
+           se quiso marcar, así que su mitad externa ya está afuera.
+
+    Si no hay nada encerrado (se pintó el área entera), devuelve la máscara sin cambios.
+
+    Args:
+        mask: Máscara booleana con lo pintado.
+
+    Returns:
+        Máscara booleana de la zona.
+    """
+    painted = mask.astype(np.uint8)
+    # Medio grosor del trazo: la mayor distancia de un píxel pintado al borde de lo pintado.
+    # ponytail: asume trazos de grosor parejo; un contorno junto a un área grande pintada
+    # sobreestima el grosor (si pasa, medir el grosor solo sobre los trazos finos).
+    half_stroke = max(1, int(cv2.distanceTransform(painted, cv2.DIST_L2, 5).max()))
+    closed = cv2.morphologyEx(painted, cv2.MORPH_CLOSE, _disk(min(2 * half_stroke, MAX_GAP_PX)))
+    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    filled = np.zeros_like(painted)
+    cv2.drawContours(filled, contours, -1, 1, cv2.FILLED)
+    if filled.sum() == closed.sum():  # nada encerrado: se pintó el área entera
+        return mask
+    return cv2.erode(filled, _disk(half_stroke)).astype(bool)
 
 
 def feet_in_zone(feet_xy: np.ndarray, zone: np.ndarray) -> np.ndarray:

tests/test_zone.py

@@ -1,7 +1,53 @@
+import time
+
+import cv2
 import numpy as np
 import pytest
 
-from camguard.zone import feet_in_zone, zone_from_layers
+from camguard.zone import feet_in_zone, fill_outlines, zone_from_layers
+
+
+def outline(gap=0):
+    """Máscara 200x200 con el contorno de un cuadrado (50,50)-(150,150), trazo de 10 px.
+
+    `gap` deja un hueco de ese ancho en el lado de arriba, como un trazo a mano que no cierra.
+    """
+    mask = np.zeros((200, 200), np.uint8)
+    cv2.rectangle(mask, (50, 50), (150, 150), 1, 10)
+    if gap:
+        mask[40:60, 100 : 100 + gap] = 0
+    return mask.astype(bool)
+
+
+@pytest.mark.parametrize("gap", [pytest.param(0, id="cerrado"), pytest.param(15, id="con-hueco")])
+def test_fill_outlines_fills_the_drawn_contour(gap):
+    zone = fill_outlines(outline(gap))
+    assert zone[100, 100]  # centro del cuadrado: adentro
+    assert zone[100, 53] and zone[100, 147]  # justo adentro del borde marcado
+    # justo afuera: la mitad externa del trazo no cuenta como zona
+    assert not zone[100, 46] and not zone[100, 154]
+
+
+def test_fill_outlines_keeps_a_painted_area_as_is():
+    mask = np.zeros((200, 200), bool)
+    mask[50:150, 50:150] = True
+    assert np.array_equal(fill_outlines(mask), mask)
+
+
+def test_fill_outlines_is_fast_on_a_large_painted_area():
+    # Regresión: con un área grande el "grosor de trazo" estimado es enorme y cerrar huecos con
+    # ese radio tardaba ~100 s en 1080p.
+    mask = np.zeros((1080, 1920), bool)
+    mask[594:, 960:] = True
+    start = time.perf_counter()
+    assert np.array_equal(fill_outlines(mask), mask)
+    assert time.perf_counter() - start < 2
+
+
+def test_zone_from_layers_fills_a_drawn_contour():
+    layer = np.zeros((200, 200, 4), np.uint8)
+    layer[outline()] = (255, 0, 0, 255)
+    assert zone_from_layers([layer], (200, 200))[100, 100]
 
 
 def make_layer(shape, painted=None):