--- license: mit license_link: LICENSE library_name: openvino pipeline_tag: object-detection tags: - openvino - intel - yolo - yolov26 - fire-and-smoke-detection - wildfire - smoke-detection - safety - edge-ai - metro - dlstreamer language: - en --- # Fire and Smoke Detection | Property | Value | |---|---| | **Category** | Object Detection (Fire & Smoke / Safety) | | **Base Model** | [YOLOv26 Fire Detection](https://huggingface.co/SalahALHaismawi/yolov26-fire-detection) (community, Ultralytics YOLOv26-S) | | **Source Framework** | PyTorch (Ultralytics) | | **Supported Precisions** | FP32, FP16, INT8 (mixed-precision) | | **Inference Engine** | OpenVINO | | **Hardware** | CPU, GPU, NPU | | **Detected Class(es)** | `fire`, `smoke` | --- ## Overview Fire and Smoke Detection is a Metro Analytics use case that detects open flames and smoke plumes in images and video streams and raises an on-screen alert whenever fire or smoke is present. It is built on a community [YOLOv26 fire/smoke detector](https://huggingface.co/SalahALHaismawi/yolov26-fire-detection), exported to OpenVINO IR and optionally quantized to INT8 for efficient inference on Intel hardware. The model was trained to recognize the `fire` and `smoke` classes. Rather than drawing bounding boxes, both the OpenVINO and DLStreamer samples overlay a banner across the top of each frame that reports whether fire or smoke has been detected, so operators get an immediate, unambiguous alert. Typical Metro deployments include: - **Depot and Tunnel Safety** -- raise an early alarm when open flame or smoke appears in a rail depot, tunnel, or maintenance bay. - **Trackside Vegetation Fires** -- detect brush and wildfire near the right of way before it spreads to infrastructure. - **Facility Fire Watch** -- continuous monitoring of substations, storage yards, and platforms for ignition and smoke events. - **Automated Incident Escalation** -- trigger alerts and video capture the moment a `fire` or `smoke` detection is confirmed. --- ## 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) - [FFmpeg](https://ffmpeg.org/) (used to transcode the sample video for the DLStreamer pipeline) 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 the fire/smoke model, export it to OpenVINO IR, and optionally quantize: ```bash chmod +x export_and_quantize.sh ./export_and_quantize.sh ``` This exports the model in **FP16** precision. #### Optional: Select a Different Precision ```bash ./export_and_quantize.sh FP32 # full-precision ./export_and_quantize.sh INT8 # quantized ``` The script performs the following steps: 1. Installs dependencies (`openvino`, `ultralytics`; adds `nncf` for INT8). 2. Downloads the community YOLOv26 fire/smoke weights (`yolov26_fire.pt`). 3. Downloads a Pexels-licensed sample wildfire video, transcoding it to `test_video.mp4`. 4. Exports the PyTorch weights to OpenVINO IR. 5. *(INT8 only)* Quantizes the model using NNCF post-training quantization. Output files: - `yolov26_fire_openvino_model/` -- FP32 or FP16 OpenVINO IR model directory. - `yolov26_fire_int8.xml` / `.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 | ### OpenVINO Sample The sample below runs the YOLOv26 fire/smoke detector on the sample video. For each frame it checks whether any `fire` or `smoke` detection is present and overlays an alert banner across the top of the frame -- no bounding boxes are drawn. The annotated result is written to `output_openvino.mp4`. YOLOv26 is NMS-free end-to-end, so no non-maximum suppression is required. Change the `device` string to run on CPU, GPU, or NPU. ```python import cv2 import numpy as np import openvino as ov # YOLOv26 fire/smoke detector classes. Alert on "fire" and "smoke". CLASS_NAMES = {0: "fire", 1: "smoke", 2: "other"} ALERT_CLASS_IDS = {0, 1} CONF_THRESHOLD = 0.4 INPUT_SIZE = 640 core = ov.Core() model = core.read_model("yolov26_fire_openvino_model/yolov26_fire.xml") # 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) ) 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 # YOLOv26 is NMS-free: output is [1, 300, 6] = [x1, y1, x2, y2, conf, class_id]. detections = compiled([blob])[output_port][0] detected = set() for _x1, _y1, _x2, _y2, conf, class_id in detections: if conf >= CONF_THRESHOLD and int(class_id) in ALERT_CLASS_IDS: detected.add(CLASS_NAMES[int(class_id)]) if detected: text = f"{' & '.join(sorted(detected)).upper()} DETECTED" color = (0, 0, 255) # red alert else: text = "NO FIRE / SMOKE" color = (0, 180, 0) # green # Draw the alert banner across the top of the frame (no bounding boxes). cv2.rectangle(frame, (0, 0), (width, 60), (0, 0, 0), -1) cv2.putText(frame, text, (20, 42), cv2.FONT_HERSHEY_SIMPLEX, 1.2, color, 3) if frame_idx % 30 == 0: print(f"frame {frame_idx}: {text}", 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 (validate with `benchmark_app -d NPU`). ### Try It on a Sample Video The `export_and_quantize.sh` script downloads and transcodes `test_video.mp4` automatically. Re-run the OpenVINO sample above. The script reads `test_video.mp4`, prints a periodic alert status to the console, and writes the annotated video to `output_openvino.mp4`. Expected console output (representative): ```text frame 30: FIRE & SMOKE DETECTED frame 60: FIRE & SMOKE DETECTED frame 90: SMOKE DETECTED ``` #### Expected Output ![OpenVINO expected output showing a FIRE & SMOKE DETECTED alert banner across the top of a wildfire frame](expected_output_openvino.gif) ### DLStreamer Sample The pipeline below runs the FP16 fire/smoke detector on the sample video via `gvadetect`. Frames are pulled through an `appsink`; for each frame a callback reads the detection metadata and, instead of drawing bounding boxes, overlays an alert banner across the top of the frame reporting whether `fire` or `smoke` is detected. The annotated result is written to `output_dlstreamer.mp4`. > **Notes on running this sample:** > > - Use the FP16 IR (`yolov26_fire_openvino_model/yolov26_fire.xml`). > - Frames are converted to `BGR` for the `appsink` and the banner is drawn with > OpenCV, so no additional GStreamer overlay plugin is required. > - A `threshold=0.4` is used for the video stream to keep the alert stable > across frames. > - 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([]) # Import cv2 after Gst.init to avoid a GStreamer re-initialization conflict. import cv2 import numpy as np MODEL_XML = "yolov26_fire_openvino_model/yolov26_fire.xml" INPUT_VIDEO = "test_video.mp4" ALERT_LABELS = {"fire", "smoke"} # 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 name=detect model={MODEL_XML} " f"device=GPU threshold=0.4 ! queue ! " f"videoconvert ! video/x-raw,format=BGR ! " f"appsink name=sink emit-signals=true sync=false max-buffers=4 drop=false" ) pipeline = Gst.parse_launch(pipeline_str) appsink = pipeline.get_by_name("sink") state = {"writer": None, "frame": 0} def on_sample(sink): sample = sink.emit("pull-sample") if sample is None: return Gst.FlowReturn.OK buf = sample.get_buffer() caps = sample.get_caps().get_structure(0) width = caps.get_value("width") height = caps.get_value("height") ok, mapinfo = buf.map(Gst.MapFlags.READ) if not ok: return Gst.FlowReturn.OK frame = np.frombuffer(mapinfo.data, np.uint8).reshape(height, width, 3).copy() buf.unmap(mapinfo) # Read the gvadetect metadata and collect fire/smoke labels (no boxes drawn). labels = set() rmeta = GstAnalytics.buffer_get_analytics_relation_meta(buf) if rmeta is not None: idx = 1 while True: found, od = rmeta.get_od_mtd(idx) if not found: break label = GLib.quark_to_string(od.get_obj_type()) if label in ALERT_LABELS: labels.add(label) idx += 1 if labels: text = f"{' & '.join(sorted(labels)).upper()} DETECTED" color = (0, 0, 255) # red alert else: text = "NO FIRE / SMOKE" color = (0, 180, 0) # green # Draw the alert banner across the top of the frame (no bounding boxes). cv2.rectangle(frame, (0, 0), (width, 60), (0, 0, 0), -1) cv2.putText(frame, text, (20, 42), cv2.FONT_HERSHEY_SIMPLEX, 1.2, color, 3) if state["writer"] is None: state["writer"] = cv2.VideoWriter( "output_dlstreamer.mp4", cv2.VideoWriter_fourcc(*"mp4v"), 30.0, (width, height), ) state["writer"].write(frame) state["frame"] += 1 if state["frame"] % 30 == 0: print(f"frame {state['frame']}: {text}", flush=True) return Gst.FlowReturn.OK appsink.connect("new-sample", on_sample) 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) if state["writer"] is not None: state["writer"].release() print("Saved: output_dlstreamer.mp4") ``` ### Try It on a Sample Video The `export_and_quantize.sh` script downloads and transcodes `test_video.mp4` automatically. Run the DLStreamer sample above. The callback prints a periodic alert status and writes the annotated video. Expected console output (representative): ```text frame 30: FIRE DETECTED frame 60: FIRE DETECTED frame 90: FIRE & SMOKE DETECTED ``` The annotated video is saved to `output_dlstreamer.mp4` with the alert banner drawn across the top by OpenCV -- no bounding boxes are drawn. #### Expected Output ![DLStreamer expected output showing a fire and smoke alert banner across the top of an aerial wildfire video](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 - [YOLOv26 Fire Detection Model](https://huggingface.co/SalahALHaismawi/yolov26-fire-detection) - [Ultralytics YOLO Documentation](https://docs.ultralytics.com/) - Sample video: "Aerial view of wildfire in forested area" by K (Kelly) (Pexels License), via [Pexels](https://www.pexels.com/video/aerial-view-of-wildfire-in-forested-area-30937716/) - [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)