README.md · Intel/object-classification at main

Sync object-classification from metro-analytics-catalog

ae0ee67 verified 3 months ago

13.6 kB

---
license: mit
license_link: LICENSE
library_name: openvino
pipeline_tag: object-detection
tags:
  - openvino
  - intel
  - yolo
  - yolo26
  - object-classification
  - classification
  - smart-city
  - situational-awareness
  - traffic
  - edge-ai
  - metro
  - dlstreamer
language:
  - en
---
# Object Classification

| Property | Value |
|---|---|
| **Category** | Object Classification (Traffic Categorization: People / Vehicles) |
| **Base Model** | [YOLO26](https://docs.ultralytics.com/models/yolo26/) (Ultralytics) |
| **Source Framework** | PyTorch (Ultralytics) |
| **Supported Precisions** | FP32, FP16, INT8 (mixed-precision) |
| **Inference Engine** | OpenVINO |
| **Hardware** | CPU, GPU, NPU |
| **Detected Class(es)** | `person` and vehicle classes grouped into `People` and `Vehicles` |

---

## Overview

Object Classification is a Metro Analytics use case that detects objects with [YOLO26](https://docs.ultralytics.com/models/yolo26/) and then categorizes each detection into higher-level city-operations groups.
It is built on the state-of-the-art YOLO26 real-time detector, quantized to INT8 for efficient inference on Intel hardware.
Where the general object-detection use case reports every one of the 80 COCO classes individually, this use case rolls the traffic-relevant classes up into two semantic categories, `People` and `Vehicles`, so operators get an at-a-glance picture of a scene.

The traffic categories are:

- **People** -- the COCO `person` class.
- **Vehicles** -- the COCO `bicycle`, `car`, `motorcycle`, `bus`, `train`, and `truck` classes.

Objects outside these categories are ignored to keep the output focused on traffic situational awareness.

Typical Metro deployments include:

- **Situational Awareness** -- summarize each camera feed as live People and Vehicles counts.
- **Automated City Operations** -- feed category counts into signal timing, congestion, and dispatch logic.
- **Intersection and Roundabout Monitoring** -- track the mix of pedestrians and vehicles at busy junctions.
- **Trend Analytics** -- aggregate category counts over time to understand traffic patterns.

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

---

## Prerequisites

- Python 3.11+
- [Install OpenVINO](https://docs.openvino.ai/2026/get-started/install-openvino.html) (latest version)
- [Install Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/get_started/install/install_guide_ubuntu.html) (latest version)

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

```bash
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:

```bash
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

```bash
./export_and_quantize.sh yolo26n FP32   # full-precision
./export_and_quantize.sh yolo26n INT8   # quantized
./export_and_quantize.sh yolo26s        # larger variant, default FP16
```

Replace `yolo26n` with any variant (`yolo26s`, `yolo26m`, `yolo26l`, `yolo26x`).
The second argument selects the precision (`FP32`, `FP16`, `INT8`); the default is **FP16**.

The script performs the following steps:

1. Installs dependencies (`openvino`, `ultralytics`; adds `nncf` for INT8).
2. Downloads a sample traffic video (`test_video.mp4`) of an urban roundabout at low resolution (640x360).
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_objcls_int8.xml` / `yolo26n_objcls_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 a frame 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 traffic video, maps each
detection into the `People` or `Vehicles` category, draws boxes colored per
category, overlays live category counts, and writes the annotated result to
`output_openvino.mp4`.
YOLO26 is end-to-end (NMS-free), so no manual non-maximum suppression is needed.
Change the `device` string to run on CPU, GPU, or NPU.

```python
import cv2
import numpy as np
import openvino as ov
CONF_THRESHOLD = 0.4
INPUT_SIZE = 640
# Map the traffic-relevant COCO class ids into higher-level city categories.
# People and Vehicles are the two categories tracked for situational awareness.
CATEGORY_BY_CLASS_ID = {
    0: "People",      # person
    1: "Vehicles",    # bicycle
    2: "Vehicles",    # car
    3: "Vehicles",    # motorcycle
    5: "Vehicles",    # bus
    6: "Vehicles",    # train
    7: "Vehicles",    # truck
}
# BGR overlay colors for each category.
CATEGORY_COLORS = {
    "People": (0, 200, 0),
    "Vehicles": (255, 128, 0),
}
core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
# YOLO26 embeds the 80 COCO class names in rt_info. Ultralytics separates
# multi-word names with underscores (e.g. "traffic_light"), so restore spaces.
COCO_NAMES = [
    name.replace("_", " ")
    for name in model.get_rt_info()["model_info"]["labels"].value.split()
]
# Change device to "GPU" or "NPU" to run on integrated GPU or NPU.
compiled = core.compile_model(model, "CPU")
output_port = compiled.output(0)
cap = cv2.VideoCapture("test_video.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))
writer = cv2.VideoWriter(
    "output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)
)
totals = {"People": 0, "Vehicles": 0}
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
    # YOLO26 end-to-end output: [1, 300, 6] = [x1, y1, x2, y2, confidence, class_id].
    output = compiled([blob])[output_port][0]
    sx, sy = width / INPUT_SIZE, height / INPUT_SIZE
    counts = {"People": 0, "Vehicles": 0}
    for x1, y1, x2, y2, conf, class_id in output:
        if conf < CONF_THRESHOLD:
            continue
        category = CATEGORY_BY_CLASS_ID.get(int(class_id))
        if category is None:
            continue  # not a traffic-relevant object
        counts[category] += 1
        totals[category] += 1
        color = CATEGORY_COLORS[category]
        px1, py1 = int(x1 * sx), int(y1 * sy)
        px2, py2 = int(x2 * sx), int(y2 * sy)
        label = f"{category}: {COCO_NAMES[int(class_id)]} {conf:.2f}"
        cv2.rectangle(frame, (px1, py1), (px2, py2), color, 2)
        cv2.putText(frame, label, (px1, py1 - 5),
                    cv2.FONT_HERSHEY_SIMPLEX, 2.0, color, 2)
    # Overlay the per-category counts for this frame.
    banner = f"People: {counts['People']}  Vehicles: {counts['Vehicles']}"
    cv2.rectangle(frame, (0, 0), (width, 60), (0, 0, 0), -1)
    cv2.putText(frame, banner, (15, 45),
                cv2.FONT_HERSHEY_SIMPLEX, 2.0, (255, 255, 255), 2)
    if frame_idx % 30 == 0:
        print(f"frame {frame_idx}: {banner}", flush=True)
    writer.write(frame)
cap.release()
writer.release()
print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
print("Saved: output_openvino.mp4")
```

**Device targets:**

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

### Try It on a Sample Video

The `export_and_quantize.sh` script downloads `test_video.mp4` automatically.
Re-run the OpenVINO sample above.
The script reads `test_video.mp4`, prints the running People and Vehicles counts to the console, and writes the annotated video to `output_openvino.mp4`.

Expected console output (representative):

```text
frame 30: People: 4  Vehicles: 6
frame 60: People: 3  Vehicles: 7
frame 90: People: 5  Vehicles: 5
Summary: People=372 Vehicles=548
Saved: output_openvino.mp4
```

#### Expected Output

![OpenVINO expected output](expected_output_openvino.gif)

### DLStreamer Sample

The pipeline below runs the FP16 YOLO26 detector on the sample video via
`gvadetect`, overlays bounding boxes with `gvawatermark` for the traffic-relevant
classes only (non-traffic detections such as `handbag` are filtered out via
`show-roi`), saves the annotated result to `output_dlstreamer.mp4`, and prints the
`People` and `Vehicles` category counts per frame from the detection metadata.

> **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.
> - Export `PYTHONPATH` so the DLStreamer Python module is importable:
>
>   ```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:-}
>   ```
```python
import gi
gi.require_version("Gst", "1.0")
gi.require_version("GstAnalytics", "1.0")
from gi.repository import Gst, GLib, GstAnalytics
Gst.init([])
INPUT_VIDEO = "test_video.mp4"
# Traffic-relevant COCO labels grouped into higher-level city categories.
CATEGORY_BY_LABEL = {
    "person": "People",
    "bicycle": "Vehicles",
    "car": "Vehicles",
    "motorcycle": "Vehicles",
    "bus": "Vehicles",
    "train": "Vehicles",
    "truck": "Vehicles",
}
# For CPU: change device=GPU to device=CPU.
# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
# gvawatermark displ-cfg:
#   show-roi=... draws only the traffic-relevant classes (person + vehicles),
#     so non-traffic detections such as handbag/backpack are not boxed.
#   font-scale=1.5 enlarges the label text for better visualization.
pipeline_str = (
    f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
    "videoconvert ! "
    "gvadetect model=yolo26n_openvino_model/yolo26n.xml "
    "device=GPU "
    "threshold=0.4 ! queue ! "
    "gvawatermark "
    "displ-cfg=show-roi=person:bicycle:car:motorcycle:bus:train:truck,font-scale=2.5 ! "
    "videoconvert ! video/x-raw,format=I420 ! "
    "openh264enc ! h264parse ! "
    "mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
)
pipeline = Gst.parse_launch(pipeline_str)
totals = {"People": 0, "Vehicles": 0}


def on_buffer(pad, info):
    buf = info.get_buffer()
    rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf)
    if rmeta is None:
        return Gst.PadProbeReturn.OK
    counts = {"People": 0, "Vehicles": 0}
    idx = 1
    while True:
        ok, od = rmeta.get_od_mtd(idx)
        if not ok:
            break
        label = GLib.quark_to_string(od.get_obj_type())
        category = CATEGORY_BY_LABEL.get(label)
        if category is not None:
            counts[category] += 1
            totals[category] += 1
        idx += 1
    if counts["People"] or counts["Vehicles"]:
        print(f"frame: People={counts['People']} Vehicles={counts['Vehicles']}",
              flush=True)
    return Gst.PadProbeReturn.OK

sink = pipeline.get_by_name("sink")
sink_pad = sink.get_static_pad("sink")
sink_pad.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"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
```
#### Expected Output

![DLStreamer expected output](expected_output_dlstreamer.gif)

**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.

---

## License

Licensed under the MIT License. See [LICENSE](LICENSE) for details.

## References

- [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)
- [Sample video: Urban roundabout with cars and pedestrian (Pexels)](https://www.pexels.com/video/urban-roundabout-with-cars-and-pedestrian-30119018/)
- [OpenVINO Documentation](https://docs.openvino.ai/)
- [NNCF Post-Training Quantization](https://docs.openvino.ai/latest/nncf_ptq_introduction.html)
- [Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/index.html)

	---
	license: mit
	license_link: LICENSE
	library_name: openvino
	pipeline_tag: object-detection
	tags:
	- openvino
	- intel
	- yolo
	- yolo26
	- object-classification
	- classification
	- smart-city
	- situational-awareness
	- traffic
	- edge-ai
	- metro
	- dlstreamer
	language:
	- en
	---

	# Object Classification

	\| Property \| Value \|
	\|---\|---\|
	\| Category \| Object Classification (Traffic Categorization: People / Vehicles) \|
	\| Base Model \| [YOLO26](https://docs.ultralytics.com/models/yolo26/) (Ultralytics) \|
	\| Source Framework \| PyTorch (Ultralytics) \|
	\| Supported Precisions \| FP32, FP16, INT8 (mixed-precision) \|
	\| Inference Engine \| OpenVINO \|
	\| Hardware \| CPU, GPU, NPU \|
	\| Detected Class(es) \| `person` and vehicle classes grouped into `People` and `Vehicles` \|

	---

	## Overview

	Object Classification is a Metro Analytics use case that detects objects with [YOLO26](https://docs.ultralytics.com/models/yolo26/) and then categorizes each detection into higher-level city-operations groups.
	It is built on the state-of-the-art YOLO26 real-time detector, quantized to INT8 for efficient inference on Intel hardware.
	Where the general object-detection use case reports every one of the 80 COCO classes individually, this use case rolls the traffic-relevant classes up into two semantic categories, `People` and `Vehicles`, so operators get an at-a-glance picture of a scene.

	The traffic categories are:

	- People -- the COCO `person` class.
	- Vehicles -- the COCO `bicycle`, `car`, `motorcycle`, `bus`, `train`, and `truck` classes.

	Objects outside these categories are ignored to keep the output focused on traffic situational awareness.

	Typical Metro deployments include:

	- Situational Awareness -- summarize each camera feed as live People and Vehicles counts.
	- Automated City Operations -- feed category counts into signal timing, congestion, and dispatch logic.
	- Intersection and Roundabout Monitoring -- track the mix of pedestrians and vehicles at busy junctions.
	- Trend Analytics -- aggregate category counts over time to understand traffic patterns.

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

	---

	## Prerequisites

	- Python 3.11+
	- [Install OpenVINO](https://docs.openvino.ai/2026/get-started/install-openvino.html) (latest version)
	- [Install Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/get_started/install/install_guide_ubuntu.html) (latest version)

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

	```bash
	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:

	```bash
	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

	```bash
	./export_and_quantize.sh yolo26n FP32 # full-precision
	./export_and_quantize.sh yolo26n INT8 # quantized
	./export_and_quantize.sh yolo26s # larger variant, default FP16
	```

	Replace `yolo26n` with any variant (`yolo26s`, `yolo26m`, `yolo26l`, `yolo26x`).
	The second argument selects the precision (`FP32`, `FP16`, `INT8`); the default is FP16.

	The script performs the following steps:

	1. Installs dependencies (`openvino`, `ultralytics`; adds `nncf` for INT8).
	2. Downloads a sample traffic video (`test_video.mp4`) of an urban roundabout at low resolution (640x360).
	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_objcls_int8.xml` / `yolo26n_objcls_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 a frame 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 traffic video, maps each
	detection into the `People` or `Vehicles` category, draws boxes colored per
	category, overlays live category counts, and writes the annotated result to
	`output_openvino.mp4`.
	YOLO26 is end-to-end (NMS-free), so no manual non-maximum suppression is needed.
	Change the `device` string to run on CPU, GPU, or NPU.

	```python
	import cv2
	import numpy as np
	import openvino as ov

	CONF_THRESHOLD = 0.4
	INPUT_SIZE = 640

	# Map the traffic-relevant COCO class ids into higher-level city categories.
	# People and Vehicles are the two categories tracked for situational awareness.
	CATEGORY_BY_CLASS_ID = {
	0: "People", # person
	1: "Vehicles", # bicycle
	2: "Vehicles", # car
	3: "Vehicles", # motorcycle
	5: "Vehicles", # bus
	6: "Vehicles", # train
	7: "Vehicles", # truck
	}
	# BGR overlay colors for each category.
	CATEGORY_COLORS = {
	"People": (0, 200, 0),
	"Vehicles": (255, 128, 0),
	}

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

	# YOLO26 embeds the 80 COCO class names in rt_info. Ultralytics separates
	# multi-word names with underscores (e.g. "traffic_light"), so restore spaces.
	COCO_NAMES = [
	name.replace("_", " ")
	for name in model.get_rt_info()["model_info"]["labels"].value.split()
	]

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

	cap = cv2.VideoCapture("test_video.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))
	writer = cv2.VideoWriter(
	"output_openvino.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (width, height)
	)

	totals = {"People": 0, "Vehicles": 0}
	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

	# YOLO26 end-to-end output: [1, 300, 6] = [x1, y1, x2, y2, confidence, class_id].
	output = compiled([blob])[output_port][0]

	sx, sy = width / INPUT_SIZE, height / INPUT_SIZE
	counts = {"People": 0, "Vehicles": 0}
	for x1, y1, x2, y2, conf, class_id in output:
	if conf < CONF_THRESHOLD:
	continue
	category = CATEGORY_BY_CLASS_ID.get(int(class_id))
	if category is None:
	continue # not a traffic-relevant object
	counts[category] += 1
	totals[category] += 1
	color = CATEGORY_COLORS[category]
	px1, py1 = int(x1 * sx), int(y1 * sy)
	px2, py2 = int(x2 * sx), int(y2 * sy)
	label = f"{category}: {COCO_NAMES[int(class_id)]} {conf:.2f}"
	cv2.rectangle(frame, (px1, py1), (px2, py2), color, 2)
	cv2.putText(frame, label, (px1, py1 - 5),
	cv2.FONT_HERSHEY_SIMPLEX, 2.0, color, 2)

	# Overlay the per-category counts for this frame.
	banner = f"People: {counts['People']} Vehicles: {counts['Vehicles']}"
	cv2.rectangle(frame, (0, 0), (width, 60), (0, 0, 0), -1)
	cv2.putText(frame, banner, (15, 45),
	cv2.FONT_HERSHEY_SIMPLEX, 2.0, (255, 255, 255), 2)

	if frame_idx % 30 == 0:
	print(f"frame {frame_idx}: {banner}", flush=True)

	writer.write(frame)

	cap.release()
	writer.release()
	print(f"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
	print("Saved: output_openvino.mp4")
	```

	Device targets:

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

	### Try It on a Sample Video

	The `export_and_quantize.sh` script downloads `test_video.mp4` automatically.
	Re-run the OpenVINO sample above.
	The script reads `test_video.mp4`, prints the running People and Vehicles counts to the console, and writes the annotated video to `output_openvino.mp4`.

	Expected console output (representative):

	```text
	frame 30: People: 4 Vehicles: 6
	frame 60: People: 3 Vehicles: 7
	frame 90: People: 5 Vehicles: 5
	Summary: People=372 Vehicles=548
	Saved: output_openvino.mp4
	```

	#### Expected Output

	![OpenVINO expected output](expected_output_openvino.gif)

	### DLStreamer Sample

	The pipeline below runs the FP16 YOLO26 detector on the sample video via
	`gvadetect`, overlays bounding boxes with `gvawatermark` for the traffic-relevant
	classes only (non-traffic detections such as `handbag` are filtered out via
	`show-roi`), saves the annotated result to `output_dlstreamer.mp4`, and prints the
	`People` and `Vehicles` category counts per frame from the detection metadata.

	> 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.
	> - Export `PYTHONPATH` so the DLStreamer Python module is importable:
	>
	> ```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:-}
	> ```

	```python
	import gi

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

	Gst.init([])

	INPUT_VIDEO = "test_video.mp4"

	# Traffic-relevant COCO labels grouped into higher-level city categories.
	CATEGORY_BY_LABEL = {
	"person": "People",
	"bicycle": "Vehicles",
	"car": "Vehicles",
	"motorcycle": "Vehicles",
	"bus": "Vehicles",
	"train": "Vehicles",
	"truck": "Vehicles",
	}

	# For CPU: change device=GPU to device=CPU.
	# For NPU: change device=GPU to device=NPU (batch-size=1, nireq=4 recommended).
	# gvawatermark displ-cfg:
	# show-roi=... draws only the traffic-relevant classes (person + vehicles),
	# so non-traffic detections such as handbag/backpack are not boxed.
	# font-scale=1.5 enlarges the label text for better visualization.
	pipeline_str = (
	f"filesrc location={INPUT_VIDEO} ! decodebin3 ! "
	"videoconvert ! "
	"gvadetect model=yolo26n_openvino_model/yolo26n.xml "
	"device=GPU "
	"threshold=0.4 ! queue ! "
	"gvawatermark "
	"displ-cfg=show-roi=person:bicycle:car:motorcycle:bus:train:truck,font-scale=2.5 ! "
	"videoconvert ! video/x-raw,format=I420 ! "
	"openh264enc ! h264parse ! "
	"mp4mux ! filesink name=sink location=output_dlstreamer.mp4"
	)
	pipeline = Gst.parse_launch(pipeline_str)

	totals = {"People": 0, "Vehicles": 0}


	def on_buffer(pad, info):
	buf = info.get_buffer()
	rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf)
	if rmeta is None:
	return Gst.PadProbeReturn.OK
	counts = {"People": 0, "Vehicles": 0}
	idx = 1
	while True:
	ok, od = rmeta.get_od_mtd(idx)
	if not ok:
	break
	label = GLib.quark_to_string(od.get_obj_type())
	category = CATEGORY_BY_LABEL.get(label)
	if category is not None:
	counts[category] += 1
	totals[category] += 1
	idx += 1
	if counts["People"] or counts["Vehicles"]:
	print(f"frame: People={counts['People']} Vehicles={counts['Vehicles']}",
	flush=True)
	return Gst.PadProbeReturn.OK


	sink = pipeline.get_by_name("sink")
	sink_pad = sink.get_static_pad("sink")
	sink_pad.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"Summary: People={totals['People']} Vehicles={totals['Vehicles']}")
	```

	#### Expected Output

	![DLStreamer expected output](expected_output_dlstreamer.gif)

	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.

	---

	## License

	Licensed under the MIT License. See [LICENSE](LICENSE) for details.

	## References

	- [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)
	- [Sample video: Urban roundabout with cars and pedestrian (Pexels)](https://www.pexels.com/video/urban-roundabout-with-cars-and-pedestrian-30119018/)
	- [OpenVINO Documentation](https://docs.openvino.ai/)
	- [NNCF Post-Training Quantization](https://docs.openvino.ai/latest/nncf_ptq_introduction.html)
	- [Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/index.html)