Sync loitering-detection from metro-analytics-catalog

LICENSE

@@ -1,45 +1,21 @@
-This directory contains two categories of content under different licenses.
-
-
-Scripts and Documentation
--------------------------
-
-The scripts (export_and_quantize.sh) and documentation (README.md) in this
-directory are original works by Intel Corporation, licensed under the
-MIT License.
-
-    Copyright (C) Intel Corporation
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-    THE SOFTWARE.
-
-
-YOLO26 Model
-------------
-
-The YOLO26 model weights and the Ultralytics framework are developed by
-Ultralytics and licensed under the GNU Affero General Public License v3.0
-(AGPL-3.0).
-
-    Source:  https://github.com/ultralytics/ultralytics
-    License: https://github.com/ultralytics/ultralytics/blob/main/LICENSE
-    Docs:    https://docs.ultralytics.com/models/yolo26/
-
-Users must comply with the AGPL-3.0 license terms when using, modifying,
-or distributing the YOLO26 model weights or Ultralytics software.
-For commercial licensing options, see https://www.ultralytics.com/license.
+MIT License
+
+Copyright (c) Intel Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE

README.md

@@ -1,5 +1,5 @@
 ---
-license: other
+license: mit
 license_link: LICENSE
 library_name: openvino
 pipeline_tag: object-detection
@@ -11,6 +11,8 @@ tags:
   - loitering-detection
   - zone-analytics
   - tracking
+  - gstanalytics
+  - gvaanalytics
   - edge-ai
   - metro
   - dlstreamer
@@ -24,7 +26,7 @@ language:
 
 | Property | Value |
 |---|---|
-| **Category** | Object Detection + Tracking + Zone Analytics |
+| **Category** | Object Detection + Tracking + Zone Analytics (GstAnalytics) |
 | **Source Framework** | PyTorch (Ultralytics) |
 | **Supported Precisions** | FP32, FP16, INT8 (mixed-precision) |
 | **Inference Engine** | OpenVINO |
@@ -37,7 +39,8 @@ language:
 
 Loitering Detection is a Metro Analytics use case that flags people who remain inside a configurable region of interest for longer than a dwell-time threshold.
 It is built on [YOLO26](https://docs.ultralytics.com/models/yolo26/) for person detection, paired with a multi-object tracker that assigns persistent IDs across frames.
-A polygon zone defines the area to monitor; for each tracked person whose bounding-box anchor falls inside the zone, the application accumulates dwell time and raises a loitering event when the threshold is exceeded.
+DLStreamer's `gvaanalytics` element defines the monitoring zone and automatically attaches `GstAnalyticsZoneMtd` metadata to every tracked person whose center falls inside the polygon.
+A Python probe reads this GstAnalytics metadata to accumulate per-person dwell time and raises a loitering event when the threshold is exceeded.
 
 Typical Metro deployments include:
 
@@ -117,17 +120,30 @@ Output files:
 > For production accuracy, replace it with a representative set of frames from
 > the target deployment site.
 
-### Defining the Region of Interest
+### Defining the Monitoring Zone
 
-The zone is a rectangular ROI expressed as `x_min,y_min,x_max,y_max` in the
-original input frame coordinates (not the 640x640 model input).
-DLStreamer's `gvaattachroi` element attaches the ROI to every buffer, and
-`gvadetect inference-region=1` (`roi-list`) restricts inference to that ROI
-only -- no Python polygon math required.
+The zone is a polygon defined in JSON and passed to DLStreamer's
+`gvaanalytics` element, which automatically detects when tracked objects
+are inside the zone using GstAnalytics metadata -- no Python polygon math
+required.
 A typical surveillance-zone configuration on a 1280x720 source might be:
 
+```json
+[
+  {
+    "id": "loiter_zone",
+    "type": "polygon",
+    "points": [
+      {"x": 0, "y": 200},
+      {"x": 300, "y": 200},
+      {"x": 300, "y": 400},
+      {"x": 0, "y": 400}
+    ]
+  }
+]
+```
+
 ```text
-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)
 ```
 
@@ -136,8 +152,13 @@ LOITERING_SECONDS = 5.0       # dwell threshold, in seconds (demo value)
 > increase this to 10--30 seconds depending on the site's operational
 > requirements.
 
-Per-person dwell time is measured at the bottom-center of the bounding box
-(the foot anchor), which most closely approximates the person's ground position.
+The `gvaanalytics` element attaches `GstAnalyticsZoneMtd` to each detection
+whose center falls inside the polygon.  The Python probe checks for this
+metadata to accumulate per-person dwell time.
+
+> **Note:** The zone polygon supports arbitrary shapes (not just rectangles).
+> Use `draw-zones=true` (the default) so that `gvawatermark` renders the zone
+> boundary on the output video.
 
 ### DLStreamer Sample
 
@@ -153,60 +174,89 @@ Run loitering detection:
 
 ```python
 from collections import defaultdict
-import ctypes
+import json
+import sys
 import gi
 gi.require_version("Gst", "1.0")
-from gi.repository import Gst
-from gstgva import Tensor, VideoFrame
+gi.require_version("GstAnalytics", "1.0")
+gi.require_version("DLStreamerMeta", "1.0")
+gi.require_version("DLStreamerWatermarkMeta", "1.0")
+from gi.repository import Gst, GLib, GstAnalytics, DLStreamerMeta, DLStreamerWatermarkMeta
 
-Gst.init(None)
+Gst.init([])
 
-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
+# Register DLStreamerMeta types so GstAnalytics iteration can handle them
+_ov = sys.modules["gi.overrides.GstAnalytics"]
+_ov.__mtd_types__[DLStreamerMeta.ZoneMtd.get_mtd_type()] = DLStreamerMeta.relation_meta_get_zone_mtd
+_ov.__mtd_types__[DLStreamerMeta.TripwireMtd.get_mtd_type()] = DLStreamerMeta.relation_meta_get_tripwire_mtd
 
 MODEL = "yolo26n_openvino_model/yolo26n.xml"
 VIDEO = "VIRAT_S_000101.mp4"
-ROI = "0,200,300,400"
+ZONE_JSON = json.dumps([{
+    "id": "loiter_zone",
+    "type": "polygon",
+    "points": [{"x": 0, "y": 200}, {"x": 300, "y": 200},
+               {"x": 300, "y": 400}, {"x": 0, "y": 400}]
+}])
 LOITERING_SECONDS = 5.0
 
 pipeline = Gst.parse_launch(
     f"filesrc location={VIDEO} ! decodebin3 ! videoconvert ! "
-    f"gvaattachroi roi={ROI} ! "
-    f"gvadetect inference-region=1 model={MODEL} device=GPU threshold=0.5 ! queue ! "
+    f"gvadetect model={MODEL} device=GPU threshold=0.5 ! queue ! "
     f"gvatrack tracking-type=short-term-imageless ! queue ! "
-    f"gvafpscounter ! identity name=probe ! gvawatermark ! videoconvert ! video/x-raw,format=I420 ! "
+    f"gvaanalytics name=analytics draw-zones=true ! "
+    f"gvafpscounter ! identity name=probe ! gvawatermark name=watermark ! "
+    f"videoconvert ! video/x-raw,format=I420 ! "
     f"openh264enc ! h264parse ! mp4mux ! filesink location=output_dlstreamer.mp4"
 )
 
+pipeline.get_by_name("analytics").set_property("zones", ZONE_JSON)
+pipeline.get_by_name("watermark").set_property("displ-cfg", "hide-roi=person")
+
 dwell = defaultdict(float)
 last_seen = {}
 flagged = set()
 
 def on_buffer(pad, info):
     buf = info.get_buffer()
-    frame = VideoFrame(buf, caps=pad.get_current_caps())
     now = buf.pts / Gst.SECOND if buf.pts != Gst.CLOCK_TIME_NONE else 0.0
-
-    for region in frame.regions():
-        if region.label() != "person":
+    rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf)
+    if not rmeta:
+        return Gst.PadProbeReturn.OK
+
+    # Iterate only over object-detection entries
+    for od in rmeta.iter_on_type(GstAnalytics.ODMtd):
+        label = GLib.quark_to_string(od.get_obj_type())
+        if label != "person":
             continue
-        oid = region.object_id()
-        if oid <= 0:
+
+        # Find tracking ID via direct relation
+        track_id = None
+        for trk in od.iter_direct_related(GstAnalytics.RelTypes.RELATE_TO, GstAnalytics.TrackingMtd):
+            success, tracking_id, *_ = trk.get_info()
+            if success:
+                track_id = tracking_id
+            break
+        if track_id is None:
             continue
 
-        dwell[oid] += now - last_seen.get(oid, now)
-        last_seen[oid] = now
+        # Check if gvaanalytics placed this detection inside the zone
+        in_zone = False
+        for zone in od.iter_direct_related(GstAnalytics.RelTypes.RELATE_TO, DLStreamerMeta.ZoneMtd):
+            in_zone = True
+            break
 
-        # 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 not in_zone:
+            continue
+
+        # Accumulate dwell time for persons inside the zone
+        dwell[track_id] += now - last_seen.get(track_id, now)
+        last_seen[track_id] = now
 
-        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)})")
+        if dwell[track_id] >= LOITERING_SECONDS and track_id not in flagged:
+            flagged.add(track_id)
+            _, x, y, w, h, _ = od.get_location()
+            print(f"LOITERING id={track_id} dwell={dwell[track_id]:.1f}s pos=({int(x + w/2)},{int(y + h)})")
 
     return Gst.PadProbeReturn.OK
 
@@ -224,7 +274,8 @@ LOITERING id=27 dwell=5.0s pos=(122,337)
 ...
 ```
 
-The annotated video is saved to `output.mp4`.
+The annotated video is saved to `output_dlstreamer.mp4`.
+The `gvaanalytics` element also draws the zone polygon on each frame via `gvawatermark`.
 
 #### Expected Output
 
@@ -248,6 +299,14 @@ Licensed under the MIT License. See [LICENSE](LICENSE) for details.
 - [YOLO26 Documentation](https://docs.ultralytics.com/models/yolo26/)
 - [OpenVINO YOLO26 Notebook](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/yolov26-optimization/yolov26-object-detection.ipynb)
 - [Intel DLStreamer Object Tracking](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/elements/gvatrack.html)
+- [Intel DLStreamer gvaanalytics](https://github.com/dlstreamer/dlstreamer/blob/main/src/monolithic/gst/elements/gvaanalytics/README.md)
 - [OpenVINO Documentation](https://docs.openvino.ai/)
 - [NNCF Post-Training Quantization](https://docs.openvino.ai/latest/nncf_ptq_introduction.html)
 - [COCO Dataset](https://cocodataset.org/)
+Company logo
+Browse warning
+When posting information to this site please be careful not to post personal or Intel Confidential/ Intel Top Secret information.
+
+
+
+For More Information about Generative AI Guidelines at Intel please visit https://goto/generativeaiguidelines