Sync loitering-detection from metro-analytics-catalog

README.md

@@ -127,7 +127,7 @@ only -- no Python polygon math required.
 A typical surveillance-zone configuration on a 1280x720 source might be:
 
 ```text
-roi=400,200,1100,650          # ROI for gvaattachroi (x_min,y_min,x_max,y_max)
+roi=0,200,300,400          # ROI for gvaattachroi (x_min,y_min,x_max,y_max)
 LOITERING_SECONDS = 5.0       # dwell threshold, in seconds (demo value)
 ```
 
@@ -141,141 +141,90 @@ Per-person dwell time is measured at the bottom-center of the bounding box
 
 ### DLStreamer Sample
 
-- The DLStreamer Python module is not on `sys.path` by default. Export `PYTHONPATH` before running:
+Set up the environment:
 
 ```bash
 source /opt/intel/openvino_2026/setupvars.sh
 source /opt/intel/dlstreamer/scripts/setup_dls_env.sh
-export PYTHONPATH=/opt/intel/dlstreamer/python:\
-/opt/intel/dlstreamer/gstreamer/lib/python3/dist-packages:${PYTHONPATH:-}
+export PYTHONPATH=/opt/intel/dlstreamer/python:/opt/intel/dlstreamer/gstreamer/lib/python3/dist-packages:${PYTHONPATH:-}
 ```
 
-**Video-based loitering detection** (requires video for dwell-time tracking):
+Run loitering detection:
 
 ```python
 from collections import defaultdict
-
+import ctypes
 import gi
-
 gi.require_version("Gst", "1.0")
-gi.require_version("GstVideo", "1.0")
 from gi.repository import Gst
-from gstgva import VideoFrame
+from gstgva import Tensor, VideoFrame
 
 Gst.init(None)
 
-MODEL_XML = "yolo26n_openvino_model/yolo26n.xml"
-INPUT_VIDEO = "VIRAT_S_000101.mp4"
-ROI = "0,200,300,400"  # x_min,y_min,x_max,y_max
+libgst = ctypes.CDLL("libgstreamer-1.0.so.0")
+libgst.gst_structure_new_empty.argtypes = [ctypes.c_char_p]
+libgst.gst_structure_new_empty.restype = ctypes.c_void_p
+
+MODEL = "yolo26n_openvino_model/yolo26n.xml"
+VIDEO = "VIRAT_S_000101.mp4"
+ROI = "0,200,300,400"
 LOITERING_SECONDS = 5.0
 
-pipeline_str = (
-    f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
-    f"videoconvert ! "
+pipeline = Gst.parse_launch(
+    f"filesrc location={VIDEO} ! decodebin3 ! videoconvert ! "
     f"gvaattachroi roi={ROI} ! "
-    f"gvadetect inference-region=1 model={MODEL_XML} device=GPU "
-    f"threshold=0.5 ! queue ! "
+    f"gvadetect inference-region=1 model={MODEL} device=GPU threshold=0.5 ! queue ! "
     f"gvatrack tracking-type=short-term-imageless ! queue ! "
-    f"gvametaconvert add-empty-results=true ! queue ! "
-    f"gvafpscounter ! "
-    f"gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
-    f"openh264enc ! h264parse ! "
-    f"mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
+    f"gvafpscounter ! identity name=probe ! gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
+    f"openh264enc ! h264parse ! mp4mux ! filesink location=output_dlstreamer.mp4"
 )
-pipeline = Gst.parse_launch(pipeline_str)
-
-STALE_TIMEOUT = 2.0  # seconds of absence before clearing dwell state
-dwell_state: dict[int, float] = defaultdict(float)
-last_seen: dict[int, float] = {}
-flagged: set[int] = set()
 
+dwell = defaultdict(float)
+last_seen = {}
+flagged = set()
 
 def on_buffer(pad, info):
     buf = info.get_buffer()
-    caps = pad.get_current_caps()
-    frame = VideoFrame(buf, caps=caps)
-
+    frame = VideoFrame(buf, caps=pad.get_current_caps())
     now = buf.pts / Gst.SECOND if buf.pts != Gst.CLOCK_TIME_NONE else 0.0
-    seen_ids: set[int] = set()
 
     for region in frame.regions():
-        # gvaattachroi attaches a frame-level ROI region; skip it.
         if region.label() != "person":
             continue
-        object_id = region.object_id()
-        if object_id <= 0:
+        oid = region.object_id()
+        if oid <= 0:
             continue
 
-        rect = region.rect()
-        foot_x = int(rect.x + rect.w / 2)
-        foot_y = int(rect.y + rect.h)
-        seen_ids.add(object_id)
-
-        # gvadetect inference-region=1 already constrains detections to the
-        # gvaattachroi zone, so every tracked person here is "in zone".
-        prev = last_seen.get(object_id, now)
-        dwell_state[object_id] += now - prev
-        last_seen[object_id] = now
-
-        if (
-            dwell_state[object_id] >= LOITERING_SECONDS
-            and object_id not in flagged
-        ):
-            flagged.add(object_id)
-            print(
-                f"LOITERING id={object_id} "
-                f"dwell={dwell_state[object_id]:.1f}s "
-                f"anchor=({foot_x},{foot_y})",
-                flush=True,
-            )
-
-    # Clean up stale tracks after STALE_TIMEOUT seconds of absence.
-    # Keep flagged entries to prevent duplicate alerts when a person
-    # briefly disappears (occlusion / tracker jitter) and reappears.
-    for stale in list(dwell_state):
-        if stale not in seen_ids:
-            elapsed_since = now - last_seen.get(stale, now)
-            if elapsed_since > STALE_TIMEOUT:
-                dwell_state.pop(stale, None)
-                last_seen.pop(stale, None)
+        dwell[oid] += now - last_seen.get(oid, now)
+        last_seen[oid] = now
 
-    return Gst.PadProbeReturn.OK
+        # Show dwell time on the bounding box (rendered by gvawatermark)
+        t = Tensor(libgst.gst_structure_new_empty(b"dwell"))
+        t.set_label(f" {dwell[oid]:.1f}s")
+        region.add_tensor(t)
 
+        if dwell[oid] >= LOITERING_SECONDS and oid not in flagged:
+            flagged.add(oid)
+            rect = region.rect()
+            print(f"LOITERING id={oid} dwell={dwell[oid]:.1f}s pos=({int(rect.x + rect.w/2)},{int(rect.y + rect.h)})")
 
-sink = pipeline.get_by_name("sink")
-sink_pad = sink.get_static_pad("sink")
-sink_pad.add_probe(Gst.PadProbeType.BUFFER, on_buffer)
+    return Gst.PadProbeReturn.OK
 
+pipeline.get_by_name("probe").get_static_pad("src").add_probe(Gst.PadProbeType.BUFFER, on_buffer)
 pipeline.set_state(Gst.State.PLAYING)
-bus = pipeline.get_bus()
-bus.timed_pop_filtered(
-    Gst.CLOCK_TIME_NONE,
-    Gst.MessageType.EOS | Gst.MessageType.ERROR,
-)
+pipeline.get_bus().timed_pop_filtered(Gst.CLOCK_TIME_NONE, Gst.MessageType.EOS | Gst.MessageType.ERROR)
 pipeline.set_state(Gst.State.NULL)
 ```
 
-Expected output with the sample video and the zone/threshold above
-(exact track IDs and anchor coordinates may vary between runs due to
-tracker non-determinism):
+Expected output:
 
 ```text
-LOITERING id=26 dwell=5.0s anchor=(147,341)
-LOITERING id=27 dwell=5.0s anchor=(122,337)
-LOITERING id=29 dwell=5.0s anchor=(90,322)
+LOITERING id=26 dwell=5.0s pos=(147,341)
+LOITERING id=27 dwell=5.0s pos=(122,337)
 ...
 ```
 
-Approximately 10–12 loitering events are expected over the full video.
-
-The annotated video is saved to `output_dlstreamer.mp4` with green bounding boxes and
-track IDs drawn by `gvawatermark` around every detected person.
-
-> **Known warning:** The `openh264enc` element prints
-> `[OpenH264] this = 0x..., Error:CWelsH264SVCEncoder::EncodeFrame(), cmInitParaError.`
-> on the first frame. This is a benign initialization message — the output
-> video is encoded correctly. The warning comes from the OpenH264 library's
-> internal logging and does not indicate a real error.
+The annotated video is saved to `output.mp4`.
 
 #### Expected Output