Intel/perimeter-breach-detection

Perimeter Breach Detection

Property	Value
Category	Object Detection + Tracking + Zone Analytics (GstAnalytics)
Base Model	YOLO26 (Ultralytics, default) or DETR (Facebook, alternative)
Source Framework	PyTorch (Ultralytics, Hugging Face Transformers)
Supported Precisions	FP32, FP16, INT8 (mixed-precision)
Inference Engine	OpenVINO
Hardware	CPU, GPU, NPU
Detected Class	person (COCO class 0)

---

Overview

Perimeter Breach Detection is a Metro Analytics use case that flags people who breach a secured perimeter marked by yellow and black safety tape. It is built on YOLO26 for person detection, paired with a multi-object tracker that assigns persistent IDs across frames. The restricted region is a polygon that traces the safety tape: in the bundled sample video the yellow and black tape forms a diagonal boundary across the floor, and the default zone covers the keep-out side of that boundary. A person whose center falls inside the polygon is reported as a perimeter breach. The model is a quantized (INT8) state-of-the-art detector; smaller variants run at high FPS on edge hardware.

Typical Metro deployments include:

• Fence-Line Protection -- trigger when a person crosses a fence or barrier around depots, yards, or substations.
• Secured-Transportation Facilities -- monitor taped-off loading docks, platforms, and maintenance bays that must stay clear.
• Work-Zone Safety -- alert when a worker or bystander enters a taped hazard area near equipment or track work.
• Restricted-Area Enforcement -- raise alerts when anyone enters a standoff boundary marked with safety tape.

Available variants: yolo26n, yolo26s, yolo26m, yolo26l. Smaller variants (yolo26n, yolo26s) are recommended for high-FPS edge deployment.

Model Selection

DETR (DEtection TRansformer) is available as an alternative to YOLO26. DETR is a transformer-based, NMS-free detector trained on COCO and released under the Apache-2.0 license. The export script embeds DETR normalization, box decoding, and the class remap into the OpenVINO IR, so the DETR model produces the same output layout and class ids as YOLO26. The same OpenVINO and DLStreamer samples run either model; select one with the MODEL constant at the top of each sample.

Model	Variants	Input Size	Output	License
YOLO26 (default)	yolo26n, yolo26s, yolo26m, yolo26l	640 x 640	[1, 300, 6]	AGPL-3.0
DETR	detr-resnet-50	800 x 800	[1, 100, 6]	Apache-2.0

Choose YOLO26 for maximum throughput on edge devices. Choose DETR when a permissively licensed transformer detector is preferred; it is heavier and runs at a lower frame rate.

---

Prerequisites

Target stack: Intel DLStreamer 2026.3.0 RC1 with the matching OpenVINO GenAI bundle 2026.5.0.0.dev20261030 (OpenVINO Runtime 2026.5.0.dev20261030). Use the native RC1 setup before running these samples; this is a development stack, not a stable release. See the device validation matrix for measured CPU, GPU, and NPU results.

• Python 3.11+
• Install OpenVINO (latest version)
• Install Intel DLStreamer (latest version)

Create and activate a Python virtual environment before running the scripts:

python3 -m venv .venv --system-site-packages
source .venv/bin/activate

Note: The --system-site-packages flag is required so the virtual environment can access the system-installed OpenVINO and DLStreamer Python packages.

---

Getting Started

Download and Quantize Model

Run the provided script to download, export to OpenVINO IR, and optionally quantize:

chmod +x export_and_quantize.sh
./export_and_quantize.sh

This exports the default yolo26n model in FP16 precision.

Optional: Select a Different Model, Variant, or Precision

./export_and_quantize.sh yolo26n FP32          # full-precision
./export_and_quantize.sh yolo26n INT8          # quantized
./export_and_quantize.sh yolo26s               # larger variant, default FP16
./export_and_quantize.sh detr-resnet-50        # DETR alternative, default FP16
./export_and_quantize.sh detr-resnet-50 INT8   # DETR quantized

The first argument selects the model: any YOLO26 variant (yolo26n, yolo26s, yolo26m, yolo26l) or DETR (detr-resnet-50). The second argument selects the precision (FP32, FP16, INT8); the default is FP16.

The script performs the following steps:

1. Installs dependencies (openvino, ultralytics for YOLO26 or transformers, torch for DETR, opencv-python; adds nncf for INT8).
2. Downloads the sample worker-zone video (worker-zone-detection.mp4) into the current directory.
3. Downloads the PyTorch weights and exports to OpenVINO IR.
4. (INT8 only) Quantizes the model using NNCF post-training quantization.

Output files (replace yolo26n with the selected model, for example detr-resnet-50):

• yolo26n_openvino_model/ -- FP32 or FP16 OpenVINO IR model directory.
• yolo26n_perimeter_int8.xml / yolo26n_perimeter_int8.bin -- INT8 quantized model (only when INT8 is selected).

Precision / Device Compatibility

Precision	CPU	GPU	NPU
FP32	Yes	Yes	No
FP16	Yes	Yes	Yes
INT8	Yes	Yes	Yes

Note: The INT8 calibration uses frames from the bundled sample video. For production accuracy, replace it with a representative set of frames from the target deployment site.

OpenVINO Sample

The sample below runs YOLO26 inference on the sample video and flags any person whose center falls inside the restricted zone as a breach. The zone is the RESTRICTED_ZONE polygon, which traces the yellow and black safety tape in the sample video's 1920x1080 pixel space: the tape runs as a diagonal boundary from (1577, 0) to (434, 1079), and the polygon covers the keep-out side of that line. To adapt the perimeter to a different camera, edit the RESTRICTED_ZONE points. YOLO26 is end-to-end (NMS-free), so no manual non-maximum suppression is needed. Breaching people are drawn with a red box and a BREACH label; the annotated result is written to output_openvino.mp4. Change the device string to run on CPU, GPU, or NPU.

The full sample is in openvino_sample.py; run it with python3 openvino_sample.py or copy the code below.

# SPDX-License-Identifier: MIT
# Copyright (C) Intel Corporation
#
# Perimeter Breach Detection: OpenVINO Runtime sample.
# See README.md for prerequisites and inputs. Run: python3 openvino_sample.py

import cv2
import numpy as np
import openvino as ov

PERSON_CLASS_ID = 0
CONF_THRESHOLD = 0.4
# Select the model: "yolo26n" (default) or "detr-resnet-50".
MODEL = "yolo26n"
INPUT_SIZE = 800 if MODEL.startswith("detr") else 640
INPUT_VIDEO = "worker-zone-detection.mp4"

# Restricted zone traced from the yellow-and-black safety tape in the sample
# video (1920x1080). The tape runs diagonally from (1577, 0) to (434, 1079);
# this polygon covers the keep-out side of that boundary. Edit these points to
# retrace the tape for a different camera.
RESTRICTED_ZONE = np.array([[0, 0], [1577, 0], [434, 1079], [0, 1080]], dtype=np.int32)

core = ov.Core()
model = core.read_model(f"{MODEL}_openvino_model/{MODEL}.xml")

# Change device to "GPU" or "NPU" to run on integrated GPU or NPU.
compiled = core.compile_model(model, "CPU")

cap = cv2.VideoCapture(INPUT_VIDEO)
fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
w0 = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h0 = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

zone = RESTRICTED_ZONE

writer = cv2.VideoWriter(
    "output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w0, h0)
)

sx, sy = w0 / INPUT_SIZE, h0 / INPUT_SIZE
frame_idx = 0
while True:
    ok, frame = cap.read()
    if not ok:
        break
    frame_idx += 1

    blob = cv2.resize(frame, (INPUT_SIZE, INPUT_SIZE))
    blob = cv2.cvtColor(blob, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
    blob = blob.transpose(2, 0, 1)[np.newaxis, ...]  # NCHW

    # End-to-end output: [1, N, 6] = [x1, y1, x2, y2, confidence, class_id]
    # (N = 300 for YOLO26, 100 for DETR)
    output = compiled([blob])[compiled.output(0)][0]
    mask = (output[:, 4] >= CONF_THRESHOLD) & (output[:, 5].astype(int) == PERSON_CLASS_ID)

    # Draw the translucent restricted zone first, then the person boxes on top.
    overlay = frame.copy()
    cv2.fillPoly(overlay, [zone], (0, 0, 255))
    cv2.addWeighted(overlay, 0.25, frame, 0.75, 0, frame)
    cv2.polylines(frame, [zone], True, (0, 255, 255), 2)

    breaches = 0
    for det in output[mask]:
        x1, y1 = int(det[0] * sx), int(det[1] * sy)
        x2, y2 = int(det[2] * sx), int(det[3] * sy)
        center = (int((x1 + x2) / 2), int((y1 + y2) / 2))
        inside = cv2.pointPolygonTest(zone, center, False) >= 0
        color = (0, 0, 255) if inside else (0, 255, 0)
        cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
        if inside:
            breaches += 1
            cv2.putText(
                frame, "BREACH", (x1, max(y1 - 6, 12)),
                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2,
            )

    cv2.putText(
        frame, f"Breaches: {breaches}", (10, 30),
        cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 255), 2,
    )
    if breaches:
        print(f"frame {frame_idx}: perimeter breach - {breaches} person(s) inside zone", flush=True)
    writer.write(frame)

cap.release()
writer.release()
print("Saved: output_openvino.mp4")

Device targets:

• "CPU" -- default, works on all Intel platforms.
• "GPU" -- Intel integrated or discrete GPU.
• "NPU" -- Intel NPU (different throughput profile; validate with benchmark_app -d NPU).

Expected Output

output_openvino.mp4 shows the restricted perimeter shaded in red, a green box around each person outside the zone, and a red BREACH box around anyone inside it.

DLStreamer Sample

The pipeline below runs the FP16 YOLO26 detector on the sample video via gvadetect, tracks each person with gvatrack, and uses DLStreamer's gvaanalytics element to test membership in the restricted zone. The zone is the same RESTRICTED_ZONE polygon used by the OpenVINO sample, passed to gvaanalytics as a JSON zone, so no polygon math is required in the code. gvaanalytics attaches GstAnalyticsZoneMtd to every tracked person whose center falls inside the polygon. The pipeline ends in an appsink; for each frame a callback reads the analytics metadata, shades the restricted zone, draws a green box around people outside it and a red BREACH box around anyone inside, and writes the annotated result to output_dlstreamer.mp4. A perimeter-breach event is printed the first time each tracked person enters the zone.

Notes on running this sample:

• Use the FP16 IR (yolo26n_openvino_model/yolo26n.xml or detr-resnet-50_openvino_model/detr-resnet-50.xml). The DETR IR carries the same model_info metadata as YOLO26, so gvadetect uses the same YOLO26 post-processor for both models. gvadetect selects the YOLO26 post-processor from the metadata.yaml file stored next to the model. To use the INT8 model, place it in a directory together with that file, for example mkdir int8 && cp yolo26n_perimeter_int8.* yolo26n_openvino_model/metadata.yaml int8/, and set model=int8/yolo26n_perimeter_int8.xml.

• Class names are read automatically from the model's embedded metadata.yaml by DLStreamer 2026.0+ -- no external labels-file is required.

• Export PYTHONPATH so the DLStreamer Python module is importable:

  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:-}
  

The full sample is in dlstreamer_sample.py; run it with python3 dlstreamer_sample.py or copy the code below.

# SPDX-License-Identifier: MIT
# Copyright (C) Intel Corporation
#
# Perimeter Breach Detection: DLStreamer pipeline sample.
# See README.md for prerequisites and inputs. Run: python3 dlstreamer_sample.py

import json
import sys
import gi

gi.require_version("Gst", "1.0")
gi.require_version("GstApp", "1.0")
gi.require_version("GstAnalytics", "1.0")
gi.require_version("DLStreamerMeta", "1.0")
from gi.repository import Gst, GLib, GstApp, GstAnalytics, DLStreamerMeta

Gst.init([])

# 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

# Import OpenCV after Gst.init to avoid a GStreamer re-initialization conflict.
import cv2
import numpy as np

# Select the model: "yolo26n" (default) or "detr-resnet-50".
MODEL = "yolo26n"
MODEL_PATH = f"{MODEL}_openvino_model/{MODEL}.xml"
VIDEO = "worker-zone-detection.mp4"
DEVICE = "GPU"  # change to "CPU" or "NPU" as needed

# Restricted zone traced from the yellow-and-black safety tape in the sample
# video (1920x1080), matching the OpenVINO sample. Edit these points to retrace
# the tape for a different camera.
RESTRICTED_ZONE = np.array([[0, 0], [1577, 0], [434, 1079], [0, 1080]], dtype=np.int32)
ZONE_JSON = json.dumps([{
    "id": "restricted_zone",
    "type": "polygon",
    "points": [{"x": int(x), "y": int(y)} for x, y in RESTRICTED_ZONE],
}])

pipeline = Gst.parse_launch(
    f"filesrc location={VIDEO} ! decodebin3 ! videoconvert ! "
    f"gvadetect model={MODEL_PATH} device={DEVICE} threshold=0.4 ! queue ! "
    f"gvatrack tracking-type=short-term-imageless ! queue ! "
    f"gvaanalytics name=analytics ! queue ! "
    f"videoconvert ! video/x-raw,format=BGR ! "
    f"appsink name=sink emit-signals=true max-buffers=4 drop=false sync=false"
)
pipeline.get_by_name("analytics").set_property("zones", ZONE_JSON)

writer = {"w": None}
# Track IDs that have already triggered a breach event, so each intruder is
# reported only once.
flagged = set()


def on_sample(appsink):
    sample = appsink.emit("pull-sample")
    if sample is None:
        return Gst.FlowReturn.OK
    buf = sample.get_buffer()
    caps = sample.get_caps().get_structure(0)
    w = caps.get_value("width")
    h = caps.get_value("height")
    ok_fr, fr_n, fr_d = caps.get_fraction("framerate")
    fps = (fr_n / fr_d) if (ok_fr and fr_d) else 30.0

    ok, minfo = buf.map(Gst.MapFlags.READ)
    if not ok:
        return Gst.FlowReturn.OK
    frame = np.ndarray((h, w, 3), buffer=minfo.data, dtype=np.uint8).copy()
    buf.unmap(minfo)

    now = buf.pts / Gst.SECOND if buf.pts != Gst.CLOCK_TIME_NONE else 0.0

    # Shade the restricted zone and outline the tape boundary.
    overlay = frame.copy()
    cv2.fillPoly(overlay, [RESTRICTED_ZONE], (0, 0, 255))
    cv2.addWeighted(overlay, 0.25, frame, 0.75, 0, frame)
    cv2.polylines(frame, [RESTRICTED_ZONE], True, (0, 255, 255), 2)

    breaches = 0
    rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf)
    if rmeta:
        for od in rmeta.iter_on_type(GstAnalytics.ODMtd):
            if GLib.quark_to_string(od.get_obj_type()) != "person":
                continue
            _, x, y, bw, bh, _ = od.get_location()

            # Find the tracking ID via the direct relation.
            track_id = None
            for trk in od.iter_direct_related(GstAnalytics.RelTypes.RELATE_TO, GstAnalytics.TrackingMtd):
                success, tid, *_ = trk.get_info()
                if success:
                    track_id = tid
                break

            # gvaanalytics attaches a ZoneMtd relation when the person is in the zone.
            in_zone = any(
                True for _ in od.iter_direct_related(GstAnalytics.RelTypes.RELATE_TO, DLStreamerMeta.ZoneMtd)
            )
            color = (0, 0, 255) if in_zone else (0, 255, 0)
            cv2.rectangle(frame, (int(x), int(y)), (int(x + bw), int(y + bh)), color, 3)
            label = f"id {track_id}" if track_id is not None else "person"
            if in_zone:
                breaches += 1
                cv2.putText(frame, f"BREACH {label}", (int(x), max(int(y) - 8, 14)),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
                if track_id is not None and track_id not in flagged:
                    flagged.add(track_id)
                    print(f"PERIMETER BREACH id={track_id} t={now:.1f}s "
                          f"entered restricted zone at ({int(x + bw / 2)},{int(y + bh)})", flush=True)
            else:
                cv2.putText(frame, label, (int(x), max(int(y) - 8, 14)),
                            cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)

    cv2.putText(frame, f"Breaches: {breaches}", (10, 40),
                cv2.FONT_HERSHEY_SIMPLEX, 1.1, (0, 0, 255), 3)
    if writer["w"] is None:
        writer["w"] = cv2.VideoWriter(
            "output_dlstreamer.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h)
        )
    writer["w"].write(frame)
    return Gst.FlowReturn.OK


pipeline.get_by_name("sink").connect("new-sample", on_sample)
pipeline.set_state(Gst.State.PLAYING)
pipeline.get_bus().timed_pop_filtered(Gst.CLOCK_TIME_NONE, Gst.MessageType.EOS | Gst.MessageType.ERROR)
pipeline.set_state(Gst.State.NULL)
if writer["w"] is not None:
    writer["w"].release()

Expected output:

PERIMETER BREACH id=2 t=3.8s entered restricted zone at (799,1067)
PERIMETER BREACH id=8 t=13.7s entered restricted zone at (789,1069)
...

The annotated video is saved to output_dlstreamer.mp4. It shows the restricted zone shaded in red with the tape boundary outlined, a green box around each person outside the zone, and a red BREACH box around anyone inside it -- matching the OpenVINO output.

Expected Output

Device targets:

• DEVICE = "GPU" -- default in the sample code.
• DEVICE = "CPU" -- change DEVICE = "GPU" to DEVICE = "CPU".
• DEVICE = "NPU" -- change DEVICE = "GPU" to DEVICE = "NPU" for the Intel NPU.

---

License

Licensed under the MIT License. See LICENSE for details.

References

• YOLO26 Documentation
• DETR Model Card (facebook/detr-resnet-50)
• End-to-End Object Detection with Transformers (DETR paper)
• OpenVINO YOLO26 Notebook
• OpenVINO Documentation
• NNCF Post-Training Quantization
• Intel DLStreamer