Add Innomium Ember static fire detection Space.

Browser ONNX demo with fire, smoke, and extinguisher detection plus Python FireDetector.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+*.pyc

README.md

@@ -0,0 +1,164 @@
+---
+title: Innomium Ember
+emoji: 🔥
+colorFrom: red
+colorTo: orange
+sdk: static
+app_file: index.html
+pinned: false
+license: apache-2.0
+---
+
+<div align="center">
+
+<img src="innomium_icon.svg" width="88" alt="Innomium logo" />
+
+# Innomium Ember
+
+### Ultra-light YOLO fire, smoke, and extinguisher detection for safety monitoring and edge vision.
+
+**3 classes · 9.8 MB ONNX · Runs in browser & on edge**
+
+[![Live Demo](https://img.shields.io/badge/Live_Demo-Open_Space-1565FF?style=for-the-badge)](https://huggingface.co/spaces/innomium/fire-detection)
+[![Model Size](https://img.shields.io/badge/Model-9.8_MB-001530?style=for-the-badge)](./weights.onnx)
+[![Classes](https://img.shields.io/badge/Classes-3-1565FF?style=for-the-badge)](#overview)
+
+</div>
+
+---
+
+## Overview
+
+**Innomium Ember** is a cutting-edge YOLO-based fire hazard detector — very light, very strong, and built for real-world safety scenes.
+
+Detect **fire**, **smoke**, and **fire extinguisher** with a compact **~9.8 MB ONNX** model that runs on CPU, edge hardware, or directly in the browser.
+
+| | |
+|---|---|
+| **Classes** | fire · smoke · fire extinguisher |
+| **Model format** | ONNX |
+| **Model size** | ~9.8 MB |
+| **Input size** | 640 × 640 |
+| **Inference** | Browser (WASM) · Python · Edge CPU/GPU |
+| **Post-processing** | Per-class NMS · Smoke merge · Color-prior filters |
+
+---
+
+## Performance
+
+Ember classifies fire hazards in outdoor and industrial scenes with per-class bounding boxes and confidence scores.
+
+<div align="center">
+
+| Input | Ember Output |
+|:---:|:---:|
+| <img src="example_input.png" width="420" alt="Bonfire scene — input frame" /> | <img src="example_output.png" width="420" alt="Scene with fire and smoke detections" /> |
+| Raw camera frame | Class labels + confidence scores |
+
+</div>
+
+**What this demonstrates:**
+- Multi-class detection of fire and smoke in a bonfire scene
+- Per-class NMS without cross-class suppression
+- Smoke plume detection alongside flame localization
+- Suitable for warehouses, factories, and perimeter monitoring
+
+---
+
+## Key Features
+
+- **Multi-class YOLO** — Fire, smoke, and fire extinguisher with class ID remapping from the ONNX head.
+- **Per-class NMS** — Hard NMS applied independently per class to preserve overlapping hazard types.
+- **Smoke merge** — Fragmented smoke boxes merge into coherent plumes for cleaner alerts.
+- **Color-prior filters** — Borderline fire and extinguisher detections are validated against expected pixel appearance.
+- **Privacy-first demo** — The live Space runs inference entirely in your browser. No frames are uploaded.
+
+---
+
+## Use Cases
+
+| Sector | Application |
+|--------|-------------|
+| **Industrial** | Warehouse and factory fire/smoke monitoring |
+| **Commercial** | Kitchen, server room, and office hazard detection |
+| **Outdoor** | Wildfire perimeter and campsite flame detection |
+| **Safety** | Fire extinguisher location verification in camera views |
+
+---
+
+## Live Demo
+
+Try Ember directly in your browser:
+
+**[https://huggingface.co/spaces/innomium/fire-detection](https://huggingface.co/spaces/innomium/fire-detection)**
+
+1. Open the Space
+2. Upload an image or click **Load Example**
+3. View detections with class labels and confidence scores
+
+---
+
+## Repository Structure
+
+```
+├── index.html              # Marketing site + interactive demo
+├── main.js / detector.js   # Browser inference (ONNX Runtime Web)
+├── weights.onnx              # ONNX model weights (Git LFS)
+├── app.py                    # Python FireDetector for batch / server use
+├── example_input.png         # Sample input frame
+├── example_output.png        # Sample detection output
+└── innomium_icon.svg         # Innomium logo
+```
+
+---
+
+## Local Python Usage
+
+```bash
+pip install -r requirements.txt
+```
+
+```python
+from pathlib import Path
+import cv2
+from app import FireDetector
+
+detector = FireDetector(Path("."))
+image = cv2.imread("example_input.png")
+boxes = detector.predict_image(image)
+for box in boxes:
+    print(detector.class_names[box.cls_id], box.conf)
+```
+
+### Batch inference
+
+```python
+results = detector.predict_batch([image], offset=0, n_keypoints=0)
+for frame in results:
+    print(frame.frame_id, len(frame.boxes))
+```
+
+---
+
+## Model Pipeline
+
+1. **Letterbox preprocess** — Resize and pad to model input (640×640)
+2. **ONNX inference** — YOLO multi-class fire hazard detection
+3. **Class remap** — Map model head order to `[fire, smoke, fire extinguisher]`
+4. **Per-class NMS** — Independent hard NMS per hazard class
+5. **Smoke merge & fire suppress** — Merge fragmented smoke; suppress nested fire duplicates
+6. **Color filters** — Validate borderline fire/extinguisher boxes against pixel appearance
+
+---
+
+## About Innomium
+
+Innomium builds cutting-edge computer vision models for mission-critical environments — where accuracy, latency, and deployability all matter.
+
+**Very light. Very strong. Built for safety.**
+
+---
+
+## License
+
+Apache 2.0

app.py

@@ -0,0 +1,1118 @@
+from __future__ import annotations
+
+import math
+from pathlib import Path
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from numpy import ndarray
+from pydantic import BaseModel
+
+MODEL_DIR = Path(__file__).resolve().parent
+
+class BoundingBox(BaseModel):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    cls_id: int
+    conf: float
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: list[BoundingBox]
+    keypoints: list[tuple[int, int]]
+
+
+class FireDetector:
+    """ONNX Runtime miner for fire / smoke / fire_extinguisher detection.
+
+    Strategy (ported from offense miner):
+      - per-class confidence threshold with per-class rescue bonus
+      - per-class hard NMS, then cross-class dedup
+      - horizontal-flip TTA with full-set cluster score boost
+    Plus fire001 specifics: class remap, sanity-box filter, TTA toggle.
+    """
+
+    class_names = ["fire", "smoke", "fire extinguisher"]
+    # FALLBACK order the model emits classes in -- remapped to `class_names`
+    # index by `self.cls_remap` (built in __init__). The authoritative order
+    # is read from the ONNX `names` metadata that Ultralytics embeds at
+    # export time (ships inside weights.onnx), so a retrained model with a
+    # different class order is remapped correctly without code changes.
+    # Used only when that metadata is missing or unparsable.
+    _model_class_order = ["fire", "fire extinguisher", "smoke"]
+
+    iou_thres = 0.55
+    cross_iou_thresh = 0.8
+    max_det = 150
+
+    # Per-class confidence thresholds. Higher = fewer FP for that class.
+    # Indexed by class_names order: [fire, smoke, fire_extinguisher].
+    _conf_thres_array = np.array(
+        [0.15, 0.30, 0.23], dtype=np.float32
+    )
+    # Per-class rescue bonus. If a class has ZERO boxes passing the threshold
+    # in a frame, its top-1 candidate is admitted when its score is at least
+    # (threshold - bonus). Fire and smoke get a small bonus (variable
+    # appearance); fire extinguisher does not (distinctive object, leave FP
+    # control strict).
+    _bonus_array = np.array(
+        [0.02, 0.1, 0.1], dtype=np.float32
+    )
+
+    # Box sanity filter (fire001-specific FP reduction): drop tiny / degenerate
+    # / image-spanning / extreme aspect ratio boxes.
+    min_box_area = 14 * 14
+    min_side = 8
+    max_aspect_ratio = 8.0
+
+    # Same-class merge: two boxes whose intersection covers at least this
+    # fraction of the SMALLER box are treated as the same object and replaced
+    # by their union. Catches nested boxes (IoU below the NMS threshold) and
+    # fragmented detections. Per-class because the risk differs:
+    #   smoke -- diffuse plumes fragment a lot, so a moderate threshold helps.
+    #   fire  -- separate flames must stay separate, so keep this HIGH (only a
+    #            tight core nested inside a looser flame box merges). Set to a
+    #            value > 1.0 to disable fire merging entirely.
+    # Fire merge is DISABLED by default (1.01): measured on the fire-29-val1024
+    # val split it cost fire AP (0.751 -> 0.742, composite 0.8888 -> 0.8874)
+    # because the nested core+flame boxes it collapses were scoring as separate
+    # true positives. Lower it to ~0.8 to enable, and re-measure with
+    # verify_filters.py / tune_miner.py after a retrain -- a model whose fire
+    # boxes fragment more (or live-SAM3 GT that draws fuller flames) could flip
+    # the result.
+    smoke_merge_overlap = 0.8
+    fire_merge_overlap = 1.01
+
+    # Fire containment suppression: when two FIRE boxes overlap on one object
+    # (intersection >= this fraction of the SMALLER box) keep the HIGHER-conf
+    # box and drop the other -- unchanged geometry, unlike the union merge
+    # above. This catches the nested core+flame duplicate that per-class NMS
+    # (IoU-based, iou_thres) leaves behind. Set > 1.0 to disable.
+    # DISABLED by default (1.01): measured on fire-29-val1024 it cost fire AP
+    # (0.751 -> 0.743, composite 0.8888 -> 0.8877). Cause: GT fire boxes almost
+    # never overlap (1 pair in 416), so each nested model pair has one TP + one
+    # FP, but the higher-CONF box isn't always the one matching GT at IoU 0.5 --
+    # so keeping it can drop the real match, and score-ordered AP already
+    # tolerates the duplicate. Lower to ~0.8 to enable; re-measure after a
+    # retrain or against live-SAM3 GT, which may differ.
+    fire_suppress_overlap = 0.88
+
+    # ── Low-confidence color-prior FP filters ───────────────────────────────
+    # Ported from the firedetect1007 miner's color checks, but applied ONLY to
+    # the borderline confidence band (just above each per-class threshold) and
+    # ONLY on color frames. A fire/extinguisher detection there is dropped when
+    # its pixels clearly do not match the expected appearance: warm/bright for
+    # fire, red for extinguisher. High-confidence detections are never touched.
+    #
+    # The reference miner ran these unconditionally -- a BUG on this validator,
+    # which feeds some frames as grayscale (a true red extinguisher is gray
+    # there, so a red test would wrongly delete it). We skip the filter when the
+    # ROI is near-grayscale, so it never fires on those frames.
+    #
+    # Tunable: set a max-conf gate to 0.0 to disable that filter. After a model
+    # retrain, re-validate these with tune_miner.py (the gates are relative to
+    # the per-class thresholds, so they move when those move).
+    fire_color_filter_max_conf = 0.45      # only fire boxes in (thresh, 0.45]
+    fire_ext_color_filter_max_conf = 0.40  # only ext boxes in (thresh, 0.40]
+    color_filter_min_saturation = 0.06     # skip filter if ROI is near-grayscale
+
+    # ── Corroboration FP filters (optional; OFF by default) ─────────────────
+    # Ported in spirit from firedetect1007. Both REMOVE borderline boxes that
+    # lack support -- a precision play for the validator's FP pillar. OFF by
+    # default because, unlike the color priors, they can also drop true
+    # positives; enable + sweep with verify_filters.py and keep only the
+    # settings that raise the measured composite. A max-conf gate of 0.0
+    # disables the corresponding filter.
+    #   edge filter: drop boxes touching the frame border in a low-conf band
+    #     (the validator scales/crops, so border-hugging boxes are often the
+    #     truncated remains of an object whose body is off-frame).
+    #   tta view filter: drop low-conf boxes that appear in only ONE of the two
+    #     horizontal-flip TTA views (a real object is usually seen in both).
+    use_edge_filter = False
+    edge_filter_max_conf = 0.0      # drop edge-touching boxes with conf <= this
+    edge_tol = 2.0                  # px from the border counted as "on edge"
+    use_tta_view_filter = False
+    tta_view_filter_max_conf = 0.0  # drop single-view boxes with conf <= this
+    tta_view_iou_thresh = 0.5       # IoU for "same object seen in both views"
+
+    def __init__(self, model_dir: Path | str | None = None) -> None:
+        model_dir = Path(model_dir) if model_dir is not None else MODEL_DIR
+        model_path = model_dir / "weights.onnx"
+        print("ORT version:", ort.__version__)
+
+        try:
+            ort.preload_dlls()
+            print("✅ onnxruntime.preload_dlls() success")
+        except Exception as e:
+            print(f"⚠️ preload_dlls failed: {e}")
+
+        print("ORT available providers BEFORE session:", ort.get_available_providers())
+
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        sess_options.intra_op_num_threads = 2
+        sess_options.inter_op_num_threads = 1
+        sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+
+        try:
+            self.session = ort.InferenceSession(
+                str(model_path),
+                sess_options=sess_options,
+                providers=["CPUExecutionProvider"],
+            )
+        except Exception as e:
+            self.session = ort.InferenceSession(
+                str(model_path),
+                sess_options=sess_options,
+                providers=["CPUExecutionProvider"],
+            )
+
+        print("ORT session providers:", self.session.get_providers())
+
+        # Build cls_remap: for each model-emit index i,
+        #   cls_remap[i] = self.class_names.index(model_class_order[i])
+        # i.e. converts a model-side class id into the canonical class id
+        # that downstream code (BoundingBox.cls_id, validator) expects.
+        # The model-side order comes from the ONNX metadata when available,
+        # else falls back to the static _model_class_order.
+        model_class_order = self._read_model_class_order()
+        if model_class_order is None:
+            model_class_order = list(self._model_class_order)
+            print(f"cls order: no usable ONNX metadata, FALLBACK {model_class_order}")
+        else:
+            print(f"cls order: from ONNX metadata {model_class_order}")
+        self.cls_remap = np.array(
+            [self.class_names.index(n) for n in model_class_order],
+            dtype=np.int32,
+        )
+
+        for inp in self.session.get_inputs():
+            print("INPUT:", inp.name, inp.shape, inp.type)
+        for out in self.session.get_outputs():
+            print("OUTPUT:", out.name, out.shape, out.type)
+
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [output.name for output in self.session.get_outputs()]
+        self.input_shape = self.session.get_inputs()[0].shape
+
+        self.input_height = self._safe_dim(self.input_shape[2], default=1280)
+        self.input_width = self._safe_dim(self.input_shape[3], default=1280)
+
+        self.use_tta = False
+
+        print(f"✅ ONNX model loaded from: {model_path}")
+        print(f"✅ ONNX providers: {self.session.get_providers()}")
+        print(f"✅ ONNX input: name={self.input_name}, shape={self.input_shape}")
+        print("per-class conf: " + ", ".join(
+            f"{n}={t:.3f}" for n, t in zip(
+                self.class_names, self._conf_thres_array.tolist()
+            )
+        ))
+
+        self._warmup()
+
+    def _warmup(self, iters: int = 3) -> None:
+        try:
+            dummy = np.zeros((720, 1280, 3), dtype=np.uint8)
+            for _ in range(max(1, iters)):
+                self.predict_batch(batch_images=[dummy], offset=0, n_keypoints=0)
+            print(f"✅ warmup: {iters} dummy predict_batch call(s) done")
+        except Exception as e:
+            print(f"⚠️ warmup skipped: {e}")
+
+    def __repr__(self) -> str:
+        return (
+            f"ONNXRuntime(session={type(self.session).__name__}, "
+            f"providers={self.session.get_providers()})"
+        )
+
+    @staticmethod
+    def _safe_dim(value, default: int) -> int:
+        return value if isinstance(value, int) and value > 0 else default
+
+    def _read_model_class_order(self) -> list[str] | None:
+        """Read the model's class order from Ultralytics ONNX metadata.
+
+        Returns the class names ordered by model-emit index, or None when
+        metadata is missing/unparsable or doesn't match `class_names` as a
+        set (in which case the static _model_class_order fallback is used).
+        """
+        try:
+            import ast
+
+            meta = self.session.get_modelmeta().custom_metadata_map
+            names = ast.literal_eval(meta["names"])  # e.g. {0: 'fire', ...}
+            if isinstance(names, dict):
+                order = [str(names[i]) for i in sorted(names)]
+            else:
+                order = [str(n) for n in names]
+        except Exception as e:
+            print(f"cls order: could not read ONNX names metadata ({e})")
+            return None
+        if sorted(order) != sorted(self.class_names):
+            print(
+                f"cls order: ONNX names {order} do not match expected classes "
+                f"{self.class_names}; ignoring metadata"
+            )
+            return None
+        return order
+
+    def _letterbox(
+        self,
+        image: ndarray,
+        new_shape: tuple[int, int],
+        color=(114, 114, 114),
+    ) -> tuple[ndarray, float, tuple[float, float]]:
+        h, w = image.shape[:2]
+        new_w, new_h = new_shape
+
+        ratio = min(new_w / w, new_h / h)
+        resized_w = int(round(w * ratio))
+        resized_h = int(round(h * ratio))
+
+        if (resized_w, resized_h) != (w, h):
+            interp = cv2.INTER_CUBIC if ratio > 1.0 else cv2.INTER_LINEAR
+            image = cv2.resize(image, (resized_w, resized_h), interpolation=interp)
+
+        dw = (new_w - resized_w) / 2.0
+        dh = (new_h - resized_h) / 2.0
+
+        left = int(round(dw - 0.1))
+        right = int(round(dw + 0.1))
+        top = int(round(dh - 0.1))
+        bottom = int(round(dh + 0.1))
+
+        padded = cv2.copyMakeBorder(
+            image, top, bottom, left, right,
+            borderType=cv2.BORDER_CONSTANT, value=color,
+        )
+        return padded, ratio, (dw, dh)
+
+    def _preprocess(
+        self, image: ndarray
+    ) -> tuple[np.ndarray, float, tuple[float, float], tuple[int, int]]:
+        orig_h, orig_w = image.shape[:2]
+        img, ratio, pad = self._letterbox(
+            image, (self.input_width, self.input_height)
+        )
+        # Fused scale(1/255) + BGR->RGB swap + HWC->NCHW + contiguous float32 in
+        # one optimized OpenCV call. Bit-identical (max abs diff 6e-8) to the
+        # prior cvtColor + astype/255 + transpose + ascontiguousarray chain, but
+        # ~half the preprocess time (preprocess is ~12% of predict_batch).
+        blob = cv2.dnn.blobFromImage(img, scalefactor=1.0 / 255.0, swapRB=True)
+        return blob, ratio, pad, (orig_w, orig_h)
+
+    @staticmethod
+    def _clip_boxes(boxes: np.ndarray, image_size: tuple[int, int]) -> np.ndarray:
+        w, h = image_size
+        boxes[:, 0] = np.clip(boxes[:, 0], 0, w - 1)
+        boxes[:, 1] = np.clip(boxes[:, 1], 0, h - 1)
+        boxes[:, 2] = np.clip(boxes[:, 2], 0, w - 1)
+        boxes[:, 3] = np.clip(boxes[:, 3], 0, h - 1)
+        return boxes
+
+    @staticmethod
+    def _xywh_to_xyxy(boxes: np.ndarray) -> np.ndarray:
+        out = np.empty_like(boxes)
+        out[:, 0] = boxes[:, 0] - boxes[:, 2] / 2.0
+        out[:, 1] = boxes[:, 1] - boxes[:, 3] / 2.0
+        out[:, 2] = boxes[:, 0] + boxes[:, 2] / 2.0
+        out[:, 3] = boxes[:, 1] + boxes[:, 3] / 2.0
+        return out
+
+    @staticmethod
+    def _hard_nms(
+        boxes: np.ndarray, scores: np.ndarray, iou_thresh: float
+    ) -> np.ndarray:
+        n = len(boxes)
+        if n == 0:
+            return np.array([], dtype=np.intp)
+        order = np.argsort(-scores)
+        keep: list[int] = []
+        while len(order) > 0:
+            i = int(order[0])
+            keep.append(i)
+            if len(order) == 1:
+                break
+            rest = order[1:]
+            xx1 = np.maximum(boxes[i, 0], boxes[rest, 0])
+            yy1 = np.maximum(boxes[i, 1], boxes[rest, 1])
+            xx2 = np.minimum(boxes[i, 2], boxes[rest, 2])
+            yy2 = np.minimum(boxes[i, 3], boxes[rest, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            a_i = (max(0.0, boxes[i, 2] - boxes[i, 0]) *
+                   max(0.0, boxes[i, 3] - boxes[i, 1]))
+            a_r = (np.maximum(0.0, boxes[rest, 2] - boxes[rest, 0]) *
+                   np.maximum(0.0, boxes[rest, 3] - boxes[rest, 1]))
+            iou = inter / (a_i + a_r - inter + 1e-7)
+            order = rest[iou <= iou_thresh]
+        return np.array(keep, dtype=np.intp)
+
+    def _per_class_hard_nms(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        if len(boxes) == 0:
+            return np.array([], dtype=np.intp)
+        all_keep: list[int] = []
+        for c in np.unique(cls_ids):
+            mask = cls_ids == c
+            indices = np.where(mask)[0]
+            keep = self._hard_nms(boxes[mask], scores[mask], iou_thresh)
+            all_keep.extend(indices[keep].tolist())
+        all_keep.sort()
+        return np.array(all_keep, dtype=np.intp)
+
+    def _cross_class_dedup_op(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        iou_thresh: float,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Remove near-duplicate boxes across classes.
+
+        Order candidates by (score - per_class_threshold) margin, then by area;
+        keep the highest, suppress every other box with IoU > iou_thresh.
+        This suppresses the case where the same physical object is detected
+        as multiple classes (e.g. fire vs smoke on the same flames).
+        """
+        n = len(boxes)
+        if n <= 1:
+            return boxes, scores, cls_ids
+        boxes = np.asarray(boxes, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        cls_ids = np.asarray(cls_ids, dtype=np.int32)
+        areas = (np.maximum(0.0, boxes[:, 2] - boxes[:, 0]) *
+                 np.maximum(0.0, boxes[:, 3] - boxes[:, 1]))
+        margins = scores - self._conf_thres_array[cls_ids]
+        order = np.lexsort((-areas, -margins))
+        suppressed = np.zeros(n, dtype=bool)
+        keep: list[int] = []
+        for i in order:
+            if suppressed[i]:
+                continue
+            keep.append(int(i))
+            bi = boxes[i]
+            xx1 = np.maximum(bi[0], boxes[:, 0])
+            yy1 = np.maximum(bi[1], boxes[:, 1])
+            xx2 = np.minimum(bi[2], boxes[:, 2])
+            yy2 = np.minimum(bi[3], boxes[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            a_i = max(1e-7, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            iou = inter / (a_i + areas - inter + 1e-7)
+            dup = iou > iou_thresh
+            dup[i] = False
+            suppressed |= dup
+        keep_idx = np.array(keep, dtype=np.intp)
+        return boxes[keep_idx], scores[keep_idx], cls_ids[keep_idx]
+
+    def _merge_class_boxes(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        target_cls: int,
+        overlap: float,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Merge overlapping detections of ONE class into single boxes.
+
+        Two same-class boxes whose intersection covers >= `overlap` of the
+        SMALLER box are treated as one object and replaced by their union with
+        the max confidence of the pair. Repeats until no pair merges, so chains
+        of fragments collapse. `overlap` is intersection-over-minimum-area, so
+        only nested / heavily-overlapping boxes merge -- two spatially separate
+        objects (low mutual overlap) are never fused. `overlap > 1.0` disables.
+        """
+        if overlap > 1.0:
+            return boxes, scores, cls_ids
+        idx = np.where(cls_ids == target_cls)[0]
+        if len(idx) <= 1:
+            return boxes, scores, cls_ids
+
+        sb = boxes[idx].astype(np.float32).tolist()
+        ss = scores[idx].astype(np.float32).tolist()
+        merged_any = True
+        while merged_any and len(sb) > 1:
+            merged_any = False
+            for i in range(len(sb)):
+                for j in range(i + 1, len(sb)):
+                    a, b = sb[i], sb[j]
+                    ix1 = max(a[0], b[0])
+                    iy1 = max(a[1], b[1])
+                    ix2 = min(a[2], b[2])
+                    iy2 = min(a[3], b[3])
+                    inter = max(0.0, ix2 - ix1) * max(0.0, iy2 - iy1)
+                    area_a = max(0.0, a[2] - a[0]) * max(0.0, a[3] - a[1])
+                    area_b = max(0.0, b[2] - b[0]) * max(0.0, b[3] - b[1])
+                    smaller = min(area_a, area_b)
+                    if inter / (smaller + 1e-7) >= overlap:
+                        sb[i] = [
+                            min(a[0], b[0]), min(a[1], b[1]),
+                            max(a[2], b[2]), max(a[3], b[3]),
+                        ]
+                        ss[i] = max(ss[i], ss[j])
+                        del sb[j]
+                        del ss[j]
+                        merged_any = True
+                        break
+                if merged_any:
+                    break
+
+        other = cls_ids != target_cls
+        new_boxes = np.concatenate(
+            [boxes[other].astype(np.float32),
+             np.array(sb, dtype=np.float32).reshape(-1, 4)]
+        )
+        new_scores = np.concatenate(
+            [scores[other].astype(np.float32),
+             np.array(ss, dtype=np.float32)]
+        )
+        new_cls = np.concatenate(
+            [cls_ids[other].astype(np.int32),
+             np.full(len(sb), target_cls, dtype=np.int32)]
+        )
+        return new_boxes, new_scores, new_cls
+
+    def _suppress_contained_lower_conf(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        target_cls: int,
+        overlap: float,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """For one class, when two boxes overlap (intersection >= `overlap` of
+        the smaller box) keep the higher-confidence box and drop the other.
+        Geometry is never changed -- only the redundant lower-conf box is
+        removed. `overlap > 1.0` disables."""
+        if overlap > 1.0:
+            return boxes, scores, cls_ids
+        idx = np.where(cls_ids == target_cls)[0]
+        if len(idx) <= 1:
+            return boxes, scores, cls_ids
+
+        order = idx[np.argsort(-scores[idx])]  # highest confidence first
+        remove: set[int] = set()
+        for a in range(len(order)):
+            i = int(order[a])
+            if i in remove:
+                continue
+            bi = boxes[i]
+            area_i = max(1e-7, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            for b in range(a + 1, len(order)):
+                j = int(order[b])
+                if j in remove:
+                    continue
+                bj = boxes[j]
+                ix1 = max(bi[0], bj[0]); iy1 = max(bi[1], bj[1])
+                ix2 = min(bi[2], bj[2]); iy2 = min(bi[3], bj[3])
+                inter = max(0.0, ix2 - ix1) * max(0.0, iy2 - iy1)
+                if inter <= 0.0:
+                    continue
+                area_j = max(1e-7, float((bj[2] - bj[0]) * (bj[3] - bj[1])))
+                if inter / (min(area_i, area_j) + 1e-7) >= overlap:
+                    remove.add(j)  # j is the lower-confidence box (order desc)
+        if not remove:
+            return boxes, scores, cls_ids
+        keep = np.array(
+            [k not in remove for k in range(len(boxes))], dtype=bool
+        )
+        return boxes[keep], scores[keep], cls_ids[keep]
+
+    def _merge_same_class_boxes(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Resolve nested / fragmented same-object detections, per class.
+
+        Smoke: diffuse plumes fragment into nested boxes NMS can't collapse, so
+        they are UNION-merged (smoke_merge_overlap).
+        Fire: a tight hot-core box and a looser flame box are the same flame;
+        keep the HIGHER-confidence one and drop the other (fire_suppress_overlap),
+        which leaves geometry intact. The union-merge variant (fire_merge_overlap)
+        is also available but measured worse, so it is disabled by default.
+        """
+        boxes, scores, cls_ids = self._merge_class_boxes(
+            boxes, scores, cls_ids,
+            self.class_names.index("smoke"), self.smoke_merge_overlap,
+        )
+        boxes, scores, cls_ids = self._merge_class_boxes(
+            boxes, scores, cls_ids,
+            self.class_names.index("fire"), self.fire_merge_overlap,
+        )
+        boxes, scores, cls_ids = self._suppress_contained_lower_conf(
+            boxes, scores, cls_ids,
+            self.class_names.index("fire"), self.fire_suppress_overlap,
+        )
+        return boxes, scores, cls_ids
+
+    # Back-compat alias (older callers / tune_miner referenced this name).
+    def _merge_smoke_boxes(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        return self._merge_same_class_boxes(boxes, scores, cls_ids)
+
+    @staticmethod
+    def _max_score_per_cluster(
+        post_boxes: np.ndarray,
+        post_cls: np.ndarray,
+        full_boxes: np.ndarray,
+        full_scores: np.ndarray,
+        full_cls: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        """For each kept (post-NMS) box, return the max score over the FULL
+        candidate set among same-class boxes with IoU >= iou_thresh.
+
+        Used after horizontal-flip TTA: a high-confidence flipped detection
+        can raise the score of the corresponding original detection.
+        """
+        n = len(post_boxes)
+        if n == 0:
+            return np.empty(0, dtype=np.float32)
+        full_areas = (np.maximum(0.0, full_boxes[:, 2] - full_boxes[:, 0]) *
+                      np.maximum(0.0, full_boxes[:, 3] - full_boxes[:, 1]))
+        out = np.empty(n, dtype=np.float32)
+        for i in range(n):
+            bi = post_boxes[i]
+            xx1 = np.maximum(bi[0], full_boxes[:, 0])
+            yy1 = np.maximum(bi[1], full_boxes[:, 1])
+            xx2 = np.minimum(bi[2], full_boxes[:, 2])
+            yy2 = np.minimum(bi[3], full_boxes[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            a_i = max(0.0, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            iou = inter / (a_i + full_areas - inter + 1e-7)
+            cluster = (iou >= iou_thresh) & (full_cls == post_cls[i])
+            out[i] = float(np.max(full_scores[cluster])) if np.any(cluster) else 0.0
+        return out
+
+    def _conf_filter_mask(
+        self, scores: np.ndarray, cls_ids: np.ndarray
+    ) -> np.ndarray:
+        """Boolean keep-mask: score >= per-class threshold, with a per-class
+        rescue -- if a class has zero boxes passing, admit its top-1 candidate
+        when its score >= (per-class threshold - per-class bonus)."""
+        if len(scores) == 0:
+            return np.zeros(0, dtype=bool)
+        thr = self._conf_thres_array[cls_ids]
+        keep = scores >= thr
+        for c in np.unique(cls_ids):
+            b = float(self._bonus_array[c])
+            if b <= 0.0:
+                continue
+            cm = cls_ids == c
+            if keep[cm].any():
+                continue
+            idx = np.where(cm)[0]
+            top = int(idx[int(np.argmax(scores[idx]))])
+            if scores[top] >= self._conf_thres_array[c] - b:
+                keep[top] = True
+        return keep
+
+    def _filter_sane_boxes(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+        orig_size: tuple[int, int],
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Drop tiny / degenerate / image-spanning / extreme-AR boxes (FP)."""
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        orig_w, orig_h = orig_size
+        image_area = float(orig_w * orig_h)
+        keep = []
+        for i, box in enumerate(boxes):
+            x1, y1, x2, y2 = box.tolist()
+            bw = x2 - x1
+            bh = y2 - y1
+            if bw <= 0 or bh <= 0:
+                continue
+            if bw < self.min_side or bh < self.min_side:
+                continue
+            area = bw * bh
+            if area < self.min_box_area:
+                continue
+            if area > 0.95 * image_area:
+                continue
+            ar = max(bw / max(bh, 1e-6), bh / max(bw, 1e-6))
+            if ar > self.max_aspect_ratio:
+                continue
+            keep.append(i)
+        if not keep:
+            return (
+                np.empty((0, 4), dtype=np.float32),
+                np.empty((0,), dtype=np.float32),
+                np.empty((0,), dtype=np.int32),
+            )
+        k = np.array(keep, dtype=np.intp)
+        return boxes[k], scores[k], cls_ids[k]
+
+    def _per_view_pipeline(
+        self,
+        boxes: np.ndarray,
+        scores: np.ndarray,
+        cls_ids: np.ndarray,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Per-view post-processing pipeline: per-class NMS -> cap -> cross-class dedup -> smoke merge."""
+        if len(boxes) > 1:
+            keep = self._per_class_hard_nms(boxes, scores, cls_ids, self.iou_thres)
+            boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
+        if len(scores) > self.max_det:
+            top = np.argsort(-scores)[: self.max_det]
+            boxes, scores, cls_ids = boxes[top], scores[top], cls_ids[top]
+        if len(boxes) > 1:
+            boxes, scores, cls_ids = self._cross_class_dedup_op(
+                boxes, scores, cls_ids, self.cross_iou_thresh
+            )
+        if len(boxes) > 1:
+            boxes, scores, cls_ids = self._merge_same_class_boxes(boxes, scores, cls_ids)
+        return boxes, scores, cls_ids
+
+    @staticmethod
+    def _roi_for_box(image: np.ndarray, box: BoundingBox) -> np.ndarray | None:
+        """Clip a BoundingBox to the image and return its BGR pixel ROI."""
+        h, w = image.shape[:2]
+        x1 = max(0, int(math.floor(box.x1)))
+        y1 = max(0, int(math.floor(box.y1)))
+        x2 = min(w, int(math.ceil(box.x2)))
+        y2 = min(h, int(math.ceil(box.y2)))
+        if x2 <= x1 or y2 <= y1:
+            return None
+        roi = image[y1:y2, x1:x2]
+        return roi if roi.size else None
+
+    def _roi_is_near_grayscale(self, roi: np.ndarray) -> bool:
+        """True if the ROI carries almost no color (validator grayscale frame).
+        On such ROIs the color priors are skipped so they can't delete valid
+        red/warm objects that have been stripped of color."""
+        mx = roi.max(axis=2).astype(np.float32)
+        mn = roi.min(axis=2).astype(np.float32)
+        sat = (mx - mn) / (mx + 1e-6)
+        return float(sat.mean()) < self.color_filter_min_saturation
+
+    @staticmethod
+    def _passes_fire_color(roi: np.ndarray) -> bool:
+        """Fire is warm and/or has a bright hotspot. ROI is BGR."""
+        blue = roi[:, :, 0].astype(np.float32)
+        green = roi[:, :, 1].astype(np.float32)
+        red = roi[:, :, 2].astype(np.float32)
+        mean_r = float(np.mean(red))
+        max_rgb = float(max(np.max(red), np.max(green), np.max(blue)))
+        bright_frac = float(np.mean(np.max(roi, axis=2) >= 150))
+        # A bright hotspot is fire-like even with little hue (also covers the
+        # near-white core of an intense flame).
+        if max_rgb >= 200.0 and bright_frac >= 0.01:
+            return True
+        warm = (red > green + 10.0) & (red > blue + 10.0)
+        warm_frac = float(np.mean(warm))
+        r_minus_g = mean_r - float(np.mean(green))
+        if warm_frac >= 0.05 and (
+            max_rgb >= 120.0 or mean_r >= 120.0 or warm_frac >= 0.15
+        ):
+            return True
+        if bright_frac >= 0.12 and r_minus_g >= 2.0:
+            return True
+        return False
+
+    @staticmethod
+    def _passes_fire_ext_red_color(roi: np.ndarray) -> bool:
+        """Fire extinguishers are red. ROI is BGR. Lenient: only clearly
+        cool/green/blue or very dark regions fail."""
+        blue = roi[:, :, 0].astype(np.float32)
+        green = roi[:, :, 1].astype(np.float32)
+        red = roi[:, :, 2].astype(np.float32)
+        red_dom = float(np.mean((red > green + 10.0) & (red > blue + 10.0)))
+        if red_dom >= 0.03:
+            return True
+        if (float(np.mean(red)) - float(np.mean(green))) >= 0.0 and \
+                float(np.mean(red)) >= 50.0:
+            return True
+        return False
+
+    def _remove_edge_low_conf(
+        self, results: list[BoundingBox], orig_size: tuple[int, int]
+    ) -> list[BoundingBox]:
+        """Drop border-hugging boxes in the low-confidence band."""
+        if (
+            not self.use_edge_filter
+            or self.edge_filter_max_conf <= 0.0
+            or not results
+        ):
+            return results
+        w, h = orig_size
+        tol = self.edge_tol
+        out: list[BoundingBox] = []
+        for b in results:
+            on_edge = (
+                b.x1 <= tol
+                or b.y1 <= tol
+                or b.x2 >= w - 1 - tol
+                or b.y2 >= h - 1 - tol
+            )
+            if on_edge and b.conf <= self.edge_filter_max_conf:
+                continue
+            out.append(b)
+        return out
+
+    def _views_corroborated(
+        self,
+        post_boxes: np.ndarray,
+        post_cls: np.ndarray,
+        full_boxes: np.ndarray,
+        full_cls: np.ndarray,
+        full_views: np.ndarray,
+        iou_thresh: float,
+    ) -> np.ndarray:
+        """For each post-NMS box, True if same-class detections from >= 2
+        distinct TTA views overlap it (IoU >= iou_thresh) in the full union."""
+        n = len(post_boxes)
+        if n == 0:
+            return np.zeros(0, dtype=bool)
+        full_areas = (np.maximum(0.0, full_boxes[:, 2] - full_boxes[:, 0]) *
+                      np.maximum(0.0, full_boxes[:, 3] - full_boxes[:, 1]))
+        out = np.zeros(n, dtype=bool)
+        for i in range(n):
+            bi = post_boxes[i]
+            xx1 = np.maximum(bi[0], full_boxes[:, 0])
+            yy1 = np.maximum(bi[1], full_boxes[:, 1])
+            xx2 = np.minimum(bi[2], full_boxes[:, 2])
+            yy2 = np.minimum(bi[3], full_boxes[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            a_i = max(0.0, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            iou = inter / (a_i + full_areas - inter + 1e-7)
+            mask = (iou >= iou_thresh) & (full_cls == post_cls[i])
+            if np.any(mask):
+                out[i] = len(np.unique(full_views[mask])) >= 2
+        return out
+
+    def _filter_low_conf_by_color(
+        self, image: np.ndarray, results: list[BoundingBox]
+    ) -> list[BoundingBox]:
+        """Drop borderline fire / extinguisher detections whose pixels clearly
+        contradict the class's expected color. No-op on near-grayscale ROIs and
+        on detections above the per-class color-filter conf gate."""
+        if not results:
+            return results
+        cls_fire = self.class_names.index("fire")
+        cls_ext = self.class_names.index("fire extinguisher")
+        out: list[BoundingBox] = []
+        for box in results:
+            check_fire = (
+                box.cls_id == cls_fire
+                and box.conf <= self.fire_color_filter_max_conf
+            )
+            check_ext = (
+                box.cls_id == cls_ext
+                and box.conf <= self.fire_ext_color_filter_max_conf
+            )
+            if not check_fire and not check_ext:
+                out.append(box)
+                continue
+            roi = self._roi_for_box(image, box)
+            if roi is None or self._roi_is_near_grayscale(roi):
+                out.append(box)
+                continue
+            if check_fire and not self._passes_fire_color(roi):
+                continue
+            if check_ext and not self._passes_fire_ext_red_color(roi):
+                continue
+            out.append(box)
+        return out
+
+    @staticmethod
+    def _build_results(
+        boxes: np.ndarray, scores: np.ndarray, cls_ids: np.ndarray
+    ) -> list[BoundingBox]:
+        results: list[BoundingBox] = []
+        for box, conf, cls_id in zip(boxes, scores, cls_ids):
+            x1, y1, x2, y2 = box.tolist()
+            if x2 <= x1 or y2 <= y1:
+                continue
+            results.append(
+                BoundingBox(
+                    x1=int(math.floor(x1)),
+                    y1=int(math.floor(y1)),
+                    x2=int(math.ceil(x2)),
+                    y2=int(math.ceil(y2)),
+                    cls_id=int(cls_id),
+                    conf=float(conf),
+                )
+            )
+        return results
+
+    def _decode_final_dets(
+        self,
+        preds: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        """Final-detection output path: rows shaped [x1, y1, x2, y2, conf, cls_id]."""
+        if preds.ndim == 3 and preds.shape[0] == 1:
+            preds = preds[0]
+        if preds.ndim != 2 or preds.shape[1] < 6:
+            raise ValueError(f"Unexpected ONNX final-det output shape: {preds.shape}")
+
+        boxes = preds[:, :4].astype(np.float32)
+        scores = preds[:, 4].astype(np.float32)
+        cls_ids = preds[:, 5].astype(np.int32)
+        cls_ids = self.cls_remap[cls_ids]
+
+        keep = self._conf_filter_mask(scores, cls_ids)
+        boxes = boxes[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+        if len(boxes) == 0:
+            return []
+
+        pad_w, pad_h = pad
+        boxes[:, [0, 2]] -= pad_w
+        boxes[:, [1, 3]] -= pad_h
+        boxes /= ratio
+        boxes = self._clip_boxes(boxes, orig_size)
+
+        boxes, scores, cls_ids = self._filter_sane_boxes(
+            boxes, scores, cls_ids, orig_size
+        )
+        if len(boxes) == 0:
+            return []
+
+        boxes, scores, cls_ids = self._per_view_pipeline(boxes, scores, cls_ids)
+        return self._build_results(boxes, scores, cls_ids)
+
+    def _decode_raw_yolo(
+        self,
+        preds: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        """Fallback raw-YOLO output path: per-anchor class logits."""
+        if preds.ndim != 3 or preds.shape[0] != 1:
+            raise ValueError(f"Unexpected raw ONNX output shape: {preds.shape}")
+        preds = preds[0]
+        if preds.shape[0] <= 16 and preds.shape[1] > preds.shape[0]:
+            preds = preds.T
+        if preds.ndim != 2 or preds.shape[1] < 5:
+            raise ValueError(f"Unexpected raw output shape: {preds.shape}")
+
+        boxes_xywh = preds[:, :4].astype(np.float32)
+        cls_part = preds[:, 4:].astype(np.float32)
+        if cls_part.shape[1] == 1:
+            scores = cls_part[:, 0]
+            cls_ids = np.zeros(len(scores), dtype=np.int32)
+        else:
+            cls_ids = np.argmax(cls_part, axis=1).astype(np.int32)
+            scores = cls_part[np.arange(len(cls_part)), cls_ids]
+        cls_ids = self.cls_remap[cls_ids]
+
+        keep = self._conf_filter_mask(scores, cls_ids)
+        boxes_xywh = boxes_xywh[keep]
+        scores = scores[keep]
+        cls_ids = cls_ids[keep]
+        if len(boxes_xywh) == 0:
+            return []
+        boxes = self._xywh_to_xyxy(boxes_xywh)
+
+        pad_w, pad_h = pad
+        boxes[:, [0, 2]] -= pad_w
+        boxes[:, [1, 3]] -= pad_h
+        boxes /= ratio
+        boxes = self._clip_boxes(boxes, orig_size)
+
+        boxes, scores, cls_ids = self._filter_sane_boxes(
+            boxes, scores, cls_ids, orig_size
+        )
+        if len(boxes) == 0:
+            return []
+
+        boxes, scores, cls_ids = self._per_view_pipeline(boxes, scores, cls_ids)
+        return self._build_results(boxes, scores, cls_ids)
+
+    def _postprocess(
+        self,
+        output: np.ndarray,
+        ratio: float,
+        pad: tuple[float, float],
+        orig_size: tuple[int, int],
+    ) -> list[BoundingBox]:
+        if output.ndim == 2 and output.shape[1] >= 6:
+            return self._decode_final_dets(output, ratio, pad, orig_size)
+        if output.ndim == 3 and output.shape[0] == 1 and output.shape[2] == 6:
+            return self._decode_final_dets(output, ratio, pad, orig_size)
+        return self._decode_raw_yolo(output, ratio, pad, orig_size)
+
+    def _predict_single(self, image: np.ndarray) -> list[BoundingBox]:
+        if image is None:
+            raise ValueError("Input image is None")
+        if not isinstance(image, np.ndarray):
+            raise TypeError(f"Input is not numpy array: {type(image)}")
+        if image.ndim != 3:
+            raise ValueError(f"Expected HWC image, got shape={image.shape}")
+        if image.shape[0] <= 0 or image.shape[1] <= 0:
+            raise ValueError(f"Invalid image shape={image.shape}")
+        if image.shape[2] != 3:
+            raise ValueError(f"Expected 3 channels, got shape={image.shape}")
+        if image.dtype != np.uint8:
+            image = image.astype(np.uint8)
+
+        input_tensor, ratio, pad, orig_size = self._preprocess(image)
+        expected = (1, 3, self.input_height, self.input_width)
+        if input_tensor.shape != expected:
+            raise ValueError(
+                f"Bad input tensor shape={input_tensor.shape}, expected={expected}"
+            )
+
+        outputs = self.session.run(self.output_names, {self.input_name: input_tensor})
+        return self._postprocess(outputs[0], ratio, pad, orig_size)
+
+    def _predict_tta(self, image: np.ndarray) -> list[BoundingBox]:
+        """Horizontal-flip TTA.
+
+        Strategy:
+          1. Predict on original and on flipped image.
+          2. Map flipped boxes back to original coordinates.
+          3. Per-class hard NMS on the union.
+          4. For each kept box, compute the max same-class score across the
+             FULL union (not just the post-NMS subset) -- this lets a high-
+             confidence flipped detection raise a borderline original one.
+          5. Cross-class dedup to suppress same-physical-object multi-class.
+          6. Smoke merge: overlapping / nested smoke boxes collapse into
+             their union (one box per smoke object).
+        """
+        boxes_orig = self._predict_single(image)
+        flipped = cv2.flip(image, 1)
+        boxes_flip = self._predict_single(flipped)
+        w = image.shape[1]
+        boxes_flip = [
+            BoundingBox(
+                x1=w - b.x2, y1=b.y1, x2=w - b.x1, y2=b.y2,
+                cls_id=b.cls_id, conf=b.conf,
+            )
+            for b in boxes_flip
+        ]
+        all_boxes = boxes_orig + boxes_flip
+        if not all_boxes:
+            return []
+
+        coords = np.array(
+            [[b.x1, b.y1, b.x2, b.y2] for b in all_boxes], dtype=np.float32
+        )
+        scores = np.array([b.conf for b in all_boxes], dtype=np.float32)
+        cls_ids = np.array([b.cls_id for b in all_boxes], dtype=np.int32)
+        # view_id 0 = original, 1 = horizontal flip (mapped back to orig coords)
+        view_ids = np.array(
+            [0] * len(boxes_orig) + [1] * len(boxes_flip), dtype=np.int32
+        )
+
+        hard_keep = self._per_class_hard_nms(coords, scores, cls_ids, self.iou_thres)
+        if len(hard_keep) == 0:
+            return []
+        if len(hard_keep) > self.max_det:
+            top = np.argsort(-scores[hard_keep])[: self.max_det]
+            hard_keep = hard_keep[top]
+
+        boosted = self._max_score_per_cluster(
+            coords[hard_keep], cls_ids[hard_keep],
+            coords, scores, cls_ids, self.iou_thres,
+        )
+
+        kept_coords = coords[hard_keep]
+        kept_cls = cls_ids[hard_keep]
+
+        # Optional: drop low-conf detections seen in only one TTA view.
+        if (
+            self.use_tta_view_filter
+            and self.tta_view_filter_max_conf > 0.0
+            and len(kept_coords) > 0
+        ):
+            corrob = self._views_corroborated(
+                kept_coords, kept_cls, coords, cls_ids, view_ids,
+                self.tta_view_iou_thresh,
+            )
+            keep = ~((boosted <= self.tta_view_filter_max_conf) & (~corrob))
+            kept_coords = kept_coords[keep]
+            boosted = boosted[keep]
+            kept_cls = kept_cls[keep]
+
+        if len(kept_coords) > 1:
+            kept_coords, boosted, kept_cls = self._cross_class_dedup_op(
+                kept_coords, boosted, kept_cls, self.cross_iou_thresh
+            )
+        if len(kept_coords) > 1:
+            kept_coords, boosted, kept_cls = self._merge_same_class_boxes(
+                kept_coords, boosted, kept_cls
+            )
+
+        return [
+            BoundingBox(
+                x1=int(math.floor(kept_coords[j, 0])),
+                y1=int(math.floor(kept_coords[j, 1])),
+                x2=int(math.ceil(kept_coords[j, 2])),
+                y2=int(math.ceil(kept_coords[j, 3])),
+                cls_id=int(kept_cls[j]),
+                conf=float(boosted[j]),
+            )
+            for j in range(len(kept_coords))
+        ]
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        results: list[TVFrameResult] = []
+        for frame_number_in_batch, image in enumerate(batch_images):
+            try:
+                if self.use_tta:
+                    boxes = self._predict_tta(image)
+                else:
+                    boxes = self._predict_single(image)
+                # Color-prior + edge FP filters on the merged result, in
+                # original-image coords. Single insertion point so they run once
+                # per frame for both the TTA and non-TTA paths.
+                if isinstance(image, np.ndarray) and image.ndim == 3:
+                    boxes = self._filter_low_conf_by_color(image, boxes)
+                    boxes = self._remove_edge_low_conf(
+                        boxes, (image.shape[1], image.shape[0])
+                    )
+            except Exception as e:
+                print(
+                    f"⚠️ Inference failed for frame "
+                    f"{offset + frame_number_in_batch}: {e}"
+                )
+                boxes = []
+            results.append(
+                TVFrameResult(
+                    frame_id=offset + frame_number_in_batch,
+                    boxes=boxes,
+                    keypoints=[(0, 0) for _ in range(max(0, int(n_keypoints)))],
+                )
+            )
+        return results
+
+    def predict_image(self, image: ndarray) -> list[BoundingBox]:
+        """Run detection on a single BGR image."""
+        if self.use_tta:
+            boxes = self._predict_tta(image)
+        else:
+            boxes = self._predict_single(image)
+        if isinstance(image, np.ndarray) and image.ndim == 3:
+            boxes = self._filter_low_conf_by_color(image, boxes)
+            boxes = self._remove_edge_low_conf(boxes, (image.shape[1], image.shape[0]))
+        return boxes

detector.js

@@ -0,0 +1,642 @@
+import * as ort from "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.21.0/dist/ort.min.mjs";
+
+const CLASS_NAMES = ["fire", "smoke", "fire extinguisher"];
+const CLS_REMAP = [0, 2, 1];
+
+const CLASS_COLORS = {
+  fire: "#EF4444",
+  smoke: "#64748B",
+  "fire extinguisher": "#DC2626",
+};
+
+const CONFIG = {
+  confThres: [0.15, 0.3, 0.23],
+  bonus: [0.02, 0.1, 0.1],
+  iouThres: 0.55,
+  crossIouThresh: 0.8,
+  maxDet: 150,
+  useTta: false,
+  minBoxArea: 14 * 14,
+  minSide: 8,
+  maxAspectRatio: 8.0,
+  maxBoxAreaRatio: 0.95,
+  smokeMergeOverlap: 0.8,
+  fireMergeOverlap: 1.01,
+  fireSuppressOverlap: 0.88,
+  fireColorFilterMaxConf: 0.45,
+  fireExtColorFilterMaxConf: 0.4,
+  colorFilterMinSaturation: 0.06,
+};
+
+function safeDim(value, fallback) {
+  return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+function remapClassId(clsId) {
+  return CLS_REMAP[clsId] ?? clsId;
+}
+
+function clipBoxes(boxes, imageW, imageH) {
+  for (const box of boxes) {
+    box[0] = Math.min(Math.max(box[0], 0), imageW - 1);
+    box[1] = Math.min(Math.max(box[1], 0), imageH - 1);
+    box[2] = Math.min(Math.max(box[2], 0), imageW - 1);
+    box[3] = Math.min(Math.max(box[3], 0), imageH - 1);
+  }
+  return boxes;
+}
+
+function hardNms(boxes, scores, iouThresh) {
+  const n = boxes.length;
+  if (n === 0) return [];
+  const order = scores
+    .map((score, index) => [score, index])
+    .sort((a, b) => b[0] - a[0])
+    .map((pair) => pair[1]);
+  const keep = [];
+  while (order.length > 0) {
+    const i = order.shift();
+    keep.push(i);
+    if (order.length === 0) break;
+    const rest = [];
+    const boxI = boxes[i];
+    const areaI = Math.max(0, boxI[2] - boxI[0]) * Math.max(0, boxI[3] - boxI[1]);
+    for (const j of order) {
+      const boxJ = boxes[j];
+      const xx1 = Math.max(boxI[0], boxJ[0]);
+      const yy1 = Math.max(boxI[1], boxJ[1]);
+      const xx2 = Math.min(boxI[2], boxJ[2]);
+      const yy2 = Math.min(boxI[3], boxJ[3]);
+      const inter = Math.max(0, xx2 - xx1) * Math.max(0, yy2 - yy1);
+      const areaJ = Math.max(0, boxJ[2] - boxJ[0]) * Math.max(0, boxJ[3] - boxJ[1]);
+      const iou = inter / (areaI + areaJ - inter + 1e-7);
+      if (iou <= iouThresh) rest.push(j);
+    }
+    order.length = 0;
+    order.push(...rest);
+  }
+  return keep;
+}
+
+function perClassHardNms(boxes, scores, clsIds, iouThresh) {
+  if (boxes.length === 0) return [];
+  const classes = [...new Set(clsIds)];
+  const allKeep = [];
+  for (const cls of classes) {
+    const indices = clsIds.map((id, i) => (id === cls ? i : -1)).filter((i) => i >= 0);
+    const classBoxes = indices.map((i) => boxes[i]);
+    const classScores = indices.map((i) => scores[i]);
+    const keep = hardNms(classBoxes, classScores, iouThresh);
+    allKeep.push(...keep.map((k) => indices[k]));
+  }
+  allKeep.sort((a, b) => a - b);
+  return allKeep;
+}
+
+function confFilterMask(scores, clsIds) {
+  const keep = scores.map((score, i) => score >= CONFIG.confThres[clsIds[i]]);
+  const classes = [...new Set(clsIds)];
+  for (const c of classes) {
+    if (CONFIG.bonus[c] <= 0) continue;
+    const indices = clsIds.map((id, i) => (id === c ? i : -1)).filter((i) => i >= 0);
+    if (indices.some((i) => keep[i])) continue;
+    let top = indices[0];
+    for (const i of indices) {
+      if (scores[i] > scores[top]) top = i;
+    }
+    if (scores[top] >= CONFIG.confThres[c] - CONFIG.bonus[c]) keep[top] = true;
+  }
+  return keep;
+}
+
+function filterSaneBoxes(boxes, scores, clsIds, origW, origH) {
+  const imageArea = origW * origH;
+  const keptBoxes = [];
+  const keptScores = [];
+  const keptCls = [];
+  for (let i = 0; i < boxes.length; i += 1) {
+    const [x1, y1, x2, y2] = boxes[i];
+    const bw = x2 - x1;
+    const bh = y2 - y1;
+    if (bw <= 0 || bh <= 0) continue;
+    if (bw < CONFIG.minSide || bh < CONFIG.minSide) continue;
+    const area = bw * bh;
+    if (area < CONFIG.minBoxArea) continue;
+    if (area > CONFIG.maxBoxAreaRatio * imageArea) continue;
+    const ar = Math.max(bw / Math.max(bh, 1e-6), bh / Math.max(bw, 1e-6));
+    if (ar > CONFIG.maxAspectRatio) continue;
+    keptBoxes.push(boxes[i]);
+    keptScores.push(scores[i]);
+    keptCls.push(clsIds[i]);
+  }
+  return { boxes: keptBoxes, scores: keptScores, clsIds: keptCls };
+}
+
+function crossClassDedup(boxes, scores, clsIds, iouThresh) {
+  const n = boxes.length;
+  if (n <= 1) return { boxes, scores, clsIds };
+  const areas = boxes.map(([x1, y1, x2, y2]) => Math.max(0, x2 - x1) * Math.max(0, y2 - y1));
+  const margins = scores.map((s, i) => s - CONFIG.confThres[clsIds[i]]);
+  const order = [...Array(n).keys()].sort((a, b) => {
+    if (margins[b] !== margins[a]) return margins[b] - margins[a];
+    return areas[b] - areas[a];
+  });
+  const suppressed = new Array(n).fill(false);
+  const keep = [];
+  for (const i of order) {
+    if (suppressed[i]) continue;
+    keep.push(i);
+    const bi = boxes[i];
+    const areaI = Math.max(1e-7, (bi[2] - bi[0]) * (bi[3] - bi[1]));
+    for (let j = 0; j < n; j += 1) {
+      if (j === i || suppressed[j]) continue;
+      const bj = boxes[j];
+      const xx1 = Math.max(bi[0], bj[0]);
+      const yy1 = Math.max(bi[1], bj[1]);
+      const xx2 = Math.min(bi[2], bj[2]);
+      const yy2 = Math.min(bi[3], bj[3]);
+      const inter = Math.max(0, xx2 - xx1) * Math.max(0, yy2 - yy1);
+      const iou = inter / (areaI + areas[j] - inter + 1e-7);
+      if (iou > iouThresh) suppressed[j] = true;
+    }
+  }
+  return {
+    boxes: keep.map((i) => boxes[i]),
+    scores: keep.map((i) => scores[i]),
+    clsIds: keep.map((i) => clsIds[i]),
+  };
+}
+
+function mergeClassBoxes(boxes, scores, clsIds, targetCls, overlap) {
+  if (overlap > 1.0) return { boxes, scores, clsIds };
+  const idx = clsIds.map((id, i) => (id === targetCls ? i : -1)).filter((i) => i >= 0);
+  if (idx.length <= 1) return { boxes, scores, clsIds };
+
+  let sb = idx.map((i) => [...boxes[i]]);
+  let ss = idx.map((i) => scores[i]);
+  let mergedAny = true;
+  while (mergedAny && sb.length > 1) {
+    mergedAny = false;
+    for (let i = 0; i < sb.length; i += 1) {
+      for (let j = i + 1; j < sb.length; j += 1) {
+        const a = sb[i];
+        const b = sb[j];
+        const ix1 = Math.max(a[0], b[0]);
+        const iy1 = Math.max(a[1], b[1]);
+        const ix2 = Math.min(a[2], b[2]);
+        const iy2 = Math.min(a[3], b[3]);
+        const inter = Math.max(0, ix2 - ix1) * Math.max(0, iy2 - iy1);
+        const areaA = Math.max(0, a[2] - a[0]) * Math.max(0, a[3] - a[1]);
+        const areaB = Math.max(0, b[2] - b[0]) * Math.max(0, b[3] - b[1]);
+        if (inter / (Math.min(areaA, areaB) + 1e-7) >= overlap) {
+          sb[i] = [Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.max(a[2], b[2]), Math.max(a[3], b[3])];
+          ss[i] = Math.max(ss[i], ss[j]);
+          sb.splice(j, 1);
+          ss.splice(j, 1);
+          mergedAny = true;
+          break;
+        }
+      }
+      if (mergedAny) break;
+    }
+  }
+
+  const other = [];
+  const otherScores = [];
+  const otherCls = [];
+  for (let i = 0; i < boxes.length; i += 1) {
+    if (clsIds[i] !== targetCls) {
+      other.push(boxes[i]);
+      otherScores.push(scores[i]);
+      otherCls.push(clsIds[i]);
+    }
+  }
+  return {
+    boxes: [...other, ...sb],
+    scores: [...otherScores, ...ss],
+    clsIds: [...otherCls, ...new Array(sb.length).fill(targetCls)],
+  };
+}
+
+function suppressContainedLowerConf(boxes, scores, clsIds, targetCls, overlap) {
+  if (overlap > 1.0) return { boxes, scores, clsIds };
+  const idx = clsIds.map((id, i) => (id === targetCls ? i : -1)).filter((i) => i >= 0);
+  if (idx.length <= 1) return { boxes, scores, clsIds };
+  const order = [...idx].sort((a, b) => scores[b] - scores[a]);
+  const remove = new Set();
+  for (let a = 0; a < order.length; a += 1) {
+    const i = order[a];
+    if (remove.has(i)) continue;
+    const bi = boxes[i];
+    const areaI = Math.max(1e-7, (bi[2] - bi[0]) * (bi[3] - bi[1]));
+    for (let b = a + 1; b < order.length; b += 1) {
+      const j = order[b];
+      if (remove.has(j)) continue;
+      const bj = boxes[j];
+      const ix1 = Math.max(bi[0], bj[0]);
+      const iy1 = Math.max(bi[1], bj[1]);
+      const ix2 = Math.min(bi[2], bj[2]);
+      const iy2 = Math.min(bi[3], bj[3]);
+      const inter = Math.max(0, ix2 - ix1) * Math.max(0, iy2 - iy1);
+      if (inter <= 0) continue;
+      const areaJ = Math.max(1e-7, (bj[2] - bj[0]) * (bj[3] - bj[1]));
+      if (inter / (Math.min(areaI, areaJ) + 1e-7) >= overlap) remove.add(j);
+    }
+  }
+  if (remove.size === 0) return { boxes, scores, clsIds };
+  const keep = boxes.map((_, i) => !remove.has(i));
+  return {
+    boxes: boxes.filter((_, i) => keep[i]),
+    scores: scores.filter((_, i) => keep[i]),
+    clsIds: clsIds.filter((_, i) => keep[i]),
+  };
+}
+
+function mergeSameClassBoxes(boxes, scores, clsIds) {
+  let state = mergeClassBoxes(boxes, scores, clsIds, CLASS_NAMES.indexOf("smoke"), CONFIG.smokeMergeOverlap);
+  state = mergeClassBoxes(state.boxes, state.scores, state.clsIds, CLASS_NAMES.indexOf("fire"), CONFIG.fireMergeOverlap);
+  state = suppressContainedLowerConf(state.boxes, state.scores, state.clsIds, CLASS_NAMES.indexOf("fire"), CONFIG.fireSuppressOverlap);
+  return state;
+}
+
+function perViewPipeline(boxes, scores, clsIds) {
+  if (boxes.length > 1) {
+    const keep = perClassHardNms(boxes, scores, clsIds, CONFIG.iouThres);
+    boxes = keep.map((i) => boxes[i]);
+    scores = keep.map((i) => scores[i]);
+    clsIds = keep.map((i) => clsIds[i]);
+  }
+  if (scores.length > CONFIG.maxDet) {
+    const order = scores.map((s, i) => [s, i]).sort((a, b) => b[0] - a[0]).slice(0, CONFIG.maxDet).map((p) => p[1]);
+    boxes = order.map((i) => boxes[i]);
+    scores = order.map((i) => scores[i]);
+    clsIds = order.map((i) => clsIds[i]);
+  }
+  if (boxes.length > 1) {
+    const deduped = crossClassDedup(boxes, scores, clsIds, CONFIG.crossIouThresh);
+    boxes = deduped.boxes;
+    scores = deduped.scores;
+    clsIds = deduped.clsIds;
+  }
+  if (boxes.length > 1) {
+    const merged = mergeSameClassBoxes(boxes, scores, clsIds);
+    boxes = merged.boxes;
+    scores = merged.scores;
+    clsIds = merged.clsIds;
+  }
+  return { boxes, scores, clsIds };
+}
+
+function toBoundingBoxes(boxes, scores, clsIds) {
+  const out = [];
+  for (let i = 0; i < boxes.length; i += 1) {
+    const [x1, y1, x2, y2] = boxes[i];
+    if (x2 <= x1 || y2 <= y1) continue;
+    out.push({
+      x1: Math.floor(x1),
+      y1: Math.floor(y1),
+      x2: Math.ceil(x2),
+      y2: Math.ceil(y2),
+      cls_id: clsIds[i],
+      conf: scores[i],
+    });
+  }
+  return out;
+}
+
+function letterboxCanvas(image, newW, newH) {
+  const srcW = image.width;
+  const srcH = image.height;
+  const ratio = Math.min(newW / srcW, newH / srcH);
+  const resizedW = Math.round(srcW * ratio);
+  const resizedH = Math.round(srcH * ratio);
+  const resized = document.createElement("canvas");
+  resized.width = resizedW;
+  resized.height = resizedH;
+  resized.getContext("2d").drawImage(image, 0, 0, resizedW, resizedH);
+  const padW = (newW - resizedW) / 2;
+  const padH = (newH - resizedH) / 2;
+  const canvas = document.createElement("canvas");
+  canvas.width = newW;
+  canvas.height = newH;
+  const ctx = canvas.getContext("2d");
+  ctx.fillStyle = "rgb(114,114,114)";
+  ctx.fillRect(0, 0, newW, newH);
+  ctx.drawImage(resized, padW, padH);
+  return { canvas, ratio, pad: [padW, padH] };
+}
+
+function imageToTensor(canvas, inputW, inputH) {
+  const { data } = canvas.getContext("2d").getImageData(0, 0, inputW, inputH);
+  const tensor = new Float32Array(1 * 3 * inputH * inputW);
+  const plane = inputH * inputW;
+  for (let y = 0; y < inputH; y += 1) {
+    for (let x = 0; x < inputW; x += 1) {
+      const i = (y * inputW + x) * 4;
+      const offset = y * inputW + x;
+      tensor[offset] = data[i] / 255;
+      tensor[plane + offset] = data[i + 1] / 255;
+      tensor[2 * plane + offset] = data[i + 2] / 255;
+    }
+  }
+  return tensor;
+}
+
+function transpose(matrix) {
+  const rows = matrix.length;
+  const cols = matrix[0].length;
+  const out = Array.from({ length: cols }, () => new Array(rows));
+  for (let r = 0; r < rows; r += 1) {
+    for (let c = 0; c < cols; c += 1) {
+      out[c][r] = matrix[r][c];
+    }
+  }
+  return out;
+}
+
+function tensorToNestedArray(tensor) {
+  const data = Array.from(tensor.data);
+  const dims = tensor.dims;
+  if (dims.length === 2) {
+    const [rows, cols] = dims;
+    const out = [];
+    for (let r = 0; r < rows; r += 1) out.push(data.slice(r * cols, (r + 1) * cols));
+    return out;
+  }
+  if (dims.length === 3) {
+    const [batch, dim1, dim2] = dims;
+    const out = [];
+    const stride = dim1 * dim2;
+    for (let b = 0; b < batch; b += 1) {
+      const batchData = data.slice(b * stride, (b + 1) * stride);
+      const rows = [];
+      for (let r = 0; r < dim1; r += 1) rows.push(batchData.slice(r * dim2, (r + 1) * dim2));
+      out.push(rows);
+    }
+    return out;
+  }
+  throw new Error(`Unsupported output tensor shape: ${dims.join("x")}`);
+}
+
+function decodeFinalDets(preds, ratio, pad, origW, origH) {
+  let rows = preds;
+  if (preds.length === 1 && Array.isArray(preds[0]) && Array.isArray(preds[0][0])) {
+    rows = preds[0];
+  }
+
+  const rawScores = [];
+  const rawCls = [];
+  for (const row of rows) {
+    if (row.length < 6) continue;
+    rawScores.push(row[4]);
+    rawCls.push(remapClassId(Math.round(row[5])));
+  }
+  const mask = confFilterMask(rawScores, rawCls);
+
+  let boxes = [];
+  let scores = [];
+  let clsIds = [];
+  for (let i = 0; i < rows.length; i += 1) {
+    if (!mask[i] || rows[i].length < 6) continue;
+    boxes.push(rows[i].slice(0, 4));
+    scores.push(rows[i][4]);
+    clsIds.push(rawCls[i]);
+  }
+
+  if (boxes.length === 0) return [];
+  const [padW, padH] = pad;
+  boxes = boxes.map(([x1, y1, x2, y2]) => [
+    (x1 - padW) / ratio,
+    (y1 - padH) / ratio,
+    (x2 - padW) / ratio,
+    (y2 - padH) / ratio,
+  ]);
+  clipBoxes(boxes, origW, origH);
+  let filtered = filterSaneBoxes(boxes, scores, clsIds, origW, origH);
+  if (filtered.boxes.length === 0) return [];
+  const piped = perViewPipeline(filtered.boxes, filtered.scores, filtered.clsIds);
+  return toBoundingBoxes(piped.boxes, piped.scores, piped.clsIds);
+}
+
+function decodeRawYolo(preds, ratio, pad, origW, origH) {
+  let rows = preds[0];
+  if (rows.length <= 16 && rows[0].length > rows.length) rows = transpose(rows);
+
+  const rawScores = [];
+  const rawCls = [];
+  const boxesXywh = [];
+  for (const row of rows) {
+    if (row.length < 5) continue;
+    const tail = row.slice(4);
+    let score;
+    let clsId;
+    if (tail.length === 1) {
+      score = tail[0];
+      clsId = 0;
+    } else {
+      clsId = tail.indexOf(Math.max(...tail));
+      score = tail[clsId];
+    }
+    clsId = remapClassId(clsId);
+    rawScores.push(score);
+    rawCls.push(clsId);
+    boxesXywh.push(row.slice(0, 4));
+  }
+
+  const mask = confFilterMask(rawScores, rawCls);
+  let boxes = [];
+  let scores = [];
+  let clsIds = [];
+  for (let i = 0; i < boxesXywh.length; i += 1) {
+    if (!mask[i]) continue;
+    const [x, y, w, h] = boxesXywh[i];
+    boxes.push([x - w / 2, y - h / 2, x + w / 2, y + h / 2]);
+    scores.push(rawScores[i]);
+    clsIds.push(rawCls[i]);
+  }
+
+  if (boxes.length === 0) return [];
+  const [padW, padH] = pad;
+  boxes = boxes.map(([x1, y1, x2, y2]) => [
+    (x1 - padW) / ratio,
+    (y1 - padH) / ratio,
+    (x2 - padW) / ratio,
+    (y2 - padH) / ratio,
+  ]);
+  clipBoxes(boxes, origW, origH);
+  let filtered = filterSaneBoxes(boxes, scores, clsIds, origW, origH);
+  if (filtered.boxes.length === 0) return [];
+  const piped = perViewPipeline(filtered.boxes, filtered.scores, filtered.clsIds);
+  return toBoundingBoxes(piped.boxes, piped.scores, piped.clsIds);
+}
+
+function postprocess(output, ratio, pad, origW, origH) {
+  const preds = tensorToNestedArray(output);
+  if (output.dims.length === 2 && output.dims[1] >= 6) {
+    return decodeFinalDets(preds, ratio, pad, origW, origH);
+  }
+  if (output.dims.length === 3 && output.dims[0] === 1 && output.dims[2] >= 6) {
+    return decodeFinalDets(preds, ratio, pad, origW, origH);
+  }
+  return decodeRawYolo(preds, ratio, pad, origW, origH);
+}
+
+function getRoiData(image, box) {
+  const canvas = document.createElement("canvas");
+  const w = image.width;
+  const h = image.height;
+  const x1 = Math.max(0, Math.floor(box.x1));
+  const y1 = Math.max(0, Math.floor(box.y1));
+  const x2 = Math.min(w, Math.ceil(box.x2));
+  const y2 = Math.min(h, Math.ceil(box.y2));
+  if (x2 <= x1 || y2 <= y1) return null;
+  canvas.width = x2 - x1;
+  canvas.height = y2 - y1;
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(image, x1, y1, x2 - x1, y2 - y1, 0, 0, x2 - x1, y2 - y1);
+  return ctx.getImageData(0, 0, x2 - x1, y2 - y1).data;
+}
+
+function roiIsNearGrayscale(data) {
+  let satSum = 0;
+  const pixels = data.length / 4;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    const mx = Math.max(r, g, b);
+    const mn = Math.min(r, g, b);
+    satSum += (mx - mn) / (mx + 1e-6);
+  }
+  return satSum / pixels < CONFIG.colorFilterMinSaturation;
+}
+
+function passesFireColor(data) {
+  let meanR = 0;
+  let meanG = 0;
+  let maxRgb = 0;
+  let brightCount = 0;
+  let warmCount = 0;
+  const pixels = data.length / 4;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    meanR += r;
+    meanG += g;
+    maxRgb = Math.max(maxRgb, r, g, b);
+    if (Math.max(r, g, b) >= 150) brightCount += 1;
+    if (r > g + 10 && r > b + 10) warmCount += 1;
+  }
+  meanR /= pixels;
+  meanG /= pixels;
+  const brightFrac = brightCount / pixels;
+  const warmFrac = warmCount / pixels;
+  if (maxRgb >= 200 && brightFrac >= 0.01) return true;
+  if (warmFrac >= 0.05 && (maxRgb >= 120 || meanR >= 120 || warmFrac >= 0.15)) return true;
+  if (brightFrac >= 0.12 && meanR - meanG >= 2) return true;
+  return false;
+}
+
+function passesFireExtColor(data) {
+  let redDom = 0;
+  let meanR = 0;
+  let meanG = 0;
+  const pixels = data.length / 4;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    meanR += r;
+    meanG += g;
+    if (r > g + 10 && r > b + 10) redDom += 1;
+  }
+  meanR /= pixels;
+  meanG /= pixels;
+  if (redDom / pixels >= 0.03) return true;
+  return meanR - meanG >= 0 && meanR >= 50;
+}
+
+function filterLowConfByColor(image, boxes) {
+  const clsFire = CLASS_NAMES.indexOf("fire");
+  const clsExt = CLASS_NAMES.indexOf("fire extinguisher");
+  const out = [];
+  for (const box of boxes) {
+    const checkFire = box.cls_id === clsFire && box.conf <= CONFIG.fireColorFilterMaxConf;
+    const checkExt = box.cls_id === clsExt && box.conf <= CONFIG.fireExtColorFilterMaxConf;
+    if (!checkFire && !checkExt) {
+      out.push(box);
+      continue;
+    }
+    const data = getRoiData(image, box);
+    if (!data || roiIsNearGrayscale(data)) {
+      out.push(box);
+      continue;
+    }
+    if (checkFire && !passesFireColor(data)) continue;
+    if (checkExt && !passesFireExtColor(data)) continue;
+    out.push(box);
+  }
+  return out;
+}
+
+export class FireDetector {
+  constructor() {
+    this.session = null;
+    this.inputName = null;
+    this.outputNames = null;
+    this.inputHeight = 1280;
+    this.inputWidth = 1280;
+  }
+
+  async load(modelUrl) {
+    ort.env.wasm.wasmPaths = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.21.0/dist/";
+    this.session = await ort.InferenceSession.create(modelUrl, {
+      executionProviders: ["wasm"],
+    });
+    this.inputName = this.session.inputNames[0];
+    this.outputNames = this.session.outputNames;
+    const shape = this.session.inputs.get(this.inputName).dims;
+    this.inputHeight = safeDim(shape[2], 1280);
+    this.inputWidth = safeDim(shape[3], 1280);
+  }
+
+  async predictSingle(image) {
+    const origW = image.width;
+    const origH = image.height;
+    const { canvas, ratio, pad } = letterboxCanvas(image, this.inputWidth, this.inputHeight);
+    const tensorData = imageToTensor(canvas, this.inputWidth, this.inputHeight);
+    const inputTensor = new ort.Tensor("float32", tensorData, [1, 3, this.inputHeight, this.inputWidth]);
+    const outputs = await this.session.run({ [this.inputName]: inputTensor });
+    return postprocess(outputs[this.outputNames[0]], ratio, pad, origW, origH);
+  }
+
+  async predictImage(image) {
+    const boxes = await this.predictSingle(image);
+    return filterLowConfByColor(image, boxes);
+  }
+}
+
+export function className(clsId) {
+  return CLASS_NAMES[clsId] ?? "unknown";
+}
+
+export function drawBoxes(ctx, boxes) {
+  ctx.lineWidth = 2;
+  ctx.font = "600 12px Inter, system-ui, sans-serif";
+  for (const box of boxes) {
+    const label = CLASS_NAMES[box.cls_id] ?? "unknown";
+    const color = CLASS_COLORS[label] ?? "#EF4444";
+    const w = box.x2 - box.x1;
+    const h = box.y2 - box.y1;
+    ctx.strokeStyle = color;
+    ctx.strokeRect(box.x1, box.y1, w, h);
+    const text = `${label.toUpperCase()} ${(box.conf * 100).toFixed(1)}%`;
+    const textWidth = ctx.measureText(text).width;
+    const y = Math.max(box.y1, 18);
+    ctx.fillStyle = color;
+    ctx.fillRect(box.x1, y - 18, textWidth + 10, 18);
+    ctx.fillStyle = "#ffffff";
+    ctx.fillText(text, box.x1 + 5, y - 4);
+  }
+}

index.html

@@ -0,0 +1,361 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
+      name="description"
+      content="Innomium Ember — ultra-light YOLO fire, smoke, and extinguisher detection for safety monitoring and edge vision."
+    />
+    <title>Innomium Ember — Fire Detection</title>
+    <link rel="icon" href="innomium_icon.svg" type="image/svg+xml" />
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="style.css" />
+  </head>
+  <body>
+    <header class="site-header">
+      <div class="container header-inner">
+        <a class="brand" href="#top">
+          <img src="innomium_icon.svg" alt="Innomium" class="brand-logo" width="40" height="40" />
+          <span class="brand-text">
+            <strong>Innomium</strong>
+            <small>Ember</small>
+          </span>
+        </a>
+        <nav class="nav">
+          <a href="#performance">Performance</a>
+          <a href="#capabilities">Capabilities</a>
+          <a href="#use-cases">Use Cases</a>
+          <a href="#demo" class="nav-cta">Live Demo</a>
+        </nav>
+      </div>
+    </header>
+
+    <main id="top">
+      <section class="hero">
+        <div class="container hero-grid">
+          <div class="hero-copy">
+            <p class="eyebrow">Innomium Vision · Edge YOLO</p>
+            <h1>
+              Fire &amp; smoke detection<br />
+              <span class="accent-text">built for safety.</span>
+            </h1>
+            <p class="hero-lead">
+              Ember is Innomium's cutting-edge YOLO model for fire, smoke, and fire
+              extinguisher detection — very light, very strong, and tuned for warehouses,
+              industrial sites, and mission-critical safety monitoring.
+            </p>
+            <div class="hero-actions">
+              <a href="#demo" class="btn btn-primary">Try Live Demo</a>
+              <a href="#performance" class="btn btn-secondary">See Results</a>
+            </div>
+            <dl class="hero-stats">
+              <div>
+                <dt>Classes</dt>
+                <dd>3 hazards</dd>
+              </div>
+              <div>
+                <dt>Model size</dt>
+                <dd>9.8 MB</dd>
+              </div>
+              <div>
+                <dt>Runtime</dt>
+                <dd>Edge / Browser</dd>
+              </div>
+            </dl>
+          </div>
+
+          <div class="hero-visual">
+            <div class="hero-visual-card">
+              <img
+                src="example_output.png"
+                alt="Ember detecting fire and smoke in an outdoor bonfire scene"
+                class="hero-image"
+              />
+              <div class="hero-visual-caption">
+                <span class="pill pill--live">Live detection</span>
+                <span>Fire + smoke · Multi-class hazards</span>
+              </div>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section id="performance" class="section">
+        <div class="container">
+          <div class="section-head section-head--center">
+            <p class="eyebrow">Proven performance</p>
+            <h2>From raw scene to classified hazards.</h2>
+            <p class="section-lead">
+              Ember detects fire, smoke, and fire extinguishers with per-class NMS,
+              smoke merging, and color-prior filters — keeping alerts accurate even in
+              complex industrial scenes.
+            </p>
+          </div>
+
+          <div class="compare-grid">
+            <figure class="compare-card">
+              <figcaption>
+                <span class="compare-label">Input</span>
+                <span class="compare-meta">Raw camera frame</span>
+              </figcaption>
+              <div class="compare-frame">
+                <img
+                  src="example_input.png"
+                  alt="Outdoor bonfire — input frame without detections"
+                  loading="lazy"
+                />
+              </div>
+            </figure>
+
+            <div class="compare-arrow" aria-hidden="true">
+              <svg width="24" height="24" viewBox="0 0 24 24" fill="none">
+                <path
+                  d="M5 12H19M19 12L13 6M19 12L13 18"
+                  stroke="currentColor"
+                  stroke-width="1.75"
+                  stroke-linecap="round"
+                  stroke-linejoin="round"
+                />
+              </svg>
+            </div>
+
+            <figure class="compare-card compare-card--highlight">
+              <figcaption>
+                <span class="compare-label">Ember output</span>
+                <span class="compare-meta">Class labels + confidence</span>
+              </figcaption>
+              <div class="compare-frame">
+                <img
+                  src="example_output.png"
+                  alt="Same scene with Ember fire and smoke detections"
+                  loading="lazy"
+                />
+              </div>
+            </figure>
+          </div>
+
+          <div class="performance-notes">
+            <article class="note-card">
+              <h3>Per-class precision</h3>
+              <p>
+                Separate NMS per class prevents smoke plumes from suppressing fire
+                flames or extinguisher detections in overlapping regions.
+              </p>
+            </article>
+            <article class="note-card">
+              <h3>Smoke merge &amp; fire suppress</h3>
+              <p>
+                Fragmented smoke boxes merge into coherent plumes, while nested fire
+                duplicates are suppressed to reduce false alerts.
+              </p>
+            </article>
+            <article class="note-card">
+              <h3>Edge-ready ONNX</h3>
+              <p>
+                A compact ~9.8 MB model deploys on safety cameras, drones, and
+                in-browser demos without a GPU farm.
+              </p>
+            </article>
+          </div>
+        </div>
+      </section>
+
+      <section id="capabilities" class="section section--muted">
+        <div class="container">
+          <div class="section-head">
+            <p class="eyebrow">Capabilities</p>
+            <h2>Safety intelligence, without the overhead.</h2>
+          </div>
+
+          <div class="feature-grid">
+            <article class="feature-card">
+              <div class="feature-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none"><path d="M12 22C16.97 22 21 17.97 21 13C21 8.03 12 2 12 2C12 2 3 8.03 3 13C3 17.97 7.03 22 12 22Z" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/><path d="M12 18C14.21 18 16 16.21 16 14C16 11.5 12 8 12 8C12 8 8 11.5 8 14C8 16.21 9.79 18 12 18Z" stroke="currentColor" stroke-width="1.75"/></svg>
+              </div>
+              <h3>3 hazard classes</h3>
+              <p>
+                Detects fire, smoke, and fire extinguisher with class-aware remapping and
+                per-class post-processing tuned for validator scoring.
+              </p>
+            </article>
+            <article class="feature-card">
+              <div class="feature-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none"><path d="M13 2L4 14H11L10 22L20 10H13L13 2Z" stroke="currentColor" stroke-width="1.75" stroke-linejoin="round"/></svg>
+              </div>
+              <h3>Ultra-light ONNX</h3>
+              <p>
+                ~9.8 MB footprint runs on CPU via ONNX Runtime Web in the browser or on
+                edge hardware at the camera.
+              </p>
+            </article>
+            <article class="feature-card">
+              <div class="feature-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none"><path d="M4 12H20M4 12L8 8M4 12L8 16" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/><circle cx="16" cy="12" r="3" stroke="currentColor" stroke-width="1.75"/></svg>
+              </div>
+              <h3>False-positive control</h3>
+              <p>
+                Color-prior filters, per-class hard NMS, and confidence thresholds reduce
+                spurious detections in complex scenes.
+              </p>
+            </article>
+            <article class="feature-card">
+              <div class="feature-icon" aria-hidden="true">
+                <svg viewBox="0 0 24 24" fill="none"><rect x="5" y="10" width="14" height="10" rx="2" stroke="currentColor" stroke-width="1.75"/><path d="M8 10V8C8 5.8 9.8 4 12 4C14.2 4 16 5.8 16 8V10" stroke="currentColor" stroke-width="1.75" stroke-linecap="round"/></svg>
+              </div>
+              <h3>Privacy-first demo</h3>
+              <p>
+                Inference runs entirely in your browser. Frames never leave your device —
+                ideal for regulated safety and surveillance pilots.
+              </p>
+            </article>
+          </div>
+        </div>
+      </section>
+
+      <section id="use-cases" class="section">
+        <div class="container">
+          <div class="section-head">
+            <p class="eyebrow">Use cases</p>
+            <h2>Where Ember delivers.</h2>
+          </div>
+
+          <div class="usecase-grid">
+            <article class="usecase-card">
+              <span class="usecase-tag">Industrial</span>
+              <h3>Warehouses &amp; factories</h3>
+              <p>Early fire and smoke detection in storage facilities, production floors, and loading bays.</p>
+            </article>
+            <article class="usecase-card">
+              <span class="usecase-tag">Commercial</span>
+              <h3>Retail &amp; offices</h3>
+              <p>Monitor kitchens, server rooms, and common areas for fire hazards and smoke buildup.</p>
+            </article>
+            <article class="usecase-card">
+              <span class="usecase-tag">Outdoor</span>
+              <h3>Wildfire &amp; perimeter</h3>
+              <p>Detect flames and smoke plumes along forest edges, campsites, and remote perimeters.</p>
+            </article>
+            <article class="usecase-card">
+              <span class="usecase-tag">Safety</span>
+              <h3>Extinguisher compliance</h3>
+              <p>Locate fire extinguishers in camera views for safety audits and equipment verification.</p>
+            </article>
+          </div>
+        </div>
+      </section>
+
+      <section id="demo" class="section section--muted">
+        <div class="container">
+          <div class="section-head section-head--center">
+            <p class="eyebrow">Interactive demo</p>
+            <h2>Upload your own scene.</h2>
+            <p class="section-lead">
+              Run the production ONNX model in your browser — per-class NMS and color filters included.
+            </p>
+          </div>
+
+          <div class="demo-shell">
+            <div class="demo-toolbar">
+              <div class="demo-status">
+                <span id="status-dot" class="status-dot status-dot--loading"></span>
+                <span id="status">Initializing model...</span>
+              </div>
+              <div class="demo-metrics">
+                <div class="metric-pill">
+                  <span class="metric-pill-label">Detected</span>
+                  <span id="count-value" class="metric-pill-value">—</span>
+                </div>
+                <div class="metric-pill">
+                  <span class="metric-pill-label">Latency</span>
+                  <span id="latency-value" class="metric-pill-value">—</span>
+                </div>
+              </div>
+            </div>
+
+            <label id="dropzone" class="dropzone" for="file-input">
+              <input id="file-input" type="file" accept="image/*" hidden />
+              <div class="dropzone-inner">
+                <div class="dropzone-icon" aria-hidden="true">
+                  <svg viewBox="0 0 24 24" fill="none"><path d="M12 16V4M12 4L8 8M12 4L16 8M4 17V18C4 19.1 4.9 20 6 20H18C19.1 20 20 19.1 20 18V17" stroke="currentColor" stroke-width="1.75" stroke-linecap="round" stroke-linejoin="round"/></svg>
+                </div>
+                <p><strong>Drop an image here</strong> or click to browse</p>
+                <p class="dropzone-hint">PNG, JPG, WEBP — industrial, outdoor, and indoor safety scenes</p>
+              </div>
+            </label>
+
+            <div class="demo-actions">
+              <button id="detect-btn" type="button" class="btn btn-primary" disabled>Run Detection</button>
+              <button id="clear-btn" type="button" class="btn btn-secondary" disabled>Clear</button>
+              <button id="sample-btn" type="button" class="btn btn-secondary">Load Example</button>
+            </div>
+
+            <div class="canvas-grid">
+              <figure class="canvas-card">
+                <figcaption>Input</figcaption>
+                <div class="canvas-frame">
+                  <canvas id="input-canvas"></canvas>
+                  <div class="canvas-placeholder">No image loaded</div>
+                </div>
+              </figure>
+              <figure class="canvas-card canvas-card--highlight">
+                <figcaption>
+                  Output
+                  <span id="output-badge" class="output-badge hidden">0 hazards</span>
+                </figcaption>
+                <div class="canvas-frame">
+                  <canvas id="output-canvas"></canvas>
+                  <div class="canvas-placeholder">Awaiting detection</div>
+                </div>
+              </figure>
+            </div>
+
+            <details class="json-panel">
+              <summary>Detection JSON</summary>
+              <pre id="json-output">[]</pre>
+            </details>
+          </div>
+        </div>
+      </section>
+
+      <section class="cta-section">
+        <div class="container cta-card">
+          <img src="innomium_icon.svg" alt="" class="cta-logo" width="56" height="56" aria-hidden="true" />
+          <div class="cta-copy">
+            <h2>Deploy Ember in your safety stack.</h2>
+            <p>
+              Very light. Very strong. Multi-class fire and smoke detection for warehouses,
+              industrial sites, and edge deployments that need reliable hazard alerts.
+            </p>
+          </div>
+          <div class="cta-actions">
+            <a href="#demo" class="btn btn-primary">Try the Demo</a>
+            <a
+              href="https://huggingface.co/innomium"
+              class="btn btn-secondary"
+              target="_blank"
+              rel="noopener noreferrer"
+            >Hugging Face</a>
+          </div>
+        </div>
+      </section>
+    </main>
+
+    <footer class="site-footer">
+      <div class="container footer-inner">
+        <div class="footer-brand">
+          <img src="innomium_icon.svg" alt="Innomium" width="28" height="28" />
+          <span>© 2026 Innomium</span>
+        </div>
+        <p class="footer-note">Ember runs locally in your browser · No data uploaded</p>
+      </div>
+    </footer>
+
+    <script type="module" src="main.js"></script>
+  </body>
+</html>

main.js

@@ -0,0 +1,198 @@
+import { FireDetector, drawBoxes, className } from "./detector.js";
+
+const fileInput = document.getElementById("file-input");
+const detectBtn = document.getElementById("detect-btn");
+const clearBtn = document.getElementById("clear-btn");
+const sampleBtn = document.getElementById("sample-btn");
+const statusEl = document.getElementById("status");
+const statusDot = document.getElementById("status-dot");
+const inputCanvas = document.getElementById("input-canvas");
+const outputCanvas = document.getElementById("output-canvas");
+const inputFrame = inputCanvas.closest(".canvas-frame");
+const outputFrame = outputCanvas.closest(".canvas-frame");
+const jsonOutput = document.getElementById("json-output");
+const dropzone = document.getElementById("dropzone");
+const countValue = document.getElementById("count-value");
+const latencyValue = document.getElementById("latency-value");
+const outputBadge = document.getElementById("output-badge");
+
+const detector = new FireDetector();
+let currentImage = null;
+
+function setStatus(message, state = "ready") {
+  statusEl.textContent = message;
+  statusDot.className = "status-dot";
+  if (state === "loading") statusDot.classList.add("status-dot--loading");
+  else if (state === "error") statusDot.classList.add("status-dot--error");
+  else statusDot.classList.add("status-dot--ready");
+}
+
+function setCanvasState(frame, hasImage) {
+  frame.classList.toggle("has-image", hasImage);
+}
+
+function drawImageToCanvas(canvas, image) {
+  canvas.width = image.width;
+  canvas.height = image.height;
+  const ctx = canvas.getContext("2d");
+  ctx.clearRect(0, 0, canvas.width, canvas.height);
+  ctx.drawImage(image, 0, 0);
+}
+
+async function loadImageFromUrl(url) {
+  const response = await fetch(url);
+  if (!response.ok) throw new Error("Failed to load image");
+  const blob = await response.blob();
+  return loadImageFromFile(blob);
+}
+
+function loadImageFromFile(file) {
+  return new Promise((resolve, reject) => {
+    const url = URL.createObjectURL(file);
+    const image = new Image();
+    image.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve(image);
+    };
+    image.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error("Failed to load image"));
+    };
+    image.src = url;
+  });
+}
+
+function summarizeDetections(boxes) {
+  const counts = {};
+  for (const box of boxes) {
+    const name = className(box.cls_id);
+    counts[name] = (counts[name] ?? 0) + 1;
+  }
+  return Object.entries(counts)
+    .map(([name, count]) => `${count} ${name}${count === 1 ? "" : "s"}`)
+    .join(", ");
+}
+
+function updateMetrics(count, latencyMs, boxes = null) {
+  countValue.textContent = count ?? "—";
+  latencyValue.textContent = latencyMs != null ? `${latencyMs} ms` : "—";
+  if (count == null) {
+    outputBadge.classList.add("hidden");
+    return;
+  }
+  const summary = boxes?.length ? summarizeDetections(boxes) : `${count} detections`;
+  outputBadge.textContent = summary;
+  outputBadge.classList.remove("hidden");
+}
+
+function clearDemo() {
+  currentImage = null;
+  fileInput.value = "";
+  jsonOutput.textContent = "[]";
+  setCanvasState(inputFrame, false);
+  setCanvasState(outputFrame, false);
+  detectBtn.disabled = true;
+  clearBtn.disabled = true;
+  updateMetrics(null, null);
+  setStatus("Model ready. Upload a scene or load the example.", "ready");
+}
+
+async function setCurrentImage(image) {
+  currentImage = image;
+  drawImageToCanvas(inputCanvas, currentImage);
+  drawImageToCanvas(outputCanvas, currentImage);
+  setCanvasState(inputFrame, true);
+  setCanvasState(outputFrame, true);
+  jsonOutput.textContent = "[]";
+  detectBtn.disabled = false;
+  clearBtn.disabled = false;
+  updateMetrics(null, null);
+}
+
+async function loadImage(file) {
+  setStatus("Loading image...", "loading");
+  const image = await loadImageFromFile(file);
+  await setCurrentImage(image);
+  setStatus("Image loaded. Running Ember...", "loading");
+  await runDetection();
+}
+
+async function loadExample() {
+  try {
+    setStatus("Loading example scene...", "loading");
+    const image = await loadImageFromUrl("./example_input.png");
+    await setCurrentImage(image);
+    setStatus("Example loaded. Running Ember...", "loading");
+    await runDetection();
+  } catch (error) {
+    setStatus(error.message, "error");
+  }
+}
+
+async function runDetection() {
+  if (!currentImage) return;
+  detectBtn.disabled = true;
+  setStatus("Analyzing scene...", "loading");
+  const started = performance.now();
+  try {
+    const boxes = await detector.predictImage(currentImage);
+    const latencyMs = Math.round(performance.now() - started);
+    drawImageToCanvas(outputCanvas, currentImage);
+    drawBoxes(outputCanvas.getContext("2d"), boxes);
+    jsonOutput.textContent = JSON.stringify(boxes, null, 2);
+    updateMetrics(boxes.length, latencyMs, boxes);
+    const headline =
+      boxes.length === 0
+        ? "No fire hazards detected in this frame."
+        : `Ember found ${boxes.length} detection${boxes.length === 1 ? "" : "s"} in ${latencyMs} ms.`;
+    setStatus(headline, "ready");
+  } catch (error) {
+    console.error(error);
+    setStatus(`Detection failed: ${error.message}`, "error");
+  } finally {
+    detectBtn.disabled = false;
+  }
+}
+
+fileInput.addEventListener("change", async (event) => {
+  const file = event.target.files?.[0];
+  if (!file) return;
+  try {
+    await loadImage(file);
+  } catch (error) {
+    setStatus(error.message, "error");
+  }
+});
+
+detectBtn.addEventListener("click", runDetection);
+clearBtn.addEventListener("click", clearDemo);
+sampleBtn.addEventListener("click", loadExample);
+
+dropzone.addEventListener("dragover", (event) => {
+  event.preventDefault();
+  dropzone.classList.add("is-dragover");
+});
+dropzone.addEventListener("dragleave", () => dropzone.classList.remove("is-dragover"));
+dropzone.addEventListener("drop", async (event) => {
+  event.preventDefault();
+  dropzone.classList.remove("is-dragover");
+  const file = event.dataTransfer?.files?.[0];
+  if (!file || !file.type.startsWith("image/")) {
+    setStatus("Please drop an image file.", "error");
+    return;
+  }
+  try {
+    await loadImage(file);
+  } catch (error) {
+    setStatus(error.message, "error");
+  }
+});
+
+try {
+  setStatus("Loading Ember model...", "loading");
+  await detector.load("./weights.onnx");
+  setStatus("Ember ready. Upload a scene or load the example.", "ready");
+} catch (error) {
+  console.error(error);
+  setStatus("Failed to load model. Check that weights.onnx is available.", "error");
+}

requirements.txt

@@ -0,0 +1,4 @@
+onnxruntime
+opencv-python-headless
+numpy
+pydantic

style.css

@@ -0,0 +1,826 @@
+:root {
+  --brand: #1565ff;
+  --brand-dark: #001530;
+  --brand-soft: #e8f0ff;
+  --bg: #ffffff;
+  --bg-muted: #f6f8fc;
+  --bg-dark: #001530;
+  --surface: #ffffff;
+  --border: #e2e8f0;
+  --border-strong: #c7d7f5;
+  --text: #0f172a;
+  --text-secondary: #475569;
+  --text-muted: #64748b;
+  --success: #059669;
+  --warning: #d97706;
+  --danger: #dc2626;
+  --shadow-sm: 0 1px 2px rgba(15, 23, 42, 0.05);
+  --shadow: 0 12px 40px rgba(15, 23, 42, 0.08);
+  --shadow-lg: 0 24px 60px rgba(21, 101, 255, 0.12);
+  --radius: 16px;
+  --radius-sm: 10px;
+  --container: 1120px;
+}
+
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+}
+
+html {
+  scroll-behavior: smooth;
+}
+
+body {
+  margin: 0;
+  font-family: Inter, system-ui, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  -webkit-font-smoothing: antialiased;
+}
+
+img {
+  display: block;
+  max-width: 100%;
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+}
+
+.container {
+  width: min(var(--container), calc(100% - 2rem));
+  margin: 0 auto;
+}
+
+.site-header {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  background: rgba(255, 255, 255, 0.9);
+  backdrop-filter: blur(12px);
+  border-bottom: 1px solid var(--border);
+}
+
+.header-inner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  min-height: 72px;
+}
+
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+}
+
+.brand-logo {
+  border-radius: 10px;
+  box-shadow: var(--shadow-sm);
+}
+
+.brand-text {
+  display: flex;
+  flex-direction: column;
+  line-height: 1.15;
+}
+
+.brand-text strong {
+  font-size: 0.98rem;
+  font-weight: 700;
+  color: var(--brand-dark);
+}
+
+.brand-text small {
+  font-size: 0.78rem;
+  color: var(--text-muted);
+  font-weight: 500;
+}
+
+.nav {
+  display: flex;
+  align-items: center;
+  gap: 1.5rem;
+  font-size: 0.92rem;
+  font-weight: 500;
+}
+
+.nav a {
+  color: var(--text-secondary);
+  transition: color 0.15s ease;
+}
+
+.nav a:hover {
+  color: var(--brand);
+}
+
+.nav-cta {
+  padding: 0.55rem 1rem;
+  border-radius: 999px;
+  background: var(--brand);
+  color: #fff !important;
+}
+
+.nav-cta:hover {
+  background: #0d52d9;
+  color: #fff !important;
+}
+
+.eyebrow {
+  margin: 0 0 0.65rem;
+  color: var(--brand);
+  font-size: 0.78rem;
+  font-weight: 600;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+}
+
+.hero {
+  padding: 4.5rem 0 3.5rem;
+  background:
+    radial-gradient(circle at top right, rgba(21, 101, 255, 0.08), transparent 34%),
+    linear-gradient(180deg, #fff, #f8fbff);
+}
+
+.hero-grid {
+  display: grid;
+  grid-template-columns: 1fr 1.05fr;
+  gap: 3rem;
+  align-items: center;
+}
+
+.hero-copy h1 {
+  margin: 0 0 1rem;
+  font-size: clamp(2.3rem, 4.8vw, 3.6rem);
+  line-height: 1.08;
+  letter-spacing: -0.03em;
+  color: var(--brand-dark);
+}
+
+.accent-text {
+  color: var(--brand);
+}
+
+.hero-lead {
+  margin: 0 0 1.5rem;
+  max-width: 34rem;
+  color: var(--text-secondary);
+  font-size: 1.05rem;
+}
+
+.hero-actions,
+.demo-actions,
+.cta-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.75rem;
+}
+
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.78rem 1.15rem;
+  border-radius: 10px;
+  border: 1px solid transparent;
+  font: inherit;
+  font-size: 0.92rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition:
+    background 0.15s ease,
+    border-color 0.15s ease,
+    transform 0.15s ease;
+}
+
+.btn:hover {
+  transform: translateY(-1px);
+}
+
+.btn:disabled {
+  opacity: 0.45;
+  cursor: not-allowed;
+  transform: none;
+}
+
+.btn-primary {
+  background: var(--brand);
+  color: #fff;
+  box-shadow: var(--shadow-lg);
+}
+
+.btn-primary:hover {
+  background: #0d52d9;
+}
+
+.btn-secondary {
+  background: #fff;
+  color: var(--brand-dark);
+  border-color: var(--border);
+}
+
+.btn-secondary:hover {
+  border-color: var(--border-strong);
+  background: var(--bg-muted);
+}
+
+.hero-stats {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 1rem;
+  margin: 2rem 0 0;
+  padding: 0;
+}
+
+.hero-stats div {
+  padding: 1rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: #fff;
+}
+
+.hero-stats dt {
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 0.78rem;
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+}
+
+.hero-stats dd {
+  margin: 0.2rem 0 0;
+  font-size: 1.35rem;
+  font-weight: 700;
+  color: var(--brand-dark);
+}
+
+.hero-visual-card {
+  border: 1px solid var(--border);
+  border-radius: calc(var(--radius) + 4px);
+  overflow: hidden;
+  background: #fff;
+  box-shadow: var(--shadow);
+}
+
+.hero-image {
+  width: 100%;
+  aspect-ratio: 16 / 10;
+  object-fit: cover;
+}
+
+.hero-visual-caption {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+  padding: 0.85rem 1rem;
+  border-top: 1px solid var(--border);
+  font-size: 0.86rem;
+  color: var(--text-secondary);
+}
+
+.pill {
+  display: inline-flex;
+  align-items: center;
+  padding: 0.25rem 0.55rem;
+  border-radius: 999px;
+  font-size: 0.72rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+}
+
+.pill--live {
+  background: #dcfce7;
+  color: #166534;
+}
+
+.section {
+  padding: 4.5rem 0;
+}
+
+.section--muted {
+  background: var(--bg-muted);
+}
+
+.section-head {
+  max-width: 680px;
+  margin-bottom: 2.25rem;
+}
+
+.section-head--center {
+  margin-inline: auto;
+  text-align: center;
+}
+
+.section-head h2 {
+  margin: 0 0 0.75rem;
+  font-size: clamp(1.7rem, 3vw, 2.35rem);
+  letter-spacing: -0.03em;
+  color: var(--brand-dark);
+}
+
+.section-lead {
+  margin: 0;
+  color: var(--text-secondary);
+}
+
+.compare-grid {
+  display: grid;
+  grid-template-columns: 1fr auto 1fr;
+  gap: 1rem;
+  align-items: center;
+}
+
+.compare-card {
+  margin: 0;
+}
+
+.compare-card figcaption {
+  display: flex;
+  align-items: baseline;
+  justify-content: space-between;
+  gap: 0.5rem;
+  margin-bottom: 0.65rem;
+}
+
+.compare-label {
+  font-size: 0.92rem;
+  font-weight: 600;
+  color: var(--brand-dark);
+}
+
+.compare-meta {
+  font-size: 0.8rem;
+  color: var(--text-muted);
+}
+
+.compare-frame {
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  overflow: hidden;
+  background: #fff;
+  box-shadow: var(--shadow-sm);
+}
+
+.compare-frame img {
+  width: 100%;
+  aspect-ratio: 16 / 10;
+  object-fit: cover;
+}
+
+.compare-card--highlight .compare-frame {
+  border-color: var(--border-strong);
+  box-shadow: var(--shadow);
+}
+
+.compare-arrow {
+  display: grid;
+  place-items: center;
+  width: 40px;
+  height: 40px;
+  border-radius: 50%;
+  background: var(--brand-soft);
+  color: var(--brand);
+}
+
+.performance-notes {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 1rem;
+  margin-top: 2rem;
+}
+
+.note-card {
+  padding: 1.2rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: #fff;
+}
+
+.note-card h3 {
+  margin: 0 0 0.45rem;
+  font-size: 1rem;
+  color: var(--brand-dark);
+}
+
+.note-card p {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 0.92rem;
+}
+
+.feature-grid,
+.usecase-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 1rem;
+}
+
+.feature-card,
+.usecase-card {
+  padding: 1.35rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: #fff;
+}
+
+.feature-icon {
+  width: 40px;
+  height: 40px;
+  display: grid;
+  place-items: center;
+  margin-bottom: 0.85rem;
+  border-radius: 10px;
+  background: var(--brand-soft);
+  color: var(--brand);
+}
+
+.feature-icon svg {
+  width: 20px;
+  height: 20px;
+}
+
+.feature-card h3,
+.usecase-card h3 {
+  margin: 0 0 0.45rem;
+  font-size: 1.05rem;
+  color: var(--brand-dark);
+}
+
+.feature-card p,
+.usecase-card p {
+  margin: 0;
+  color: var(--text-secondary);
+  font-size: 0.94rem;
+}
+
+.usecase-tag {
+  display: inline-block;
+  margin-bottom: 0.65rem;
+  padding: 0.22rem 0.55rem;
+  border-radius: 999px;
+  background: var(--brand-soft);
+  color: var(--brand);
+  font-size: 0.72rem;
+  font-weight: 600;
+  letter-spacing: 0.05em;
+  text-transform: uppercase;
+}
+
+.demo-shell {
+  padding: 1.25rem;
+  border: 1px solid var(--border);
+  border-radius: calc(var(--radius) + 2px);
+  background: #fff;
+  box-shadow: var(--shadow);
+}
+
+.demo-toolbar {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.demo-status {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  color: var(--text-secondary);
+  font-size: 0.92rem;
+}
+
+.status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--text-muted);
+}
+
+.status-dot--loading {
+  background: var(--warning);
+  animation: pulse 1.4s ease infinite;
+}
+
+.status-dot--ready {
+  background: var(--success);
+}
+
+.status-dot--error {
+  background: var(--danger);
+}
+
+@keyframes pulse {
+  50% {
+    opacity: 0.4;
+  }
+}
+
+.demo-metrics {
+  display: flex;
+  gap: 0.65rem;
+}
+
+.metric-pill {
+  min-width: 88px;
+  padding: 0.5rem 0.75rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: var(--bg-muted);
+}
+
+.metric-pill-label {
+  display: block;
+  font-size: 0.68rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
+}
+
+.metric-pill-value {
+  display: block;
+  font-size: 1.05rem;
+  font-weight: 700;
+  color: var(--brand-dark);
+}
+
+.dropzone {
+  display: block;
+  margin-bottom: 1rem;
+  border: 1.5px dashed var(--border-strong);
+  border-radius: var(--radius);
+  background: var(--bg-muted);
+  cursor: pointer;
+  transition:
+    border-color 0.15s ease,
+    background 0.15s ease;
+}
+
+.dropzone:hover,
+.dropzone.is-dragover {
+  border-color: var(--brand);
+  background: var(--brand-soft);
+}
+
+.dropzone-inner {
+  padding: 1.6rem 1rem;
+  text-align: center;
+}
+
+.dropzone-icon {
+  width: 44px;
+  height: 44px;
+  margin: 0 auto 0.75rem;
+  display: grid;
+  place-items: center;
+  border-radius: 12px;
+  background: #fff;
+  color: var(--brand);
+  border: 1px solid var(--border);
+}
+
+.dropzone-icon svg {
+  width: 22px;
+  height: 22px;
+}
+
+.dropzone p {
+  margin: 0;
+}
+
+.dropzone-hint {
+  margin-top: 0.35rem !important;
+  color: var(--text-muted);
+  font-size: 0.86rem;
+}
+
+.canvas-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 1rem;
+}
+
+.canvas-card {
+  margin: 0;
+}
+
+.canvas-card figcaption {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+  margin-bottom: 0.5rem;
+  font-size: 0.88rem;
+  font-weight: 600;
+  color: var(--brand-dark);
+}
+
+.canvas-card--highlight figcaption {
+  color: var(--brand);
+}
+
+.canvas-frame {
+  position: relative;
+  min-height: 220px;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+  background: #f1f5f9;
+}
+
+.canvas-frame canvas {
+  display: none;
+  width: 100%;
+  height: auto;
+}
+
+.canvas-frame.has-image canvas {
+  display: block;
+}
+
+.canvas-frame.has-image .canvas-placeholder {
+  display: none;
+}
+
+.canvas-placeholder {
+  position: absolute;
+  inset: 0;
+  display: grid;
+  place-items: center;
+  color: var(--text-muted);
+  font-size: 0.9rem;
+}
+
+.output-badge {
+  padding: 0.18rem 0.5rem;
+  border-radius: 999px;
+  background: var(--brand-soft);
+  color: var(--brand);
+  font-size: 0.72rem;
+}
+
+.output-badge.hidden {
+  display: none;
+}
+
+.json-panel {
+  margin-top: 1rem;
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  background: var(--bg-muted);
+}
+
+.json-panel summary {
+  padding: 0.8rem 1rem;
+  cursor: pointer;
+  color: var(--text-secondary);
+  font-size: 0.88rem;
+  font-weight: 500;
+}
+
+.json-panel pre {
+  margin: 0;
+  padding: 0 1rem 1rem;
+  max-height: 260px;
+  overflow: auto;
+  font-family: "JetBrains Mono", monospace;
+  font-size: 0.78rem;
+  color: var(--text-secondary);
+}
+
+.cta-section {
+  padding: 1rem 0 4rem;
+}
+
+.cta-card {
+  display: grid;
+  grid-template-columns: auto 1fr auto;
+  gap: 1.25rem;
+  align-items: center;
+  padding: 1.75rem;
+  border-radius: calc(var(--radius) + 4px);
+  background: var(--brand-dark);
+  color: #fff;
+}
+
+.cta-logo {
+  border-radius: 12px;
+}
+
+.cta-copy h2 {
+  margin: 0 0 0.35rem;
+  font-size: clamp(1.35rem, 2.5vw, 1.8rem);
+}
+
+.cta-copy p {
+  margin: 0;
+  color: #cbd5e1;
+  max-width: 38rem;
+  font-size: 0.95rem;
+}
+
+.cta-card .btn-primary {
+  background: #fff;
+  color: var(--brand-dark);
+  box-shadow: none;
+}
+
+.cta-card .btn-primary:hover {
+  background: var(--brand-soft);
+}
+
+.cta-card .btn-secondary {
+  background: transparent;
+  color: #fff;
+  border-color: rgba(255, 255, 255, 0.25);
+}
+
+.cta-card .btn-secondary:hover {
+  background: rgba(255, 255, 255, 0.08);
+}
+
+.site-footer {
+  border-top: 1px solid var(--border);
+  padding: 1.25rem 0 2rem;
+  background: #fff;
+}
+
+.footer-inner {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+}
+
+.footer-brand {
+  display: flex;
+  align-items: center;
+  gap: 0.55rem;
+  color: var(--text-secondary);
+  font-size: 0.88rem;
+  font-weight: 500;
+}
+
+.footer-note {
+  margin: 0;
+  color: var(--text-muted);
+  font-size: 0.84rem;
+}
+
+@media (max-width: 960px) {
+  .hero-grid,
+  .feature-grid,
+  .usecase-grid,
+  .canvas-grid,
+  .performance-notes {
+    grid-template-columns: 1fr;
+  }
+
+  .compare-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .compare-arrow {
+    margin: 0 auto;
+    transform: rotate(90deg);
+  }
+
+  .cta-card {
+    grid-template-columns: 1fr;
+    text-align: center;
+  }
+
+  .cta-actions {
+    justify-content: center;
+  }
+
+  .nav a:not(.nav-cta) {
+    display: none;
+  }
+}
+
+@media (max-width: 560px) {
+  .hero {
+    padding-top: 3rem;
+  }
+
+  .hero-stats {
+    grid-template-columns: 1fr;
+  }
+
+  .demo-toolbar {
+    flex-direction: column;
+    align-items: flex-start;
+  }
+}

weights.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:695ac2b54dc6bbc9c2440c8e802befba096b54497e29017e69b9a0de4dc634b5
+size 9806770