@camstack/addon-pipeline 1.2.333 → 1.2.334

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline",
-  "version": "1.2.333",
+  "version": "1.2.334",
   "description": "Pipeline bundle — runner, detection, motion, audio + stream broker. Multi-entry npm package shipping pipeline addons under a single bundle.",
   "keywords": [
     "camstack",

package/python/postprocessors/test_yolo_seg_root.py

@@ -0,0 +1,109 @@
+"""D737 — a YOLO26-seg ROOT decodes its boxes exactly like the plain detector
+and keeps one mask per kept detection.
+
+Run like the other postprocessor tests:
+``PYTHONPATH=postprocessors:. python -m pytest postprocessors/`` from
+``packages/addon-pipeline/python``.
+"""
+import base64
+
+import numpy as np
+
+from postprocessors.yolo import postprocess_yolo
+from postprocessors.yolo_seg import postprocess_yolo_seg
+
+LABELS = ["person", "car", "dog"]
+CONFIG = {"labels": LABELS, "numClasses": 3, "confidence": 0.3, "inputSize": 64}
+# A 1280x720 frame letterboxed into 64: scale 0.05, vertical pad 14.
+ORIG_W, ORIG_H, SCALE, PAD = 1280, 720, 0.05, (0, 14)
+PROTO = 16  # P x P prototype grid at the 64 input (4 px per cell)
+
+
+def _protos(rng: np.random.Generator) -> np.ndarray:
+    return rng.normal(size=(1, 32, PROTO, PROTO)).astype(np.float32)
+
+
+def _post_nms_rows(rng: np.random.Generator) -> np.ndarray:
+    """[1, 6, 38]: two overlapping persons (the end-to-end head keeps both),
+    a car, one row under the floor and two padding rows (class -1)."""
+    boxes = [
+        [8, 20, 24, 44, 0.91, 0],
+        [10, 22, 26, 46, 0.80, 0],
+        [30, 30, 56, 48, 0.66, 1],
+        [40, 18, 50, 28, 0.10, 2],
+        [0, 0, 0, 0, 0.0, -1],
+        [0, 0, 0, 0, 0.0, -1],
+    ]
+    coeffs = rng.normal(size=(len(boxes), 32))
+    return np.concatenate([np.array(boxes, dtype=np.float32), coeffs], axis=1)[None].astype(np.float32)
+
+
+def _raw_head(rng: np.random.Generator) -> np.ndarray:
+    """[1, 4 + 3 + 32, 5] with LOGIT scores (YOLO26 raw), two overlapping."""
+    cxcywh = np.array(
+        [[16, 32, 16, 24], [18, 34, 16, 24], [43, 39, 26, 18], [45, 23, 10, 10], [5, 5, 4, 4]],
+        dtype=np.float32,
+    ).T
+    logits = np.array(
+        [[3.0, 2.0, -4, -4, -6], [-4, -4, 1.5, -4, -6], [-4, -4, -4, -2.0, -6]], dtype=np.float32
+    )
+    coeffs = rng.normal(size=(32, 5)).astype(np.float32)
+    return np.concatenate([cxcywh, logits, coeffs], axis=0)[None]
+
+
+def _boxes(out: dict) -> list[tuple]:
+    return [(d["class"], d["score"], tuple(d["bbox"])) for d in out["detections"]]
+
+
+def test_post_nms_head_boxes_equal_the_plain_detectors():
+    rng = np.random.default_rng(1)
+    rows = _post_nms_rows(rng)
+    plain = postprocess_yolo({"output0": rows[..., :6].copy()}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": rows, "output1": _protos(rng)}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    # The plain detector does not NMS an end-to-end head; neither does the seg root.
+    assert len(seg["detections"]) == 3
+
+
+def test_raw_head_boxes_equal_the_plain_detectors():
+    rng = np.random.default_rng(2)
+    head = _raw_head(rng)
+    plain = postprocess_yolo({"output0": head[:, :7, :].copy()}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": head.copy(), "output1": _protos(rng)}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    assert len(seg["detections"]) == 2  # the overlap is suppressed, the floor drops two
+
+
+def test_same_nms_iou_knob_as_the_plain_detector():
+    rng = np.random.default_rng(3)
+    head = _raw_head(rng)
+    loose = dict(CONFIG, nmsIouThreshold=0.95)
+    plain = postprocess_yolo({"output0": head[:, :7, :].copy()}, loose, ORIG_W, ORIG_H, SCALE, PAD)
+    seg = postprocess_yolo_seg(
+        {"output0": head.copy(), "output1": _protos(rng)}, loose, ORIG_W, ORIG_H, SCALE, PAD
+    )
+    assert _boxes(seg) == _boxes(plain)
+    assert len(seg["detections"]) == 3
+
+
+def test_every_kept_detection_carries_its_own_mask_over_its_box():
+    rng = np.random.default_rng(4)
+    rows = _post_nms_rows(rng)
+    protos = _protos(rng)
+    out = postprocess_yolo_seg({"output0": rows, "output1": protos}, dict(CONFIG), ORIG_W, ORIG_H, SCALE, PAD)
+    first = out["detections"][0]
+    # Box [8,20,24,44] in the 64 input → proto cells [2,5,6,11] → 4 x 6.
+    assert (first["maskWidth"], first["maskHeight"]) == (4, 6)
+    raw = np.frombuffer(base64.b64decode(first["mask"]), dtype=np.uint8)
+    assert raw.size == 4 * 6
+    assert set(np.unique(raw)) <= {0, 255}
+    # The mask IS sigmoid(coeffs @ protos) > 0.5 over that window, for this row.
+    logits = rows[0, 0, 6:] @ protos[0][:, 5:11, 2:6].reshape(32, -1)
+    expected = ((1 / (1 + np.exp(-logits))) > 0.5).astype(np.uint8) * 255
+    assert np.array_equal(raw, expected)
+    # Different rows → different coefficient vectors → masks are per instance.
+    assert out["detections"][1]["mask"] != first["mask"]

package/python/postprocessors/yolo.py

@@ -180,12 +180,28 @@ def _postprocess_yolo11_nms(
 
     Coordinates are in input pixel space (0..inputSize). Already post-NMS.
     """
+    rows = decode_yolo11_nms_rows(output, config, orig_w, orig_h, scale, pad)
+    return {"kind": "detections", "detections": [d for _, d in rows]}
+
+
+def decode_yolo11_nms_rows(
+    output: np.ndarray,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> list[tuple[int, dict]]:
+    """The post-NMS box decode, each kept detection paired with its ROW in
+    ``output``. Only the first 6 columns are read, so a seg head's
+    ``[N, 6 + 32]`` rows decode exactly like the plain detector's ``[N, 6]``
+    (D737) and the row index finds the detection's mask coefficients."""
     conf_threshold = float(config.get("confidence", 0))
     labels = config.get("labels", COCO_80)
 
-    detections = []
+    detections: list[tuple[int, dict]] = []
     for i in range(output.shape[0]):
-        x1, y1, x2, y2, score, class_id = output[i]
+        x1, y1, x2, y2, score, class_id = output[i][:6]
         score = float(score)
         if score < conf_threshold:
             continue
@@ -200,13 +216,13 @@ def _postprocess_yolo11_nms(
         oy2 = max(0, min(orig_h, (float(y2) - pad[1]) / scale))
 
         label = labels[class_id] if class_id < len(labels) else str(class_id)
-        detections.append({
+        detections.append((i, {
             "class": label,
             "score": round(score, 4),
             "bbox": [round(ox1, 1), round(oy1, 1), round(ox2, 1), round(oy2, 1)],
-        })
+        }))
 
-    return {"kind": "detections", "detections": detections}
+    return detections
 
 
 def postprocess_yolo(
@@ -223,12 +239,8 @@ def postprocess_yolo(
     1. Raw tensor (ONNX/OpenVINO): [4+numClasses, numBoxes] — needs NMS
     2. CoreML built-in NMS: 'confidence' + 'coordinates' tensors — already post-NMS
     """
-    conf_threshold = float(config.get("confidence", 0))
     labels = config.get("labels", COCO_80)
     num_classes = config.get("numClasses", len(labels))
-    # NMS IoU from the step config (operator slider); the 0.45 literal stays as
-    # the fallback so an unset value is byte-identical to today (#4).
-    nms_iou = float(config.get("nmsIouThreshold", 0.45))
 
     yolox = yolox_head_to_v8(predictions, int(config.get("inputSize", 640)))
     if yolox is not None:
@@ -272,6 +284,31 @@ def postprocess_yolo(
         else:
             output = output.T
 
+    rows = decode_raw_yolo_columns(output, config, orig_w, orig_h, scale, pad)
+    return {"kind": "detections", "detections": [d for _, d in rows]}
+
+
+def decode_raw_yolo_columns(
+    output: np.ndarray,
+    config: dict,
+    orig_w: int,
+    orig_h: int,
+    scale: float,
+    pad: tuple[int, int],
+) -> list[tuple[int, dict]]:
+    """The raw-head box decode (``[4 + numClasses (+ extra), numBoxes]``, one
+    COLUMN per candidate): sigmoid when the scores are logits, confidence
+    floor, NMS. Each kept detection is paired with its column in ``output``.
+    Rows past ``4 + numClasses`` are never read, so a seg head's mask
+    coefficients ride along untouched and decode exactly like the plain
+    detector (D737). May apply the sigmoid IN PLACE on the class rows."""
+    conf_threshold = float(config.get("confidence", 0))
+    labels = config.get("labels", COCO_80)
+    num_classes = config.get("numClasses", len(labels))
+    # NMS IoU from the step config (operator slider); the 0.45 literal stays as
+    # the fallback so an unset value is byte-identical to today (#4).
+    nms_iou = float(config.get("nmsIouThreshold", 0.45))
+
     num_boxes = output.shape[1]
 
     # Detect if scores are raw logits (YOLO11/v26) vs sigmoid-activated (YOLOv8/v9).
@@ -290,7 +327,7 @@ def postprocess_yolo(
     best_scores = class_scores[best_classes, np.arange(num_boxes)]  # (N,)
     mask = best_scores >= conf_threshold
     if not np.any(mask):
-        return {"kind": "detections", "detections": []}
+        return []
 
     # Gather only above-threshold boxes
     idxs = np.nonzero(mask)[0]
@@ -315,11 +352,13 @@ def postprocess_yolo(
             "score": round(float(sc[k]), 4),
             "bbox": [round(float(x1[k]), 1), round(float(y1[k]), 1), round(float(x2[k]), 1), round(float(y2[k]), 1)],
             "_xyxy": (float(x1[k]), float(y1[k]), float(x2[k]), float(y2[k])),
+            "_col": int(idxs[k]),
         })
 
     kept = _nms(candidates, nms_iou)
-    # Remove internal _xyxy field
+    # Remove the internal fields; the column travels beside the detection.
+    out: list[tuple[int, dict]] = []
     for d in kept:
         del d["_xyxy"]
-
-    return {"kind": "detections", "detections": kept}
+        out.append((d.pop("_col"), d))
+    return out

package/python/postprocessors/yolo_seg.py

@@ -1,95 +1,66 @@
 """YOLO-seg postprocessor (YOLO26-seg instance segmentation).
 
 Input: raw predictions dict with two outputs:
-  - output0: [1, 300, 38] — 300 NMS-filtered detections, each [x1,y1,x2,y2,conf,class_id,coeff_0..coeff_31]
-  - output1: [1, 32, 160, 160] — 32 prototype masks at 160x160
-
-For raw (no NMS) models:
-  - output0: [1, 4+numClasses+32, numBoxes] — standard YOLO format with mask coefficients appended
-
-Output: {"kind": "detections", "detections": [{..., "mask": "<b64>", "maskWidth": N, "maskHeight": N}]}
+  - detections: post-NMS ``[1, 300, 6 + 32]`` rows
+    ``[x1, y1, x2, y2, conf, class_id, coeff_0..coeff_31]``, or a raw head
+    ``[1, 4 + numClasses + 32, numBoxes]`` (one column per candidate)
+  - prototypes: ``[1, 32, P, P]`` (P = 160 at a 640 input)
+
+Output: ``{"kind": "detections", "detections": [{..., "mask": "<b64>",
+"maskWidth": N, "maskHeight": N}]}`` — the mask is the detection's box region
+of the prototype grid, thresholded to 0/255 bytes, row-major, base64.
+
+The BOXES are decoded by the plain detector's own functions
+(``yolo.decode_yolo11_nms_rows`` / ``yolo.decode_raw_yolo_columns``): same
+confidence floor, same sigmoid detection, same NMS (and none on a post-NMS
+head, exactly like ``yolo``), same letterbox inversion and rounding. A seg
+model chosen as the camera ROOT therefore produces the detections a plain
+detector would from the same tensors, plus a mask on each (D737). Masks are
+computed only for the detections that survive, and only over their box.
 """
 import base64
 
 import numpy as np
 
-
-COCO_80 = [
-    "person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck",
-    "boat", "traffic light", "fire hydrant", "stop sign", "parking meter", "bench",
-    "bird", "cat", "dog", "horse", "sheep", "cow", "elephant", "bear", "zebra",
-    "giraffe", "backpack", "umbrella", "handbag", "tie", "suitcase", "frisbee",
-    "skis", "snowboard", "sports ball", "kite", "baseball bat", "baseball glove",
-    "skateboard", "surfboard", "tennis racket", "bottle", "wine glass", "cup",
-    "fork", "knife", "spoon", "bowl", "banana", "apple", "sandwich", "orange",
-    "broccoli", "carrot", "hot dog", "pizza", "donut", "cake", "chair", "couch",
-    "potted plant", "bed", "dining table", "toilet", "tv", "laptop", "mouse",
-    "remote", "keyboard", "cell phone", "microwave", "oven", "toaster", "sink",
-    "refrigerator", "book", "clock", "vase", "scissors", "teddy bear", "hair drier",
-    "toothbrush",
-]
+from .yolo import COCO_80, decode_raw_yolo_columns, decode_yolo11_nms_rows
 
 NUM_MASK_COEFFS = 32
 PROTO_SIZE = 160
 
 
-def _iou(a: tuple, b: tuple) -> float:
-    """IoU between two boxes (x1, y1, x2, y2)."""
-    ax1, ay1, ax2, ay2 = a
-    bx1, by1, bx2, by2 = b
-    ix1 = max(ax1, bx1)
-    iy1 = max(ay1, by1)
-    ix2 = min(ax2, bx2)
-    iy2 = min(ay2, by2)
-    inter = max(0, ix2 - ix1) * max(0, iy2 - iy1)
-    if inter == 0:
-        return 0.0
-    area_a = (ax2 - ax1) * (ay2 - ay1)
-    area_b = (bx2 - bx1) * (by2 - by1)
-    union = area_a + area_b - inter
-    return inter / union if union > 0 else 0.0
-
-
-def _nms(boxes: list[dict], iou_threshold: float = 0.45) -> list[dict]:
-    """Non-maximum suppression. Input: list of dicts with _xyxy, score, class."""
-    if not boxes:
-        return []
-    sorted_boxes = sorted(boxes, key=lambda b: b["score"], reverse=True)
-    kept = []
-    suppressed = set()
-    for i, box in enumerate(sorted_boxes):
-        if i in suppressed:
-            continue
-        kept.append(box)
-        for j in range(i + 1, len(sorted_boxes)):
-            if j in suppressed:
-                continue
-            if _iou(box["_xyxy"], sorted_boxes[j]["_xyxy"]) > iou_threshold:
-                suppressed.add(j)
-    return kept
-
-
 def _sigmoid(x: np.ndarray) -> np.ndarray:
     """Numerically stable sigmoid."""
     return np.where(x >= 0, 1 / (1 + np.exp(-x)), np.exp(x) / (1 + np.exp(x)))
 
 
+def _as_prototypes(arr: np.ndarray) -> np.ndarray | None:
+    """``[32, P, P]`` when ``arr`` is a prototype tensor, else ``None``."""
+    squeezed = arr
+    while squeezed.ndim > 3 and squeezed.shape[0] == 1:
+        squeezed = squeezed[0]
+    if squeezed.ndim == 3 and squeezed.shape[0] == NUM_MASK_COEFFS and squeezed.shape[1] == squeezed.shape[2]:
+        return squeezed
+    if arr.size == NUM_MASK_COEFFS * PROTO_SIZE * PROTO_SIZE:
+        return arr.reshape(NUM_MASK_COEFFS, PROTO_SIZE, PROTO_SIZE)
+    return None
+
+
 def _find_tensors(predictions: dict, num_classes: int) -> tuple[np.ndarray, np.ndarray]:
     """Locate the detection tensor and prototype tensor from model outputs.
 
     Returns (detections, prototypes) as numpy arrays.
     detections: [num_dets, channels] row-major
-    prototypes: [32, 160, 160]
+    prototypes: [32, P, P]
     """
     det_tensor = None
     proto_tensor = None
 
-    for key, val in predictions.items():
+    for _key, val in predictions.items():
         arr = np.array(val, dtype=np.float32)
 
-        # Prototype: shape containing 32 * 160 * 160 = 819200
-        if arr.size == NUM_MASK_COEFFS * PROTO_SIZE * PROTO_SIZE:
-            proto_tensor = arr.reshape(NUM_MASK_COEFFS, PROTO_SIZE, PROTO_SIZE)
+        protos = _as_prototypes(arr)
+        if protos is not None and proto_tensor is None:
+            proto_tensor = protos
             continue
 
         # Skip tiny tensors
@@ -128,28 +99,36 @@ def _find_tensors(predictions: dict, num_classes: int) -> tuple[np.ndarray, np.n
     return det_tensor, proto_tensor
 
 
-def _crop_mask_to_bbox(
-    mask_full: np.ndarray,
-    x1: float,
-    y1: float,
-    x2: float,
-    y2: float,
+def _instance_mask(
+    coeffs: np.ndarray,
+    protos: np.ndarray,
+    bbox: list[float],
+    scale: float,
+    pad: tuple[int, int],
     input_size: int,
-    mask_threshold: float = 0.5,
-) -> tuple[np.ndarray, int, int]:
-    """Crop sigmoid mask to bbox region, threshold to binary, return (binary, w, h)."""
-    proto_scale = PROTO_SIZE / input_size
-    px1 = max(0, int(np.floor(x1 * proto_scale)))
-    py1 = max(0, int(np.floor(y1 * proto_scale)))
-    px2 = min(PROTO_SIZE, int(np.ceil(x2 * proto_scale)))
-    py2 = min(PROTO_SIZE, int(np.ceil(y2 * proto_scale)))
-
+    mask_threshold: float,
+) -> tuple[str, int, int]:
+    """The detection's mask over its OWN box: the emitted (original-image)
+    bbox mapped back into the letterboxed input, then onto the prototype grid.
+    Only that window of ``coeffs @ protos`` is computed."""
+    proto_size = protos.shape[-1]
+    proto_scale = proto_size / input_size
+    ox1, oy1, ox2, oy2 = bbox
+    px1 = max(0, int(np.floor((ox1 * scale + pad[0]) * proto_scale)))
+    py1 = max(0, int(np.floor((oy1 * scale + pad[1]) * proto_scale)))
+    px2 = min(proto_size, int(np.ceil((ox2 * scale + pad[0]) * proto_scale)))
+    py2 = min(proto_size, int(np.ceil((oy2 * scale + pad[1]) * proto_scale)))
     crop_w = max(1, px2 - px1)
     crop_h = max(1, py2 - py1)
-
-    cropped = mask_full[py1:py1 + crop_h, px1:px1 + crop_w]
-    binary = (cropped > mask_threshold).astype(np.uint8) * 255
-    return binary, crop_w, crop_h
+    window = protos[:, py1:py1 + crop_h, px1:px1 + crop_w]
+    h, w = window.shape[1], window.shape[2]
+    if h == 0 or w == 0:
+        binary = np.zeros((crop_h, crop_w), dtype=np.uint8)
+    else:
+        logits = coeffs.astype(np.float32) @ window.reshape(NUM_MASK_COEFFS, -1)
+        binary = (_sigmoid(logits.reshape(h, w)) > mask_threshold).astype(np.uint8) * 255
+        crop_h, crop_w = h, w
+    return base64.b64encode(binary.tobytes()).decode("ascii"), crop_w, crop_h
 
 
 def postprocess_yolo_seg(
@@ -166,85 +145,29 @@ def postprocess_yolo_seg(
     1. NMS-enabled export: [N, 6+32] with [x1,y1,x2,y2,conf,class_id,...coeffs]
     2. Raw export: [4+numClasses+32, N] standard YOLO transposed format
     """
-    conf_threshold = float(config.get("confidence", 0))
     labels = config.get("labels", COCO_80)
     num_classes = config.get("numClasses", len(labels))
-    input_size = config.get("inputSize", 640)
-    mask_threshold = config.get("maskThreshold", 0.5)
-    # NMS IoU from the step config (operator slider); the 0.45 literal stays as
-    # the fallback so an unset value is byte-identical to today (#4).
-    nms_iou = float(config.get("nmsIouThreshold", 0.45))
+    input_size = int(config.get("inputSize", 640))
+    mask_threshold = float(config.get("maskThreshold", 0.5))
 
     det_tensor, proto_tensor = _find_tensors(predictions, num_classes)
 
-    num_dets = det_tensor.shape[0]
-    num_cols = det_tensor.shape[1]
-    is_nms_format = num_cols == 6 + NUM_MASK_COEFFS
-
-    candidates = []
-
-    for i in range(num_dets):
-        row = det_tensor[i]
-
-        if is_nms_format:
-            # [x1, y1, x2, y2, confidence, class_id, coeff_0..coeff_31]
-            x1, y1, x2, y2 = float(row[0]), float(row[1]), float(row[2]), float(row[3])
-            best_score = float(row[4])
-            best_class = int(row[5])
-            coeffs = row[6:6 + NUM_MASK_COEFFS]
-
-            if best_score < conf_threshold:
-                continue
-            if best_class < 0:
-                continue  # padding row
-        else:
-            # [cx, cy, w, h, class_scores..., coeff_0..coeff_31]
-            cx, cy, w, h = float(row[0]), float(row[1]), float(row[2]), float(row[3])
-            class_scores = row[4:4 + num_classes]
-            best_class = int(np.argmax(class_scores))
-            best_score = float(class_scores[best_class])
-            coeffs = row[4 + num_classes:4 + num_classes + NUM_MASK_COEFFS]
-
-            if best_score < conf_threshold:
-                continue
-
-            x1 = cx - w / 2
-            y1 = cy - h / 2
-            x2 = cx + w / 2
-            y2 = cy + h / 2
-
-        # Compute instance mask: sigmoid(coefficients @ prototypes)
-        # coeffs: [32], proto_tensor: [32, 160, 160]
-        mask_raw = _sigmoid(coeffs @ proto_tensor.reshape(NUM_MASK_COEFFS, -1)).reshape(
-            PROTO_SIZE, PROTO_SIZE
+    if det_tensor.shape[1] == 6 + NUM_MASK_COEFFS:
+        kept = decode_yolo11_nms_rows(det_tensor, config, orig_w, orig_h, scale, pad)
+        coeffs = det_tensor[:, 6:6 + NUM_MASK_COEFFS]
+    else:
+        # The raw decode reads [C, N] and may sigmoid its class rows in place:
+        # hand it its own copy so the coefficients below stay untouched.
+        kept = decode_raw_yolo_columns(
+            np.ascontiguousarray(det_tensor.T), config, orig_w, orig_h, scale, pad
         )
+        coeffs = det_tensor[:, 4 + num_classes:4 + num_classes + NUM_MASK_COEFFS]
 
-        # Crop mask to bbox, threshold to binary
-        binary, crop_w, crop_h = _crop_mask_to_bbox(
-            mask_raw, x1, y1, x2, y2, input_size, mask_threshold
+    detections = []
+    for index, det in kept:
+        mask_b64, mask_w, mask_h = _instance_mask(
+            coeffs[index], proto_tensor, det["bbox"], scale, pad, input_size, mask_threshold
         )
-        mask_b64 = base64.b64encode(binary.tobytes()).decode("ascii")
-
-        # Transform bbox from model coords to original image coords
-        ox1 = max(0, min(orig_w, (x1 - pad[0]) / scale))
-        oy1 = max(0, min(orig_h, (y1 - pad[1]) / scale))
-        ox2 = max(0, min(orig_w, (x2 - pad[0]) / scale))
-        oy2 = max(0, min(orig_h, (y2 - pad[1]) / scale))
-
-        label = labels[best_class] if best_class < len(labels) else str(best_class)
-        candidates.append({
-            "class": label,
-            "score": round(best_score, 4),
-            "bbox": [round(ox1, 1), round(oy1, 1), round(ox2, 1), round(oy2, 1)],
-            "mask": mask_b64,
-            "maskWidth": crop_w,
-            "maskHeight": crop_h,
-            "_xyxy": (ox1, oy1, ox2, oy2),
-        })
-
-    kept = _nms(candidates, nms_iou)
-    # Remove internal _xyxy field
-    for d in kept:
-        del d["_xyxy"]
-
-    return {"kind": "detections", "detections": kept}
+        detections.append({**det, "mask": mask_b64, "maskWidth": mask_w, "maskHeight": mask_h})
+
+    return {"kind": "detections", "detections": detections}