vehicle-entry-exit-logging

Vehicle Entry/Exit Logging

---

Overview

Vehicle Entry/Exit Logging is a Metro Analytics use case that detects vehicles, tracks them across frames with BoT-SORT, and logs directional entry and exit events when a tracked vehicle crosses a configurable virtual line. It is built on YOLO26, a state-of-the-art real-time object detector, quantized to INT8 for efficient inference on Intel hardware.

The tracking and line-crossing logic runs as a thin post-processing layer on top of the strongest vehicle detector available, keeping the solution accurate and extensible to other zone shapes.

Typical Metro deployments include:

• Parking Garage Management -- count vehicles entering and leaving a lot.
• Toll Gate Analytics -- log each vehicle that passes through a toll point.
• Depot and Fleet Monitoring -- track bus/truck entry and exit from depots.
• Traffic Flow Analysis -- measure directional flow at intersections.

Available variants: yolo26n, yolo26s, yolo26m, yolo26l, yolo26x. Smaller variants (yolo26n, yolo26s) are recommended for high-FPS edge deployment; larger variants improve recall for distant vehicles.

---

Prerequisites

• 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 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

The script performs the following steps:

1. Installs dependencies (openvino, ultralytics; adds nncf for INT8).
2. Downloads a sample test image (test.jpg) and the smart-parking sample video (smart_parking_720p_30fps.mp4).
3. Downloads the PyTorch weights and exports to OpenVINO IR.
4. (INT8 only) Quantizes the model using NNCF post-training quantization.

Output files:

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

Precision / Device Compatibility

OpenVINO Sample

The sample below runs YOLO26 inference on a video, keeps only the car class, applies simple centroid tracking with track IDs, and logs an entry or exit event -- with the wall-clock timestamp inside the video -- when a tracked car's centroid crosses a horizontal virtual line placed at 60% of the frame height. The saved output video shows only the car detection bounding boxes (no counter overlay or line). Change the device string to run on CPU, GPU, or NPU.

import cv2
import numpy as np
import openvino as ov

VEHICLE_CLASS_IDS = {2: "car"}
CONF_THRESHOLD = 0.4
INPUT_SIZE = 640
LINE_RATIO = 0.6
MAX_DIST = 80

core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")

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

cap = cv2.VideoCapture("smart_parking_720p_30fps.mp4")
fps = cap.get(cv2.CAP_PROP_FPS) or 30.0
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
line_y = int(height * LINE_RATIO)


def fmt_time(seconds: float) -> str:
    """Format elapsed video time as MM:SS.mmm."""
    minutes, secs = divmod(seconds, 60)
    return f"{int(minutes):02d}:{secs:06.3f}"


writer = cv2.VideoWriter(
    "output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height))

tracks: dict[int, tuple[int, int]] = {}
entry_time: dict[int, float] = {}
next_id = 0
entered = 0
exited = 0
frame_idx = 0

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

    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, ...]

    output = compiled([blob])[compiled.output(0)][0]
    mask = (output[:, 4] >= CONF_THRESHOLD) & np.isin(
        output[:, 5].astype(int), list(VEHICLE_CLASS_IDS.keys()))
    dets = output[mask]

    centroids = []
    for det in dets:
        cx = int(((det[0] + det[2]) / 2) * sx)
        cy = int(((det[1] + det[3]) / 2) * sy)
        centroids.append((cx, cy))

    new_tracks: dict[int, tuple[int, int]] = {}
    used = set()
    for tid, (px, py) in tracks.items():
        best_d = MAX_DIST
        best_j = -1
        for j, (cx, cy) in enumerate(centroids):
            if j in used:
                continue
            d = abs(cx - px) + abs(cy - py)
            if d < best_d:
                best_d = d
                best_j = j
        if best_j >= 0:
            cx, cy = centroids[best_j]
            used.add(best_j)
            t = frame_idx / fps
            if py < line_y <= cy:
                exited += 1
                enter_t = entry_time.pop(tid, None)
                if enter_t is not None:
                    print(
                        f"EXIT  track={tid:<3} entry={fmt_time(enter_t)} "
                        f"exit={fmt_time(t)}", flush=True)
                else:
                    print(f"EXIT  track={tid:<3} exit={fmt_time(t)}", flush=True)
            elif py >= line_y > cy:
                entered += 1
                entry_time[tid] = t
                print(f"ENTRY track={tid:<3} entry={fmt_time(t)}", flush=True)
            new_tracks[tid] = (cx, cy)
    for j, (cx, cy) in enumerate(centroids):
        if j not in used:
            new_tracks[next_id] = (cx, cy)
            next_id += 1
    tracks = new_tracks

    for det in dets:
        x1 = int(det[0] * sx)
        y1 = int(det[1] * sy)
        x2 = int(det[2] * sx)
        y2 = int(det[3] * sy)
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(frame, "car", (x1, max(y1 - 6, 0)),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
    writer.write(frame)

cap.release()
writer.release()
print(f"Total: entered={entered} exited={exited}", flush=True)

Device targets:

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

Expected Output

Each line prints the track ID with the entry timestamp, and on exit the paired entry and exit timestamps (MM:SS.mmm within the video):

ENTRY track=3   entry=00:02.400
ENTRY track=7   entry=00:05.133
EXIT  track=3   entry=00:02.400 exit=00:09.867
ENTRY track=12  entry=00:11.267
EXIT  track=7   entry=00:05.133 exit=00:14.700
EXIT  track=12  entry=00:11.267 exit=00:18.933
Total: entered=3 exited=3

DLStreamer Sample

The pipeline below runs the FP16 YOLO26 detector with gvatrack (BoT-SORT) for stable vehicle IDs, keeping only the car class. A buffer probe reads the tracking metadata and fires entry/exit events -- logging the entry and exit timestamps taken from each buffer's presentation time -- when a tracked car crosses the virtual line. The annotated result is saved to output_dlstreamer.mp4.

Notes on running this sample:

• Use the FP16 IR (yolo26n_openvino_model/yolo26n.xml). Class names are read automatically from the model's embedded metadata.yaml by DLStreamer 2026.0+ -- no external labels-file is required.

• Detections are read with the gstgva VideoFrame API (region.object_id() carries the gvatrack ID).

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

import gi

gi.require_version("Gst", "1.0")
from gi.repository import Gst
from gstgva import VideoFrame

Gst.init([])

INPUT_VIDEO = "smart_parking_720p_30fps.mp4"
VEHICLE_LABELS = {"car"}
LINE_RATIO = 0.6

# For CPU: change device=GPU to device=CPU.
# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
pipeline_str = (
    f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
    "videoconvert ! "
    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
    "device=GPU "
    "threshold=0.4 ! queue ! "
    "gvatrack tracking-type=short-term-imageless ! queue ! "
    "identity name=probe ! "
    "gvawatermark displ-cfg=show-roi=car ! "
    "videoconvert ! video/x-raw,format=I420 ! "
    "openh264enc ! h264parse ! "
    "mp4mux ! filesink location=output_dlstreamer.mp4"
)
pipeline = Gst.parse_launch(pipeline_str)

prev_positions: dict[int, int] = {}
entry_time: dict[int, float] = {}
entered = 0
exited = 0
frame_height = 0


def fmt_time(seconds: float) -> str:
    """Format elapsed video time as MM:SS.mmm."""
    minutes, secs = divmod(seconds, 60)
    return f"{int(minutes):02d}:{secs:06.3f}"


def on_buffer(pad, info):
    global entered, exited, frame_height
    buf = info.get_buffer()
    caps = pad.get_current_caps()
    if caps and frame_height == 0:
        frame_height = caps.get_structure(0).get_value("height") or 720
    line_y = int(frame_height * LINE_RATIO)

    t = buf.pts / Gst.SECOND if buf.pts != Gst.CLOCK_TIME_NONE else 0.0
    frame = VideoFrame(buf, caps=caps)
    current: dict[int, int] = {}
    for region in frame.regions():
        if region.label() not in VEHICLE_LABELS:
            continue
        rect = region.rect()
        cy = int(rect.y + rect.h / 2)
        tid = region.object_id()
        current[tid] = cy
        if tid in prev_positions:
            py = prev_positions[tid]
            if py < line_y <= cy:
                exited += 1
                enter_t = entry_time.pop(tid, None)
                if enter_t is not None:
                    print(
                        f"EXIT  track={tid:<3} entry={fmt_time(enter_t)} "
                        f"exit={fmt_time(t)}", flush=True)
                else:
                    print(f"EXIT  track={tid:<3} exit={fmt_time(t)}", flush=True)
            elif py >= line_y > cy:
                entered += 1
                entry_time[tid] = t
                print(f"ENTRY track={tid:<3} entry={fmt_time(t)}", flush=True)
    prev_positions.clear()
    prev_positions.update(current)
    return Gst.PadProbeReturn.OK


probe = pipeline.get_by_name("probe")
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.set_state(Gst.State.NULL)
print(f"Total: entered={entered} exited={exited}", flush=True)

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; use batch-size=1 and nireq=4 for best NPU utilization.

Expected Output

The terminal logs each vehicle's entry timestamp and, on exit, the paired entry and exit timestamps (MM:SS.mmm within the video):

ENTRY track=1   entry=00:01.900
ENTRY track=4   entry=00:04.633
EXIT  track=1   entry=00:01.900 exit=00:08.767
ENTRY track=9   entry=00:10.500
EXIT  track=4   entry=00:04.633 exit=00:13.400
EXIT  track=9   entry=00:10.500 exit=00:17.833
Total: entered=3 exited=3

---

License

Licensed under the MIT License. See LICENSE for details.

References

• YOLO26 Documentation
• Intel DLStreamer gvatrack
• BoT-SORT: Robust Multi-Object Tracking
• OpenVINO Documentation
• Intel DLStreamer