--- license: other license_name: intel-custom license_link: LICENSE library_name: openvino pipeline_tag: object-detection tags: - openvino - intel - geti - worker-safety - ppe-detection - safety-helmet - safety-jacket - edge-ai - metro - dlstreamer language: - en --- # Worker Safety Detection | Property | Value | |---|---| | **Category** | Object Detection (PPE / Safety Compliance) | | **Base Model** | [Worker Safety Gear Detection](https://github.com/open-edge-platform/edge-ai-resources/blob/main/models/FP32/worker-safety-gear-detection.zip) (Intel Edge AI Resources, Geti-trained) | | **Source Framework** | Intel Geti (OpenVINO IR) | | **Supported Precisions** | FP32 | | **Inference Engine** | OpenVINO | | **Hardware** | CPU, GPU, NPU | | **Detected Class(es)** | `safety_jacket` (class 0), `safety_helmet` (class 1) | --- ## Overview Worker Safety Compliance Detection is a Metro Analytics use case that detects safety gear on workers to verify compliance with personal protective equipment (PPE) requirements. It uses a pre-trained FP32 detection model from [Intel Edge AI Resources](https://github.com/open-edge-platform/edge-ai-resources), trained with [Intel Geti](https://geti.intel.com/) on worker safety imagery. The model detects two classes: `safety_jacket` (high-visibility vest) and `safety_helmet` (hard hat). Frames where expected PPE is not detected indicate non-compliance. The FP32 model ships as an OpenVINO IR, ready for deployment on Intel CPUs and GPUs without additional conversion steps. Typical deployments include: - **Construction Site Safety** -- verify that all workers wear hard hats and high-visibility vests before entering active zones. - **Warehouse Compliance** -- enforce PPE policies at loading docks and forklift areas. - **Industrial Zone Monitoring** -- continuous compliance scanning at facility entry points. - **Automated Incident Reporting** -- generate alerts when expected `safety_helmet` or `safety_jacket` detections are absent for detected persons. --- ## 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 Model Run the provided script to download and extract the pre-trained FP32 model from Intel Edge AI Resources: ```bash chmod +x export_and_quantize.sh ./export_and_quantize.sh ``` The script performs the following steps: 1. Installs dependencies (`openvino`). 2. Downloads a sample test video (`test_video.avi`) from Intel Edge AI Resources. 3. Downloads `worker-safety-gear-detection.zip` from the Intel Edge AI Resources repository. 4. Extracts the FP32 OpenVINO IR model. Output files: - `./models/worker-safety-gear-detection/` -- extracted model directory containing the FP32 OpenVINO IR (`model.xml`, `model.bin`). > **Note:** The FP32 model is ready for production use on CPU and GPU. > An INT8 variant is also available from the [INT8 models directory](https://github.com/open-edge-platform/edge-ai-resources/tree/main/models/INT8) for higher throughput. ### DLStreamer Sample The pipeline below runs the worker safety FP32 detector on the sample video via `gvadetect`, overlays bounding boxes with `gvawatermark`, and saves the annotated result to `output_dlstreamer.mp4`. > **Notes on running this sample:** > > - The Geti-exported model embeds post-processing and labels internally. > `gvadetect` auto-discovers the model type for Geti-exported IRs. > - 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("GstVideo", "1.0") from gi.repository import Gst from gstgva import VideoFrame Gst.init(None) MODEL_XML = "models/worker-safety-gear-detection/deployment/Detection/model/model.xml" INPUT_VIDEO = "test_video.avi" # 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 ! " f"videoconvert ! " f"gvadetect model={MODEL_XML} device=GPU " f"threshold=0.4 ! queue ! " f"gvawatermark ! videoconvert ! video/x-raw,format=I420 ! " f"openh264enc ! h264parse ! " f"mp4mux ! filesink name=sink location=output_dlstreamer.mp4" ) pipeline = Gst.parse_launch(pipeline_str) def on_buffer(pad, info): buf = info.get_buffer() caps = pad.get_current_caps() frame = VideoFrame(buf, caps=caps) for region in frame.regions(): label = region.label() print(f" [PPE] {label} conf={region.confidence():.2f}", 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) ``` ### Try It on a Sample Video The `export_and_quantize.sh` script downloads `test_video.avi` automatically. Run the DLStreamer sample above. The buffer probe prints one line per detected safety item per frame. Expected console output (representative): ```text [PPE] safety_helmet conf=0.87 [PPE] safety_jacket conf=0.82 ``` The annotated video is saved to `output_dlstreamer.mp4` with bounding boxes drawn by `gvawatermark` around each detected `safety_helmet` and `safety_jacket`. > **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. #### 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 Copyright (C) Intel Corporation. All rights reserved. Licensed under the MIT License. See [LICENSE](LICENSE) for details. ## References - [Intel Edge AI Resources -- Worker Safety Gear Detection Model](https://github.com/open-edge-platform/edge-ai-resources/blob/main/models/FP32/worker-safety-gear-detection.zip) - [Worker Safety Gear Detection Application (Edge AI Suites)](https://github.com/open-edge-platform/edge-ai-suites/tree/main/manufacturing-ai-suite/industrial-edge-insights-vision) - [Intel Geti Platform](https://geti.intel.com/) - [OpenVINO Documentation](https://docs.openvino.ai/) - [Intel DLStreamer](https://docs.openedgeplatform.intel.com/2026.0/edge-ai-libraries/dlstreamer/index.html)