Sync fire-and-smoke-detection from metro-analytics-catalog

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+expected_output_dlstreamer.gif filter=lfs diff=lfs merge=lfs -text
+expected_output_openvino.gif filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Intel Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE

README.md

@@ -0,0 +1,387 @@
+---
+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)

export_and_quantize.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# SPDX-License-Identifier: MIT
+# Copyright (C) Intel Corporation
+#
+# Export a community YOLOv26 fire/smoke detector to OpenVINO IR for the
+# fire-and-smoke-detection use case. The model detects the "fire" and
+# "smoke" classes.
+# Usage: ./export_and_quantize.sh [PRECISION]
+# Example: ./export_and_quantize.sh FP16
+
+set -euo pipefail
+
+PRECISION="${1:-FP16}"
+PRECISION="$(echo "${PRECISION}" | tr '[:lower:]' '[:upper:]')"
+
+MODEL_NAME="yolov26_fire"
+MODEL_URL="https://huggingface.co/SalahALHaismawi/yolov26-fire-detection/resolve/main/best.pt"
+
+# CC0 / Pexels-licensed sample video: "Aerial view of wildfire in forested
+# area" by K (Kelly), free to use via Pexels.
+VIDEO_URL="https://www.pexels.com/download/video/30937716/"
+
+if [[ "${PRECISION}" != "FP32" && "${PRECISION}" != "FP16" && "${PRECISION}" != "INT8" ]]; then
+    echo "ERROR: unsupported precision '${PRECISION}'. Choose FP32, FP16, or INT8." >&2
+    exit 1
+fi
+
+echo "--- Installing dependencies ---"
+if [[ "${PRECISION}" == "INT8" ]]; then
+    pip install -qU openvino nncf ultralytics
+else
+    pip install -qU openvino ultralytics
+fi
+
+# Ask for approval before downloading models and sample files
+echo ""
+echo "This script will download:"
+echo "  - Community YOLOv26 fire/smoke model weights"
+echo "  - A Pexels-licensed sample wildfire video"
+echo ""
+read -p "Continue with downloads? (yes/no): " APPROVAL
+if [[ "${APPROVAL}" != "yes" ]]; then
+    echo "Download cancelled by user."
+    exit 0
+fi
+echo ""
+
+echo "--- Downloading fire/smoke model weights ---"
+if [[ ! -f "${MODEL_NAME}.pt" ]]; then
+    curl -sL -o "${MODEL_NAME}.pt" "${MODEL_URL}"
+    echo "Downloaded: ${MODEL_NAME}.pt"
+else
+    echo "Already present: ${MODEL_NAME}.pt"
+fi
+
+echo "--- Downloading and transcoding sample test video ---"
+# Both samples run on an H.264 MP4. A fire/smoke-rich 8-second window is
+# trimmed, center-cropped to a square (so the fixed 640x640 resize does not
+# distort the aspect ratio the model is sensitive to), and transcoded with
+# ffmpeg.
+if [[ ! -f test_video.mp4 ]]; then
+    if ! command -v ffmpeg >/dev/null 2>&1; then
+        echo "ERROR: ffmpeg is required to transcode the sample video." >&2
+        echo "Install it (e.g. 'sudo apt-get install ffmpeg') and re-run." >&2
+        exit 1
+    fi
+    curl -sL -o fire_source.mp4 "${VIDEO_URL}"
+    ffmpeg -y -loglevel error -ss 2 -t 8 -i fire_source.mp4 \
+        -vf "crop=ih:ih,scale=736:736,format=yuv420p" \
+        -c:v libx264 -preset veryfast -an test_video.mp4
+    rm -f fire_source.mp4
+    echo "Downloaded and transcoded: test_video.mp4"
+else
+    echo "Already present: test_video.mp4"
+fi
+
+if [[ "${PRECISION}" == "FP32" ]]; then
+    HALF_FLAG="False"
+    EXPORT_LABEL="FP32"
+else
+    HALF_FLAG="True"
+    EXPORT_LABEL="FP16"
+fi
+
+echo "--- Exporting ${MODEL_NAME} to OpenVINO IR (${EXPORT_LABEL}) ---"
+python3 -c "
+from ultralytics import YOLO
+
+model = YOLO('${MODEL_NAME}.pt')
+model.export(format='openvino', half=${HALF_FLAG}, dynamic=False, imgsz=640)
+print('Export complete: ${MODEL_NAME}_openvino_model/')
+"
+
+if [[ "${PRECISION}" == "INT8" ]]; then
+    echo "--- Quantizing to INT8 with NNCF ---"
+    python3 -c "
+import nncf
+import openvino as ov
+import numpy as np
+import cv2
+
+core = ov.Core()
+model = core.read_model('${MODEL_NAME}_openvino_model/${MODEL_NAME}.xml')
+
+cap = cv2.VideoCapture('test_video.mp4')
+ok, frame = cap.read()
+cap.release()
+img = cv2.resize(frame, (640, 640))
+img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+img = img.transpose(2, 0, 1)[np.newaxis, ...]
+
+def transform_fn(data_item):
+    return img
+
+calibration_dataset = nncf.Dataset(list(range(300)), transform_fn)
+
+quantized = nncf.quantize(
+    model,
+    calibration_dataset,
+    preset=nncf.QuantizationPreset.MIXED,
+    subset_size=300,
+)
+
+ov.save_model(quantized, '${MODEL_NAME}_int8.xml')
+print('Quantization complete: ${MODEL_NAME}_int8.xml')
+"
+fi
+echo "--- Done ---"