tempest-react-sdk 0.23.0 → 0.25.0

package/dist/vision/postprocess/detection.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"detection.cjs","sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/**\n * Detection head postprocessing: anchor-free YOLO decoding + non-maximum suppression.\n *\n * The shared {@link decodeYoloAnchors} helper does the per-anchor work that\n * is identical for plain detection and segmentation (transpose, xywh→xyxy,\n * letterbox unmap, per-class NMS, sort & cap). {@link decodeYolo} is a thin\n * wrapper around it; the segmentation module ({@link ./segmentation.js})\n * calls the helper directly so it can also recover the per-anchor mask\n * coefficients.\n *\n * Works for any YOLO export with the post-v8 anchor-free head:\n * **YOLOv8 / v9 / v10 / v11 / v12** detect heads, all of which share the\n * `[1, 4 + nc, N]` output layout.\n */\n\nimport { BoundingBox } from \"../types\";\n\n/**\n * Greedy non-maximum suppression on axis-aligned bounding boxes.\n *\n * Mirrors `torchvision.ops.nms` (keeps boxes with the highest score, drops\n * any subsequent box whose IoU exceeds the threshold).\n *\n * @param boxes Flat array of length `4 * N` in xyxy order: `[x1,y1,x2,y2, ...]`.\n * @param scores Detection score per box, length `N`.\n * @param iouThreshold Boxes with IoU above this threshold relative to a kept box are suppressed.\n * @returns Indices of kept boxes, in descending score order.\n */\nexport function nms(boxes: Float32Array, scores: Float32Array, iouThreshold: number): Int32Array {\n    const n = scores.length;\n    if (n === 0) return new Int32Array(0);\n\n    const areas = new Float32Array(n);\n    for (let i = 0; i < n; i++) {\n        const x1 = boxes[i * 4] as number;\n        const y1 = boxes[i * 4 + 1] as number;\n        const x2 = boxes[i * 4 + 2] as number;\n        const y2 = boxes[i * 4 + 3] as number;\n        areas[i] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const order = new Array<number>(n);\n    for (let i = 0; i < n; i++) order[i] = i;\n    order.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let oi = 0; oi < order.length; oi++) {\n        const i = order[oi] as number;\n        if (suppressed[i]) continue;\n        keep.push(i);\n\n        const ax1 = boxes[i * 4] as number;\n        const ay1 = boxes[i * 4 + 1] as number;\n        const ax2 = boxes[i * 4 + 2] as number;\n        const ay2 = boxes[i * 4 + 3] as number;\n        const ai = areas[i] as number;\n\n        for (let oj = oi + 1; oj < order.length; oj++) {\n            const j = order[oj] as number;\n            if (suppressed[j]) continue;\n\n            const bx1 = boxes[j * 4] as number;\n            const by1 = boxes[j * 4 + 1] as number;\n            const bx2 = boxes[j * 4 + 2] as number;\n            const by2 = boxes[j * 4 + 3] as number;\n\n            const ix1 = Math.max(ax1, bx1);\n            const iy1 = Math.max(ay1, by1);\n            const ix2 = Math.min(ax2, bx2);\n            const iy2 = Math.min(ay2, by2);\n            const iw = Math.max(0, ix2 - ix1);\n            const ih = Math.max(0, iy2 - iy1);\n            const inter = iw * ih;\n            const union = ai + (areas[j] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[j] = 1;\n        }\n    }\n\n    return Int32Array.from(keep);\n}\n\n/**\n * Per-class NMS — boxes are suppressed only by other boxes of the same class.\n *\n * Mirrors `torchvision.ops.batched_nms`.\n *\n * @param boxes Flat array of length `4 * N` in xyxy order.\n * @param scores Detection score per box, length `N`.\n * @param idxs Class index per box, length `N`. Boxes with different `idxs`\n *   never suppress each other.\n * @param iouThreshold IoU threshold for suppression within a class.\n */\nexport function batchedNms(\n    boxes: Float32Array,\n    scores: Float32Array,\n    idxs: Int32Array,\n    iouThreshold: number,\n): Int32Array {\n    if (scores.length === 0) return new Int32Array(0);\n\n    const byClass = new Map<number, number[]>();\n    for (let i = 0; i < idxs.length; i++) {\n        const c = idxs[i] as number;\n        const list = byClass.get(c);\n        if (list === undefined) byClass.set(c, [i]);\n        else list.push(i);\n    }\n\n    const keep: number[] = [];\n    for (const indices of byClass.values()) {\n        const m = indices.length;\n        const subBoxes = new Float32Array(m * 4);\n        const subScores = new Float32Array(m);\n        for (let k = 0; k < m; k++) {\n            const i = indices[k] as number;\n            subBoxes[k * 4] = boxes[i * 4] as number;\n            subBoxes[k * 4 + 1] = boxes[i * 4 + 1] as number;\n            subBoxes[k * 4 + 2] = boxes[i * 4 + 2] as number;\n            subBoxes[k * 4 + 3] = boxes[i * 4 + 3] as number;\n            subScores[k] = scores[i] as number;\n        }\n        const subKeep = nms(subBoxes, subScores, iouThreshold);\n        for (let k = 0; k < subKeep.length; k++) {\n            keep.push(indices[subKeep[k] as number] as number);\n        }\n    }\n\n    keep.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n    return Int32Array.from(keep);\n}\n\nexport interface DecodeYoloAnchorsOptions {\n    /** Number of class-score channels following the 4 box channels. */\n    readonly numClasses: number;\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedAnchors {\n    /** Indices into the original `numAnchors` axis, in descending confidence order. */\n    readonly anchorIndices: Int32Array;\n    /** `[k, 4]` boxes in original-image pixel coords, flat row-major xyxy. */\n    readonly boxesXyxy: Float32Array;\n    /** Predicted class id per survivor. */\n    readonly classIds: Int32Array;\n    /** Confidence per survivor. */\n    readonly confidences: Float32Array;\n}\n\n/**\n * Shared YOLO per-anchor decode used by both detection and segmentation\n * (v8 / v9 / v10 / v11 / v12).\n *\n * Only the first `4 + numClasses` channels are read; later channels (e.g.\n * mask coefficients) are ignored — callers can fetch them via the returned\n * {@link DecodedAnchors.anchorIndices}.\n *\n * @param data Flat per-anchor output, length `channels * numAnchors`.\n * @param dims Dims as reported by ORT, e.g. `[1, 84, 8400]` (det) or\n *   `[1, 116, 8400]` (seg). The leading batch dim must be 1.\n */\nexport function decodeYoloAnchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    let normalized = dims;\n    if (normalized.length === 3) {\n        if (normalized[0] !== 1) {\n            throw new Error(`decodeYoloAnchors: expected batch size 1, got ${normalized[0]}.`);\n        }\n        normalized = [normalized[1] as number, normalized[2] as number];\n    }\n    if (normalized.length !== 2) {\n        throw new Error(\n            `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(dims)}.`,\n        );\n    }\n    const channels = normalized[0] as number;\n    const numAnchors = normalized[1] as number;\n\n    const {\n        numClasses,\n        originalWidth,\n        originalHeight,\n        padLeft,\n        padTop,\n        scale,\n        confThreshold,\n        iouThreshold,\n        maxDetections,\n    } = options;\n\n    if (numClasses < 1 || numClasses + 4 > channels) {\n        throw new Error(\n            `decodeYoloAnchors: invalid numClasses=${numClasses} for channels=${channels}.`,\n        );\n    }\n    if (data.length !== channels * numAnchors) {\n        throw new Error(\n            `decodeYoloAnchors: data length ${data.length} does not match channels*numAnchors=${channels * numAnchors}.`,\n        );\n    }\n\n    type Candidate = {\n        anchorIdx: number;\n        x1: number;\n        y1: number;\n        x2: number;\n        y2: number;\n        classId: number;\n        confidence: number;\n    };\n    const candidates: Candidate[] = [];\n\n    for (let a = 0; a < numAnchors; a++) {\n        let bestCls = 0;\n        let bestScore = -Infinity;\n        for (let c = 0; c < numClasses; c++) {\n            const s = data[(4 + c) * numAnchors + a];\n            if (s !== undefined && s > bestScore) {\n                bestScore = s;\n                bestCls = c;\n            }\n        }\n        if (bestScore < confThreshold) continue;\n\n        const cx = data[a] as number;\n        const cy = data[numAnchors + a] as number;\n        const w = data[2 * numAnchors + a] as number;\n        const h = data[3 * numAnchors + a] as number;\n\n        let x1 = cx - w / 2;\n        let y1 = cy - h / 2;\n        let x2 = cx + w / 2;\n        let y2 = cy + h / 2;\n\n        x1 = (x1 - padLeft) / scale;\n        y1 = (y1 - padTop) / scale;\n        x2 = (x2 - padLeft) / scale;\n        y2 = (y2 - padTop) / scale;\n\n        x1 = Math.max(0, Math.min(originalWidth, x1));\n        y1 = Math.max(0, Math.min(originalHeight, y1));\n        x2 = Math.max(0, Math.min(originalWidth, x2));\n        y2 = Math.max(0, Math.min(originalHeight, y2));\n\n        candidates.push({ anchorIdx: a, x1, y1, x2, y2, classId: bestCls, confidence: bestScore });\n    }\n\n    if (candidates.length === 0) return emptyDecoded();\n\n    // Build flat arrays then delegate to batchedNms — same algorithm as before\n    // but funnelled through the public per-class NMS helper.\n    const flatBoxes = new Float32Array(candidates.length * 4);\n    const scoresArr = new Float32Array(candidates.length);\n    const idxsArr = new Int32Array(candidates.length);\n    for (let i = 0; i < candidates.length; i++) {\n        const c = candidates[i] as Candidate;\n        flatBoxes[i * 4] = c.x1;\n        flatBoxes[i * 4 + 1] = c.y1;\n        flatBoxes[i * 4 + 2] = c.x2;\n        flatBoxes[i * 4 + 3] = c.y2;\n        scoresArr[i] = c.confidence;\n        idxsArr[i] = c.classId;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const limited = Array.from(kept).slice(0, maxDetections);\n    const k = limited.length;\n    const anchorIndices = new Int32Array(k);\n    const boxesXyxy = new Float32Array(k * 4);\n    const classIds = new Int32Array(k);\n    const confidences = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n        const c = candidates[limited[i] as number] as Candidate;\n        anchorIndices[i] = c.anchorIdx;\n        boxesXyxy[i * 4] = c.x1;\n        boxesXyxy[i * 4 + 1] = c.y1;\n        boxesXyxy[i * 4 + 2] = c.x2;\n        boxesXyxy[i * 4 + 3] = c.y2;\n        classIds[i] = c.classId;\n        confidences[i] = c.confidence;\n    }\n    return { anchorIndices, boxesXyxy, classIds, confidences };\n}\n\nfunction emptyDecoded(): DecodedAnchors {\n    return {\n        anchorIndices: new Int32Array(0),\n        boxesXyxy: new Float32Array(0),\n        classIds: new Int32Array(0),\n        confidences: new Float32Array(0),\n    };\n}\n\nexport interface DecodeYoloOptions {\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedDetection {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n}\n\n/**\n * Decode an anchor-free YOLO detection output into a list of detections.\n *\n * Works for **YOLOv8 / v9 / v10 / v11 / v12** detect heads.\n *\n * Expected raw shape: `[1, 4 + numClasses, N]`. `numClasses` is inferred\n * from the channel count.\n */\nexport function decodeYolo(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    const channels = outputDims.length === 3 ? outputDims[1] : outputDims[0];\n    if (channels === undefined || channels < 5) {\n        throw new Error(`decodeYolo: invalid output channel count ${channels} (expected >= 5).`);\n    }\n    const numClasses = channels - 4;\n\n    const decoded = decodeYoloAnchors(output, outputDims, {\n        numClasses,\n        ...options,\n    });\n\n    const results: DecodedDetection[] = [];\n    for (let i = 0; i < decoded.classIds.length; i++) {\n        results.push({\n            bbox: new BoundingBox(\n                decoded.boxesXyxy[i * 4] as number,\n                decoded.boxesXyxy[i * 4 + 1] as number,\n                decoded.boxesXyxy[i * 4 + 2] as number,\n                decoded.boxesXyxy[i * 4 + 3] as number,\n            ),\n            classId: decoded.classIds[i] as number,\n            confidence: decoded.confidences[i] as number,\n        });\n    }\n    return results;\n}\n\nlet _warnedDecodeYoloV8 = false;\nlet _warnedDecodeYoloV8Anchors = false;\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYolo}. Same behavior; the\n * decoder covers v8/v9/v10/v11/v12 detect heads. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    if (!_warnedDecodeYoloV8) {\n        _warnedDecodeYoloV8 = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYolo(output, outputDims, options);\n}\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYoloAnchors}. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8Anchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    if (!_warnedDecodeYoloV8Anchors) {\n        _warnedDecodeYoloV8Anchors = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloAnchors(data, dims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloAnchorsOptions}. */\nexport type DecodeYoloV8AnchorsOptions = DecodeYoloAnchorsOptions;\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloOptions}. */\nexport type DecodeYoloV8Options = DecodeYoloOptions;\n"],"names":["nms","boxes","scores","iouThreshold","n","areas","i","x1","y1","x2","y2","order","a","b","suppressed","keep","oi","ax1","ay1","ax2","ay2","ai","oj","j","bx1","by1","bx2","by2","ix1","iy1","ix2","iy2","iw","ih","inter","union","batchedNms","idxs","byClass","c","list","indices","m","subBoxes","subScores","k","subKeep","decodeYoloAnchors","data","dims","options","normalized","channels","numAnchors","numClasses","originalWidth","originalHeight","padLeft","padTop","scale","confThreshold","maxDetections","candidates","bestCls","bestScore","s","cx","cy","w","h","emptyDecoded","flatBoxes","scoresArr","idxsArr","kept","limited","anchorIndices","boxesXyxy","classIds","confidences","decodeYolo","output","outputDims","decoded","results","BoundingBox","_warnedDecodeYoloV8","_warnedDecodeYoloV8Anchors","decodeYoloV8","decodeYoloV8Anchors"],"mappings":"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"}
+{"version":3,"file":"detection.cjs","names":[],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/**\n * Detection head postprocessing: anchor-free YOLO decoding + non-maximum suppression.\n *\n * The shared {@link decodeYoloAnchors} helper does the per-anchor work that\n * is identical for plain detection and segmentation (transpose, xywh→xyxy,\n * letterbox unmap, per-class NMS, sort & cap). {@link decodeYolo} is a thin\n * wrapper around it; the segmentation module ({@link ./segmentation.js})\n * calls the helper directly so it can also recover the per-anchor mask\n * coefficients.\n *\n * Works for any YOLO export with the post-v8 anchor-free head:\n * **YOLOv8 / v9 / v10 / v11 / v12** detect heads, all of which share the\n * `[1, 4 + nc, N]` output layout.\n */\n\nimport { BoundingBox } from \"../types\";\n\n/**\n * Greedy non-maximum suppression on axis-aligned bounding boxes.\n *\n * Mirrors `torchvision.ops.nms` (keeps boxes with the highest score, drops\n * any subsequent box whose IoU exceeds the threshold).\n *\n * @param boxes Flat array of length `4 * N` in xyxy order: `[x1,y1,x2,y2, ...]`.\n * @param scores Detection score per box, length `N`.\n * @param iouThreshold Boxes with IoU above this threshold relative to a kept box are suppressed.\n * @returns Indices of kept boxes, in descending score order.\n */\nexport function nms(boxes: Float32Array, scores: Float32Array, iouThreshold: number): Int32Array {\n    const n = scores.length;\n    if (n === 0) return new Int32Array(0);\n\n    const areas = new Float32Array(n);\n    for (let i = 0; i < n; i++) {\n        const x1 = boxes[i * 4] as number;\n        const y1 = boxes[i * 4 + 1] as number;\n        const x2 = boxes[i * 4 + 2] as number;\n        const y2 = boxes[i * 4 + 3] as number;\n        areas[i] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const order = new Array<number>(n);\n    for (let i = 0; i < n; i++) order[i] = i;\n    order.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let oi = 0; oi < order.length; oi++) {\n        const i = order[oi] as number;\n        if (suppressed[i]) continue;\n        keep.push(i);\n\n        const ax1 = boxes[i * 4] as number;\n        const ay1 = boxes[i * 4 + 1] as number;\n        const ax2 = boxes[i * 4 + 2] as number;\n        const ay2 = boxes[i * 4 + 3] as number;\n        const ai = areas[i] as number;\n\n        for (let oj = oi + 1; oj < order.length; oj++) {\n            const j = order[oj] as number;\n            if (suppressed[j]) continue;\n\n            const bx1 = boxes[j * 4] as number;\n            const by1 = boxes[j * 4 + 1] as number;\n            const bx2 = boxes[j * 4 + 2] as number;\n            const by2 = boxes[j * 4 + 3] as number;\n\n            const ix1 = Math.max(ax1, bx1);\n            const iy1 = Math.max(ay1, by1);\n            const ix2 = Math.min(ax2, bx2);\n            const iy2 = Math.min(ay2, by2);\n            const iw = Math.max(0, ix2 - ix1);\n            const ih = Math.max(0, iy2 - iy1);\n            const inter = iw * ih;\n            const union = ai + (areas[j] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[j] = 1;\n        }\n    }\n\n    return Int32Array.from(keep);\n}\n\n/**\n * Per-class NMS — boxes are suppressed only by other boxes of the same class.\n *\n * Mirrors `torchvision.ops.batched_nms`.\n *\n * @param boxes Flat array of length `4 * N` in xyxy order.\n * @param scores Detection score per box, length `N`.\n * @param idxs Class index per box, length `N`. Boxes with different `idxs`\n *   never suppress each other.\n * @param iouThreshold IoU threshold for suppression within a class.\n */\nexport function batchedNms(\n    boxes: Float32Array,\n    scores: Float32Array,\n    idxs: Int32Array,\n    iouThreshold: number,\n): Int32Array {\n    if (scores.length === 0) return new Int32Array(0);\n\n    const byClass = new Map<number, number[]>();\n    for (let i = 0; i < idxs.length; i++) {\n        const c = idxs[i] as number;\n        const list = byClass.get(c);\n        if (list === undefined) byClass.set(c, [i]);\n        else list.push(i);\n    }\n\n    const keep: number[] = [];\n    for (const indices of byClass.values()) {\n        const m = indices.length;\n        const subBoxes = new Float32Array(m * 4);\n        const subScores = new Float32Array(m);\n        for (let k = 0; k < m; k++) {\n            const i = indices[k] as number;\n            subBoxes[k * 4] = boxes[i * 4] as number;\n            subBoxes[k * 4 + 1] = boxes[i * 4 + 1] as number;\n            subBoxes[k * 4 + 2] = boxes[i * 4 + 2] as number;\n            subBoxes[k * 4 + 3] = boxes[i * 4 + 3] as number;\n            subScores[k] = scores[i] as number;\n        }\n        const subKeep = nms(subBoxes, subScores, iouThreshold);\n        for (let k = 0; k < subKeep.length; k++) {\n            keep.push(indices[subKeep[k] as number] as number);\n        }\n    }\n\n    keep.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n    return Int32Array.from(keep);\n}\n\nexport interface DecodeYoloAnchorsOptions {\n    /** Number of class-score channels following the 4 box channels. */\n    readonly numClasses: number;\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedAnchors {\n    /** Indices into the original `numAnchors` axis, in descending confidence order. */\n    readonly anchorIndices: Int32Array;\n    /** `[k, 4]` boxes in original-image pixel coords, flat row-major xyxy. */\n    readonly boxesXyxy: Float32Array;\n    /** Predicted class id per survivor. */\n    readonly classIds: Int32Array;\n    /** Confidence per survivor. */\n    readonly confidences: Float32Array;\n}\n\n/**\n * Shared YOLO per-anchor decode used by both detection and segmentation\n * (v8 / v9 / v10 / v11 / v12).\n *\n * Only the first `4 + numClasses` channels are read; later channels (e.g.\n * mask coefficients) are ignored — callers can fetch them via the returned\n * {@link DecodedAnchors.anchorIndices}.\n *\n * @param data Flat per-anchor output, length `channels * numAnchors`.\n * @param dims Dims as reported by ORT, e.g. `[1, 84, 8400]` (det) or\n *   `[1, 116, 8400]` (seg). The leading batch dim must be 1.\n */\nexport function decodeYoloAnchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    let normalized = dims;\n    if (normalized.length === 3) {\n        if (normalized[0] !== 1) {\n            throw new Error(`decodeYoloAnchors: expected batch size 1, got ${normalized[0]}.`);\n        }\n        normalized = [normalized[1] as number, normalized[2] as number];\n    }\n    if (normalized.length !== 2) {\n        throw new Error(\n            `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(dims)}.`,\n        );\n    }\n    const channels = normalized[0] as number;\n    const numAnchors = normalized[1] as number;\n\n    const {\n        numClasses,\n        originalWidth,\n        originalHeight,\n        padLeft,\n        padTop,\n        scale,\n        confThreshold,\n        iouThreshold,\n        maxDetections,\n    } = options;\n\n    if (numClasses < 1 || numClasses + 4 > channels) {\n        throw new Error(\n            `decodeYoloAnchors: invalid numClasses=${numClasses} for channels=${channels}.`,\n        );\n    }\n    if (data.length !== channels * numAnchors) {\n        throw new Error(\n            `decodeYoloAnchors: data length ${data.length} does not match channels*numAnchors=${channels * numAnchors}.`,\n        );\n    }\n\n    type Candidate = {\n        anchorIdx: number;\n        x1: number;\n        y1: number;\n        x2: number;\n        y2: number;\n        classId: number;\n        confidence: number;\n    };\n    const candidates: Candidate[] = [];\n\n    for (let a = 0; a < numAnchors; a++) {\n        let bestCls = 0;\n        let bestScore = -Infinity;\n        for (let c = 0; c < numClasses; c++) {\n            const s = data[(4 + c) * numAnchors + a];\n            if (s !== undefined && s > bestScore) {\n                bestScore = s;\n                bestCls = c;\n            }\n        }\n        if (bestScore < confThreshold) continue;\n\n        const cx = data[a] as number;\n        const cy = data[numAnchors + a] as number;\n        const w = data[2 * numAnchors + a] as number;\n        const h = data[3 * numAnchors + a] as number;\n\n        let x1 = cx - w / 2;\n        let y1 = cy - h / 2;\n        let x2 = cx + w / 2;\n        let y2 = cy + h / 2;\n\n        x1 = (x1 - padLeft) / scale;\n        y1 = (y1 - padTop) / scale;\n        x2 = (x2 - padLeft) / scale;\n        y2 = (y2 - padTop) / scale;\n\n        x1 = Math.max(0, Math.min(originalWidth, x1));\n        y1 = Math.max(0, Math.min(originalHeight, y1));\n        x2 = Math.max(0, Math.min(originalWidth, x2));\n        y2 = Math.max(0, Math.min(originalHeight, y2));\n\n        candidates.push({ anchorIdx: a, x1, y1, x2, y2, classId: bestCls, confidence: bestScore });\n    }\n\n    if (candidates.length === 0) return emptyDecoded();\n\n    // Build flat arrays then delegate to batchedNms — same algorithm as before\n    // but funnelled through the public per-class NMS helper.\n    const flatBoxes = new Float32Array(candidates.length * 4);\n    const scoresArr = new Float32Array(candidates.length);\n    const idxsArr = new Int32Array(candidates.length);\n    for (let i = 0; i < candidates.length; i++) {\n        const c = candidates[i] as Candidate;\n        flatBoxes[i * 4] = c.x1;\n        flatBoxes[i * 4 + 1] = c.y1;\n        flatBoxes[i * 4 + 2] = c.x2;\n        flatBoxes[i * 4 + 3] = c.y2;\n        scoresArr[i] = c.confidence;\n        idxsArr[i] = c.classId;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const limited = Array.from(kept).slice(0, maxDetections);\n    const k = limited.length;\n    const anchorIndices = new Int32Array(k);\n    const boxesXyxy = new Float32Array(k * 4);\n    const classIds = new Int32Array(k);\n    const confidences = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n        const c = candidates[limited[i] as number] as Candidate;\n        anchorIndices[i] = c.anchorIdx;\n        boxesXyxy[i * 4] = c.x1;\n        boxesXyxy[i * 4 + 1] = c.y1;\n        boxesXyxy[i * 4 + 2] = c.x2;\n        boxesXyxy[i * 4 + 3] = c.y2;\n        classIds[i] = c.classId;\n        confidences[i] = c.confidence;\n    }\n    return { anchorIndices, boxesXyxy, classIds, confidences };\n}\n\nfunction emptyDecoded(): DecodedAnchors {\n    return {\n        anchorIndices: new Int32Array(0),\n        boxesXyxy: new Float32Array(0),\n        classIds: new Int32Array(0),\n        confidences: new Float32Array(0),\n    };\n}\n\nexport interface DecodeYoloOptions {\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedDetection {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n}\n\n/**\n * Decode an anchor-free YOLO detection output into a list of detections.\n *\n * Works for **YOLOv8 / v9 / v10 / v11 / v12** detect heads.\n *\n * Expected raw shape: `[1, 4 + numClasses, N]`. `numClasses` is inferred\n * from the channel count.\n */\nexport function decodeYolo(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    const channels = outputDims.length === 3 ? outputDims[1] : outputDims[0];\n    if (channels === undefined || channels < 5) {\n        throw new Error(`decodeYolo: invalid output channel count ${channels} (expected >= 5).`);\n    }\n    const numClasses = channels - 4;\n\n    const decoded = decodeYoloAnchors(output, outputDims, {\n        numClasses,\n        ...options,\n    });\n\n    const results: DecodedDetection[] = [];\n    for (let i = 0; i < decoded.classIds.length; i++) {\n        results.push({\n            bbox: new BoundingBox(\n                decoded.boxesXyxy[i * 4] as number,\n                decoded.boxesXyxy[i * 4 + 1] as number,\n                decoded.boxesXyxy[i * 4 + 2] as number,\n                decoded.boxesXyxy[i * 4 + 3] as number,\n            ),\n            classId: decoded.classIds[i] as number,\n            confidence: decoded.confidences[i] as number,\n        });\n    }\n    return results;\n}\n\nlet _warnedDecodeYoloV8 = false;\nlet _warnedDecodeYoloV8Anchors = false;\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYolo}. Same behavior; the\n * decoder covers v8/v9/v10/v11/v12 detect heads. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    if (!_warnedDecodeYoloV8) {\n        _warnedDecodeYoloV8 = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYolo(output, outputDims, options);\n}\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYoloAnchors}. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8Anchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    if (!_warnedDecodeYoloV8Anchors) {\n        _warnedDecodeYoloV8Anchors = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloAnchors(data, dims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloAnchorsOptions}. */\nexport type DecodeYoloV8AnchorsOptions = DecodeYoloAnchorsOptions;\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloOptions}. */\nexport type DecodeYoloV8Options = DecodeYoloOptions;\n"],"mappings":"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"}

package/dist/vision/postprocess/detection.js

@@ -1,153 +1,129 @@
-import { BoundingBox as K } from "../types.js";
-function L(n, a, y) {
-  const c = a.length;
-  if (c === 0) return new Int32Array(0);
-  const d = new Float32Array(c);
-  for (let o = 0; o < c; o++) {
-    const h = n[o * 4], m = n[o * 4 + 1], l = n[o * 4 + 2], w = n[o * 4 + 3];
-    d[o] = Math.max(0, l - h) * Math.max(0, w - m);
-  }
-  const t = new Array(c);
-  for (let o = 0; o < c; o++) t[o] = o;
-  t.sort((o, h) => a[h] - a[o]);
-  const s = new Uint8Array(c), r = [];
-  for (let o = 0; o < t.length; o++) {
-    const h = t[o];
-    if (s[h]) continue;
-    r.push(h);
-    const m = n[h * 4], l = n[h * 4 + 1], w = n[h * 4 + 2], E = n[h * 4 + 3], T = d[h];
-    for (let u = o + 1; u < t.length; u++) {
-      const f = t[u];
-      if (s[f]) continue;
-      const b = n[f * 4], v = n[f * 4 + 1], F = n[f * 4 + 2], k = n[f * 4 + 3], x = Math.max(m, b), $ = Math.max(l, v), A = Math.min(w, F), V = Math.min(E, k), X = Math.max(0, A - x), e = Math.max(0, V - $), i = X * e, g = T + d[f] - i;
-      (g > 0 ? i / g : 0) > y && (s[f] = 1);
-    }
-  }
-  return Int32Array.from(r);
+import { BoundingBox as e } from "../types.js";
+//#region src/vision/postprocess/detection.ts
+function t(e, t, n) {
+	let r = t.length;
+	if (r === 0) return /* @__PURE__ */ new Int32Array();
+	let i = new Float32Array(r);
+	for (let t = 0; t < r; t++) {
+		let n = e[t * 4], r = e[t * 4 + 1], a = e[t * 4 + 2], o = e[t * 4 + 3];
+		i[t] = Math.max(0, a - n) * Math.max(0, o - r);
+	}
+	let a = Array(r);
+	for (let e = 0; e < r; e++) a[e] = e;
+	a.sort((e, n) => t[n] - t[e]);
+	let o = new Uint8Array(r), s = [];
+	for (let t = 0; t < a.length; t++) {
+		let r = a[t];
+		if (o[r]) continue;
+		s.push(r);
+		let c = e[r * 4], l = e[r * 4 + 1], u = e[r * 4 + 2], d = e[r * 4 + 3], f = i[r];
+		for (let r = t + 1; r < a.length; r++) {
+			let t = a[r];
+			if (o[t]) continue;
+			let s = e[t * 4], p = e[t * 4 + 1], m = e[t * 4 + 2], h = e[t * 4 + 3], g = Math.max(c, s), _ = Math.max(l, p), v = Math.min(u, m), y = Math.min(d, h), b = Math.max(0, v - g) * Math.max(0, y - _), x = f + i[t] - b;
+			(x > 0 ? b / x : 0) > n && (o[t] = 1);
+		}
+	}
+	return Int32Array.from(s);
 }
-function O(n, a, y, c) {
-  if (a.length === 0) return new Int32Array(0);
-  const d = /* @__PURE__ */ new Map();
-  for (let s = 0; s < y.length; s++) {
-    const r = y[s], o = d.get(r);
-    o === void 0 ? d.set(r, [s]) : o.push(s);
-  }
-  const t = [];
-  for (const s of d.values()) {
-    const r = s.length, o = new Float32Array(r * 4), h = new Float32Array(r);
-    for (let l = 0; l < r; l++) {
-      const w = s[l];
-      o[l * 4] = n[w * 4], o[l * 4 + 1] = n[w * 4 + 1], o[l * 4 + 2] = n[w * 4 + 2], o[l * 4 + 3] = n[w * 4 + 3], h[l] = a[w];
-    }
-    const m = L(o, h, c);
-    for (let l = 0; l < m.length; l++)
-      t.push(s[m[l]]);
-  }
-  return t.sort((s, r) => a[r] - a[s]), Int32Array.from(t);
+function n(e, n, r, i) {
+	if (n.length === 0) return /* @__PURE__ */ new Int32Array();
+	let a = /* @__PURE__ */ new Map();
+	for (let e = 0; e < r.length; e++) {
+		let t = r[e], n = a.get(t);
+		n === void 0 ? a.set(t, [e]) : n.push(e);
+	}
+	let o = [];
+	for (let r of a.values()) {
+		let a = r.length, s = new Float32Array(a * 4), c = new Float32Array(a);
+		for (let t = 0; t < a; t++) {
+			let i = r[t];
+			s[t * 4] = e[i * 4], s[t * 4 + 1] = e[i * 4 + 1], s[t * 4 + 2] = e[i * 4 + 2], s[t * 4 + 3] = e[i * 4 + 3], c[t] = n[i];
+		}
+		let l = t(s, c, i);
+		for (let e = 0; e < l.length; e++) o.push(r[l[e]]);
+	}
+	return o.sort((e, t) => n[t] - n[e]), Int32Array.from(o);
 }
-function J(n, a, y) {
-  let c = a;
-  if (c.length === 3) {
-    if (c[0] !== 1)
-      throw new Error(`decodeYoloAnchors: expected batch size 1, got ${c[0]}.`);
-    c = [c[1], c[2]];
-  }
-  if (c.length !== 2)
-    throw new Error(
-      `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(a)}.`
-    );
-  const d = c[0], t = c[1], {
-    numClasses: s,
-    originalWidth: r,
-    originalHeight: o,
-    padLeft: h,
-    padTop: m,
-    scale: l,
-    confThreshold: w,
-    iouThreshold: E,
-    maxDetections: T
-  } = y;
-  if (s < 1 || s + 4 > d)
-    throw new Error(
-      `decodeYoloAnchors: invalid numClasses=${s} for channels=${d}.`
-    );
-  if (n.length !== d * t)
-    throw new Error(
-      `decodeYoloAnchors: data length ${n.length} does not match channels*numAnchors=${d * t}.`
-    );
-  const u = [];
-  for (let e = 0; e < t; e++) {
-    let i = 0, g = -1 / 0;
-    for (let C = 0; C < s; C++) {
-      const S = n[(4 + C) * t + e];
-      S !== void 0 && S > g && (g = S, i = C);
-    }
-    if (g < w) continue;
-    const B = n[e], j = n[t + e], z = n[2 * t + e], D = n[3 * t + e];
-    let p = B - z / 2, I = j - D / 2, M = B + z / 2, Y = j + D / 2;
-    p = (p - h) / l, I = (I - m) / l, M = (M - h) / l, Y = (Y - m) / l, p = Math.max(0, Math.min(r, p)), I = Math.max(0, Math.min(o, I)), M = Math.max(0, Math.min(r, M)), Y = Math.max(0, Math.min(o, Y)), u.push({ anchorIdx: e, x1: p, y1: I, x2: M, y2: Y, classId: i, confidence: g });
-  }
-  if (u.length === 0) return N();
-  const f = new Float32Array(u.length * 4), b = new Float32Array(u.length), v = new Int32Array(u.length);
-  for (let e = 0; e < u.length; e++) {
-    const i = u[e];
-    f[e * 4] = i.x1, f[e * 4 + 1] = i.y1, f[e * 4 + 2] = i.x2, f[e * 4 + 3] = i.y2, b[e] = i.confidence, v[e] = i.classId;
-  }
-  const F = O(f, b, v, E);
-  if (F.length === 0) return N();
-  const k = Array.from(F).slice(0, T), x = k.length, $ = new Int32Array(x), A = new Float32Array(x * 4), V = new Int32Array(x), X = new Float32Array(x);
-  for (let e = 0; e < x; e++) {
-    const i = u[k[e]];
-    $[e] = i.anchorIdx, A[e * 4] = i.x1, A[e * 4 + 1] = i.y1, A[e * 4 + 2] = i.x2, A[e * 4 + 3] = i.y2, V[e] = i.classId, X[e] = i.confidence;
-  }
-  return { anchorIndices: $, boxesXyxy: A, classIds: V, confidences: X };
+function r(e, t, r) {
+	let a = t;
+	if (a.length === 3) {
+		if (a[0] !== 1) throw Error(`decodeYoloAnchors: expected batch size 1, got ${a[0]}.`);
+		a = [a[1], a[2]];
+	}
+	if (a.length !== 2) throw Error(`decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(t)}.`);
+	let o = a[0], s = a[1], { numClasses: c, originalWidth: l, originalHeight: u, padLeft: d, padTop: f, scale: p, confThreshold: m, iouThreshold: h, maxDetections: g } = r;
+	if (c < 1 || c + 4 > o) throw Error(`decodeYoloAnchors: invalid numClasses=${c} for channels=${o}.`);
+	if (e.length !== o * s) throw Error(`decodeYoloAnchors: data length ${e.length} does not match channels*numAnchors=${o * s}.`);
+	let _ = [];
+	for (let t = 0; t < s; t++) {
+		let n = 0, r = -Infinity;
+		for (let i = 0; i < c; i++) {
+			let a = e[(4 + i) * s + t];
+			a !== void 0 && a > r && (r = a, n = i);
+		}
+		if (r < m) continue;
+		let i = e[t], a = e[s + t], o = e[2 * s + t], h = e[3 * s + t], g = i - o / 2, v = a - h / 2, y = i + o / 2, b = a + h / 2;
+		g = (g - d) / p, v = (v - f) / p, y = (y - d) / p, b = (b - f) / p, g = Math.max(0, Math.min(l, g)), v = Math.max(0, Math.min(u, v)), y = Math.max(0, Math.min(l, y)), b = Math.max(0, Math.min(u, b)), _.push({
+			anchorIdx: t,
+			x1: g,
+			y1: v,
+			x2: y,
+			y2: b,
+			classId: n,
+			confidence: r
+		});
+	}
+	if (_.length === 0) return i();
+	let v = new Float32Array(_.length * 4), y = new Float32Array(_.length), b = new Int32Array(_.length);
+	for (let e = 0; e < _.length; e++) {
+		let t = _[e];
+		v[e * 4] = t.x1, v[e * 4 + 1] = t.y1, v[e * 4 + 2] = t.x2, v[e * 4 + 3] = t.y2, y[e] = t.confidence, b[e] = t.classId;
+	}
+	let x = n(v, y, b, h);
+	if (x.length === 0) return i();
+	let S = Array.from(x).slice(0, g), C = S.length, w = new Int32Array(C), T = new Float32Array(C * 4), E = new Int32Array(C), D = new Float32Array(C);
+	for (let e = 0; e < C; e++) {
+		let t = _[S[e]];
+		w[e] = t.anchorIdx, T[e * 4] = t.x1, T[e * 4 + 1] = t.y1, T[e * 4 + 2] = t.x2, T[e * 4 + 3] = t.y2, E[e] = t.classId, D[e] = t.confidence;
+	}
+	return {
+		anchorIndices: w,
+		boxesXyxy: T,
+		classIds: E,
+		confidences: D
+	};
 }
-function N() {
-  return {
-    anchorIndices: new Int32Array(0),
-    boxesXyxy: new Float32Array(0),
-    classIds: new Int32Array(0),
-    confidences: new Float32Array(0)
-  };
+function i() {
+	return {
+		anchorIndices: /* @__PURE__ */ new Int32Array(),
+		boxesXyxy: /* @__PURE__ */ new Float32Array(),
+		classIds: /* @__PURE__ */ new Int32Array(),
+		confidences: /* @__PURE__ */ new Float32Array()
+	};
 }
-function U(n, a, y) {
-  const c = a.length === 3 ? a[1] : a[0];
-  if (c === void 0 || c < 5)
-    throw new Error(`decodeYolo: invalid output channel count ${c} (expected >= 5).`);
-  const d = c - 4, t = J(n, a, {
-    numClasses: d,
-    ...y
-  }), s = [];
-  for (let r = 0; r < t.classIds.length; r++)
-    s.push({
-      bbox: new K(
-        t.boxesXyxy[r * 4],
-        t.boxesXyxy[r * 4 + 1],
-        t.boxesXyxy[r * 4 + 2],
-        t.boxesXyxy[r * 4 + 3]
-      ),
-      classId: t.classIds[r],
-      confidence: t.confidences[r]
-    });
-  return s;
+function a(t, n, i) {
+	let a = n.length === 3 ? n[1] : n[0];
+	if (a === void 0 || a < 5) throw Error(`decodeYolo: invalid output channel count ${a} (expected >= 5).`);
+	let o = r(t, n, {
+		numClasses: a - 4,
+		...i
+	}), s = [];
+	for (let t = 0; t < o.classIds.length; t++) s.push({
+		bbox: new e(o.boxesXyxy[t * 4], o.boxesXyxy[t * 4 + 1], o.boxesXyxy[t * 4 + 2], o.boxesXyxy[t * 4 + 3]),
+		classId: o.classIds[t],
+		confidence: o.confidences[t]
+	});
+	return s;
 }
-let _ = !1, H = !1;
-function q(n, a, y) {
-  return _ || (_ = !0, console.warn(
-    "[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. The alias will be removed in 0.3.0."
-  )), U(n, a, y);
+var o = !1, s = !1;
+function c(e, t, n) {
+	return o || (o = !0, console.warn("[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. The alias will be removed in 0.3.0.")), a(e, t, n);
 }
-function G(n, a, y) {
-  return H || (H = !0, console.warn(
-    "[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. The alias will be removed in 0.3.0."
-  )), J(n, a, y);
+function l(e, t, n) {
+	return s || (s = !0, console.warn("[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. The alias will be removed in 0.3.0.")), r(e, t, n);
 }
-export {
-  O as batchedNms,
-  U as decodeYolo,
-  J as decodeYoloAnchors,
-  q as decodeYoloV8,
-  G as decodeYoloV8Anchors,
-  L as nms
-};
-//# sourceMappingURL=detection.js.map
+//#endregion
+export { n as batchedNms, a as decodeYolo, r as decodeYoloAnchors, c as decodeYoloV8, l as decodeYoloV8Anchors, t as nms };
+
+//# sourceMappingURL=detection.js.map

package/dist/vision/postprocess/detection.js.map

@@ -1 +1 @@
-{"version":3,"file":"detection.js","sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/**\n * Detection head postprocessing: anchor-free YOLO decoding + non-maximum suppression.\n *\n * The shared {@link decodeYoloAnchors} helper does the per-anchor work that\n * is identical for plain detection and segmentation (transpose, xywh→xyxy,\n * letterbox unmap, per-class NMS, sort & cap). {@link decodeYolo} is a thin\n * wrapper around it; the segmentation module ({@link ./segmentation.js})\n * calls the helper directly so it can also recover the per-anchor mask\n * coefficients.\n *\n * Works for any YOLO export with the post-v8 anchor-free head:\n * **YOLOv8 / v9 / v10 / v11 / v12** detect heads, all of which share the\n * `[1, 4 + nc, N]` output layout.\n */\n\nimport { BoundingBox } from \"../types\";\n\n/**\n * Greedy non-maximum suppression on axis-aligned bounding boxes.\n *\n * Mirrors `torchvision.ops.nms` (keeps boxes with the highest score, drops\n * any subsequent box whose IoU exceeds the threshold).\n *\n * @param boxes Flat array of length `4 * N` in xyxy order: `[x1,y1,x2,y2, ...]`.\n * @param scores Detection score per box, length `N`.\n * @param iouThreshold Boxes with IoU above this threshold relative to a kept box are suppressed.\n * @returns Indices of kept boxes, in descending score order.\n */\nexport function nms(boxes: Float32Array, scores: Float32Array, iouThreshold: number): Int32Array {\n    const n = scores.length;\n    if (n === 0) return new Int32Array(0);\n\n    const areas = new Float32Array(n);\n    for (let i = 0; i < n; i++) {\n        const x1 = boxes[i * 4] as number;\n        const y1 = boxes[i * 4 + 1] as number;\n        const x2 = boxes[i * 4 + 2] as number;\n        const y2 = boxes[i * 4 + 3] as number;\n        areas[i] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const order = new Array<number>(n);\n    for (let i = 0; i < n; i++) order[i] = i;\n    order.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let oi = 0; oi < order.length; oi++) {\n        const i = order[oi] as number;\n        if (suppressed[i]) continue;\n        keep.push(i);\n\n        const ax1 = boxes[i * 4] as number;\n        const ay1 = boxes[i * 4 + 1] as number;\n        const ax2 = boxes[i * 4 + 2] as number;\n        const ay2 = boxes[i * 4 + 3] as number;\n        const ai = areas[i] as number;\n\n        for (let oj = oi + 1; oj < order.length; oj++) {\n            const j = order[oj] as number;\n            if (suppressed[j]) continue;\n\n            const bx1 = boxes[j * 4] as number;\n            const by1 = boxes[j * 4 + 1] as number;\n            const bx2 = boxes[j * 4 + 2] as number;\n            const by2 = boxes[j * 4 + 3] as number;\n\n            const ix1 = Math.max(ax1, bx1);\n            const iy1 = Math.max(ay1, by1);\n            const ix2 = Math.min(ax2, bx2);\n            const iy2 = Math.min(ay2, by2);\n            const iw = Math.max(0, ix2 - ix1);\n            const ih = Math.max(0, iy2 - iy1);\n            const inter = iw * ih;\n            const union = ai + (areas[j] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[j] = 1;\n        }\n    }\n\n    return Int32Array.from(keep);\n}\n\n/**\n * Per-class NMS — boxes are suppressed only by other boxes of the same class.\n *\n * Mirrors `torchvision.ops.batched_nms`.\n *\n * @param boxes Flat array of length `4 * N` in xyxy order.\n * @param scores Detection score per box, length `N`.\n * @param idxs Class index per box, length `N`. Boxes with different `idxs`\n *   never suppress each other.\n * @param iouThreshold IoU threshold for suppression within a class.\n */\nexport function batchedNms(\n    boxes: Float32Array,\n    scores: Float32Array,\n    idxs: Int32Array,\n    iouThreshold: number,\n): Int32Array {\n    if (scores.length === 0) return new Int32Array(0);\n\n    const byClass = new Map<number, number[]>();\n    for (let i = 0; i < idxs.length; i++) {\n        const c = idxs[i] as number;\n        const list = byClass.get(c);\n        if (list === undefined) byClass.set(c, [i]);\n        else list.push(i);\n    }\n\n    const keep: number[] = [];\n    for (const indices of byClass.values()) {\n        const m = indices.length;\n        const subBoxes = new Float32Array(m * 4);\n        const subScores = new Float32Array(m);\n        for (let k = 0; k < m; k++) {\n            const i = indices[k] as number;\n            subBoxes[k * 4] = boxes[i * 4] as number;\n            subBoxes[k * 4 + 1] = boxes[i * 4 + 1] as number;\n            subBoxes[k * 4 + 2] = boxes[i * 4 + 2] as number;\n            subBoxes[k * 4 + 3] = boxes[i * 4 + 3] as number;\n            subScores[k] = scores[i] as number;\n        }\n        const subKeep = nms(subBoxes, subScores, iouThreshold);\n        for (let k = 0; k < subKeep.length; k++) {\n            keep.push(indices[subKeep[k] as number] as number);\n        }\n    }\n\n    keep.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n    return Int32Array.from(keep);\n}\n\nexport interface DecodeYoloAnchorsOptions {\n    /** Number of class-score channels following the 4 box channels. */\n    readonly numClasses: number;\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedAnchors {\n    /** Indices into the original `numAnchors` axis, in descending confidence order. */\n    readonly anchorIndices: Int32Array;\n    /** `[k, 4]` boxes in original-image pixel coords, flat row-major xyxy. */\n    readonly boxesXyxy: Float32Array;\n    /** Predicted class id per survivor. */\n    readonly classIds: Int32Array;\n    /** Confidence per survivor. */\n    readonly confidences: Float32Array;\n}\n\n/**\n * Shared YOLO per-anchor decode used by both detection and segmentation\n * (v8 / v9 / v10 / v11 / v12).\n *\n * Only the first `4 + numClasses` channels are read; later channels (e.g.\n * mask coefficients) are ignored — callers can fetch them via the returned\n * {@link DecodedAnchors.anchorIndices}.\n *\n * @param data Flat per-anchor output, length `channels * numAnchors`.\n * @param dims Dims as reported by ORT, e.g. `[1, 84, 8400]` (det) or\n *   `[1, 116, 8400]` (seg). The leading batch dim must be 1.\n */\nexport function decodeYoloAnchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    let normalized = dims;\n    if (normalized.length === 3) {\n        if (normalized[0] !== 1) {\n            throw new Error(`decodeYoloAnchors: expected batch size 1, got ${normalized[0]}.`);\n        }\n        normalized = [normalized[1] as number, normalized[2] as number];\n    }\n    if (normalized.length !== 2) {\n        throw new Error(\n            `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(dims)}.`,\n        );\n    }\n    const channels = normalized[0] as number;\n    const numAnchors = normalized[1] as number;\n\n    const {\n        numClasses,\n        originalWidth,\n        originalHeight,\n        padLeft,\n        padTop,\n        scale,\n        confThreshold,\n        iouThreshold,\n        maxDetections,\n    } = options;\n\n    if (numClasses < 1 || numClasses + 4 > channels) {\n        throw new Error(\n            `decodeYoloAnchors: invalid numClasses=${numClasses} for channels=${channels}.`,\n        );\n    }\n    if (data.length !== channels * numAnchors) {\n        throw new Error(\n            `decodeYoloAnchors: data length ${data.length} does not match channels*numAnchors=${channels * numAnchors}.`,\n        );\n    }\n\n    type Candidate = {\n        anchorIdx: number;\n        x1: number;\n        y1: number;\n        x2: number;\n        y2: number;\n        classId: number;\n        confidence: number;\n    };\n    const candidates: Candidate[] = [];\n\n    for (let a = 0; a < numAnchors; a++) {\n        let bestCls = 0;\n        let bestScore = -Infinity;\n        for (let c = 0; c < numClasses; c++) {\n            const s = data[(4 + c) * numAnchors + a];\n            if (s !== undefined && s > bestScore) {\n                bestScore = s;\n                bestCls = c;\n            }\n        }\n        if (bestScore < confThreshold) continue;\n\n        const cx = data[a] as number;\n        const cy = data[numAnchors + a] as number;\n        const w = data[2 * numAnchors + a] as number;\n        const h = data[3 * numAnchors + a] as number;\n\n        let x1 = cx - w / 2;\n        let y1 = cy - h / 2;\n        let x2 = cx + w / 2;\n        let y2 = cy + h / 2;\n\n        x1 = (x1 - padLeft) / scale;\n        y1 = (y1 - padTop) / scale;\n        x2 = (x2 - padLeft) / scale;\n        y2 = (y2 - padTop) / scale;\n\n        x1 = Math.max(0, Math.min(originalWidth, x1));\n        y1 = Math.max(0, Math.min(originalHeight, y1));\n        x2 = Math.max(0, Math.min(originalWidth, x2));\n        y2 = Math.max(0, Math.min(originalHeight, y2));\n\n        candidates.push({ anchorIdx: a, x1, y1, x2, y2, classId: bestCls, confidence: bestScore });\n    }\n\n    if (candidates.length === 0) return emptyDecoded();\n\n    // Build flat arrays then delegate to batchedNms — same algorithm as before\n    // but funnelled through the public per-class NMS helper.\n    const flatBoxes = new Float32Array(candidates.length * 4);\n    const scoresArr = new Float32Array(candidates.length);\n    const idxsArr = new Int32Array(candidates.length);\n    for (let i = 0; i < candidates.length; i++) {\n        const c = candidates[i] as Candidate;\n        flatBoxes[i * 4] = c.x1;\n        flatBoxes[i * 4 + 1] = c.y1;\n        flatBoxes[i * 4 + 2] = c.x2;\n        flatBoxes[i * 4 + 3] = c.y2;\n        scoresArr[i] = c.confidence;\n        idxsArr[i] = c.classId;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const limited = Array.from(kept).slice(0, maxDetections);\n    const k = limited.length;\n    const anchorIndices = new Int32Array(k);\n    const boxesXyxy = new Float32Array(k * 4);\n    const classIds = new Int32Array(k);\n    const confidences = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n        const c = candidates[limited[i] as number] as Candidate;\n        anchorIndices[i] = c.anchorIdx;\n        boxesXyxy[i * 4] = c.x1;\n        boxesXyxy[i * 4 + 1] = c.y1;\n        boxesXyxy[i * 4 + 2] = c.x2;\n        boxesXyxy[i * 4 + 3] = c.y2;\n        classIds[i] = c.classId;\n        confidences[i] = c.confidence;\n    }\n    return { anchorIndices, boxesXyxy, classIds, confidences };\n}\n\nfunction emptyDecoded(): DecodedAnchors {\n    return {\n        anchorIndices: new Int32Array(0),\n        boxesXyxy: new Float32Array(0),\n        classIds: new Int32Array(0),\n        confidences: new Float32Array(0),\n    };\n}\n\nexport interface DecodeYoloOptions {\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedDetection {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n}\n\n/**\n * Decode an anchor-free YOLO detection output into a list of detections.\n *\n * Works for **YOLOv8 / v9 / v10 / v11 / v12** detect heads.\n *\n * Expected raw shape: `[1, 4 + numClasses, N]`. `numClasses` is inferred\n * from the channel count.\n */\nexport function decodeYolo(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    const channels = outputDims.length === 3 ? outputDims[1] : outputDims[0];\n    if (channels === undefined || channels < 5) {\n        throw new Error(`decodeYolo: invalid output channel count ${channels} (expected >= 5).`);\n    }\n    const numClasses = channels - 4;\n\n    const decoded = decodeYoloAnchors(output, outputDims, {\n        numClasses,\n        ...options,\n    });\n\n    const results: DecodedDetection[] = [];\n    for (let i = 0; i < decoded.classIds.length; i++) {\n        results.push({\n            bbox: new BoundingBox(\n                decoded.boxesXyxy[i * 4] as number,\n                decoded.boxesXyxy[i * 4 + 1] as number,\n                decoded.boxesXyxy[i * 4 + 2] as number,\n                decoded.boxesXyxy[i * 4 + 3] as number,\n            ),\n            classId: decoded.classIds[i] as number,\n            confidence: decoded.confidences[i] as number,\n        });\n    }\n    return results;\n}\n\nlet _warnedDecodeYoloV8 = false;\nlet _warnedDecodeYoloV8Anchors = false;\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYolo}. Same behavior; the\n * decoder covers v8/v9/v10/v11/v12 detect heads. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    if (!_warnedDecodeYoloV8) {\n        _warnedDecodeYoloV8 = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYolo(output, outputDims, options);\n}\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYoloAnchors}. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8Anchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    if (!_warnedDecodeYoloV8Anchors) {\n        _warnedDecodeYoloV8Anchors = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloAnchors(data, dims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloAnchorsOptions}. */\nexport type DecodeYoloV8AnchorsOptions = DecodeYoloAnchorsOptions;\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloOptions}. */\nexport type DecodeYoloV8Options = DecodeYoloOptions;\n"],"names":["nms","boxes","scores","iouThreshold","n","areas","i","x1","y1","x2","y2","order","a","b","suppressed","keep","oi","ax1","ay1","ax2","ay2","ai","oj","j","bx1","by1","bx2","by2","ix1","iy1","ix2","iy2","iw","ih","inter","union","batchedNms","idxs","byClass","c","list","indices","m","subBoxes","subScores","k","subKeep","decodeYoloAnchors","data","dims","options","normalized","channels","numAnchors","numClasses","originalWidth","originalHeight","padLeft","padTop","scale","confThreshold","maxDetections","candidates","bestCls","bestScore","s","cx","cy","w","h","emptyDecoded","flatBoxes","scoresArr","idxsArr","kept","limited","anchorIndices","boxesXyxy","classIds","confidences","decodeYolo","output","outputDims","decoded","results","BoundingBox","_warnedDecodeYoloV8","_warnedDecodeYoloV8Anchors","decodeYoloV8","decodeYoloV8Anchors"],"mappings":"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"}
+{"version":3,"file":"detection.js","names":[],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/**\n * Detection head postprocessing: anchor-free YOLO decoding + non-maximum suppression.\n *\n * The shared {@link decodeYoloAnchors} helper does the per-anchor work that\n * is identical for plain detection and segmentation (transpose, xywh→xyxy,\n * letterbox unmap, per-class NMS, sort & cap). {@link decodeYolo} is a thin\n * wrapper around it; the segmentation module ({@link ./segmentation.js})\n * calls the helper directly so it can also recover the per-anchor mask\n * coefficients.\n *\n * Works for any YOLO export with the post-v8 anchor-free head:\n * **YOLOv8 / v9 / v10 / v11 / v12** detect heads, all of which share the\n * `[1, 4 + nc, N]` output layout.\n */\n\nimport { BoundingBox } from \"../types\";\n\n/**\n * Greedy non-maximum suppression on axis-aligned bounding boxes.\n *\n * Mirrors `torchvision.ops.nms` (keeps boxes with the highest score, drops\n * any subsequent box whose IoU exceeds the threshold).\n *\n * @param boxes Flat array of length `4 * N` in xyxy order: `[x1,y1,x2,y2, ...]`.\n * @param scores Detection score per box, length `N`.\n * @param iouThreshold Boxes with IoU above this threshold relative to a kept box are suppressed.\n * @returns Indices of kept boxes, in descending score order.\n */\nexport function nms(boxes: Float32Array, scores: Float32Array, iouThreshold: number): Int32Array {\n    const n = scores.length;\n    if (n === 0) return new Int32Array(0);\n\n    const areas = new Float32Array(n);\n    for (let i = 0; i < n; i++) {\n        const x1 = boxes[i * 4] as number;\n        const y1 = boxes[i * 4 + 1] as number;\n        const x2 = boxes[i * 4 + 2] as number;\n        const y2 = boxes[i * 4 + 3] as number;\n        areas[i] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const order = new Array<number>(n);\n    for (let i = 0; i < n; i++) order[i] = i;\n    order.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let oi = 0; oi < order.length; oi++) {\n        const i = order[oi] as number;\n        if (suppressed[i]) continue;\n        keep.push(i);\n\n        const ax1 = boxes[i * 4] as number;\n        const ay1 = boxes[i * 4 + 1] as number;\n        const ax2 = boxes[i * 4 + 2] as number;\n        const ay2 = boxes[i * 4 + 3] as number;\n        const ai = areas[i] as number;\n\n        for (let oj = oi + 1; oj < order.length; oj++) {\n            const j = order[oj] as number;\n            if (suppressed[j]) continue;\n\n            const bx1 = boxes[j * 4] as number;\n            const by1 = boxes[j * 4 + 1] as number;\n            const bx2 = boxes[j * 4 + 2] as number;\n            const by2 = boxes[j * 4 + 3] as number;\n\n            const ix1 = Math.max(ax1, bx1);\n            const iy1 = Math.max(ay1, by1);\n            const ix2 = Math.min(ax2, bx2);\n            const iy2 = Math.min(ay2, by2);\n            const iw = Math.max(0, ix2 - ix1);\n            const ih = Math.max(0, iy2 - iy1);\n            const inter = iw * ih;\n            const union = ai + (areas[j] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[j] = 1;\n        }\n    }\n\n    return Int32Array.from(keep);\n}\n\n/**\n * Per-class NMS — boxes are suppressed only by other boxes of the same class.\n *\n * Mirrors `torchvision.ops.batched_nms`.\n *\n * @param boxes Flat array of length `4 * N` in xyxy order.\n * @param scores Detection score per box, length `N`.\n * @param idxs Class index per box, length `N`. Boxes with different `idxs`\n *   never suppress each other.\n * @param iouThreshold IoU threshold for suppression within a class.\n */\nexport function batchedNms(\n    boxes: Float32Array,\n    scores: Float32Array,\n    idxs: Int32Array,\n    iouThreshold: number,\n): Int32Array {\n    if (scores.length === 0) return new Int32Array(0);\n\n    const byClass = new Map<number, number[]>();\n    for (let i = 0; i < idxs.length; i++) {\n        const c = idxs[i] as number;\n        const list = byClass.get(c);\n        if (list === undefined) byClass.set(c, [i]);\n        else list.push(i);\n    }\n\n    const keep: number[] = [];\n    for (const indices of byClass.values()) {\n        const m = indices.length;\n        const subBoxes = new Float32Array(m * 4);\n        const subScores = new Float32Array(m);\n        for (let k = 0; k < m; k++) {\n            const i = indices[k] as number;\n            subBoxes[k * 4] = boxes[i * 4] as number;\n            subBoxes[k * 4 + 1] = boxes[i * 4 + 1] as number;\n            subBoxes[k * 4 + 2] = boxes[i * 4 + 2] as number;\n            subBoxes[k * 4 + 3] = boxes[i * 4 + 3] as number;\n            subScores[k] = scores[i] as number;\n        }\n        const subKeep = nms(subBoxes, subScores, iouThreshold);\n        for (let k = 0; k < subKeep.length; k++) {\n            keep.push(indices[subKeep[k] as number] as number);\n        }\n    }\n\n    keep.sort((a, b) => (scores[b] as number) - (scores[a] as number));\n    return Int32Array.from(keep);\n}\n\nexport interface DecodeYoloAnchorsOptions {\n    /** Number of class-score channels following the 4 box channels. */\n    readonly numClasses: number;\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedAnchors {\n    /** Indices into the original `numAnchors` axis, in descending confidence order. */\n    readonly anchorIndices: Int32Array;\n    /** `[k, 4]` boxes in original-image pixel coords, flat row-major xyxy. */\n    readonly boxesXyxy: Float32Array;\n    /** Predicted class id per survivor. */\n    readonly classIds: Int32Array;\n    /** Confidence per survivor. */\n    readonly confidences: Float32Array;\n}\n\n/**\n * Shared YOLO per-anchor decode used by both detection and segmentation\n * (v8 / v9 / v10 / v11 / v12).\n *\n * Only the first `4 + numClasses` channels are read; later channels (e.g.\n * mask coefficients) are ignored — callers can fetch them via the returned\n * {@link DecodedAnchors.anchorIndices}.\n *\n * @param data Flat per-anchor output, length `channels * numAnchors`.\n * @param dims Dims as reported by ORT, e.g. `[1, 84, 8400]` (det) or\n *   `[1, 116, 8400]` (seg). The leading batch dim must be 1.\n */\nexport function decodeYoloAnchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    let normalized = dims;\n    if (normalized.length === 3) {\n        if (normalized[0] !== 1) {\n            throw new Error(`decodeYoloAnchors: expected batch size 1, got ${normalized[0]}.`);\n        }\n        normalized = [normalized[1] as number, normalized[2] as number];\n    }\n    if (normalized.length !== 2) {\n        throw new Error(\n            `decodeYoloAnchors: expected 2-D output after batch removal, got dims=${JSON.stringify(dims)}.`,\n        );\n    }\n    const channels = normalized[0] as number;\n    const numAnchors = normalized[1] as number;\n\n    const {\n        numClasses,\n        originalWidth,\n        originalHeight,\n        padLeft,\n        padTop,\n        scale,\n        confThreshold,\n        iouThreshold,\n        maxDetections,\n    } = options;\n\n    if (numClasses < 1 || numClasses + 4 > channels) {\n        throw new Error(\n            `decodeYoloAnchors: invalid numClasses=${numClasses} for channels=${channels}.`,\n        );\n    }\n    if (data.length !== channels * numAnchors) {\n        throw new Error(\n            `decodeYoloAnchors: data length ${data.length} does not match channels*numAnchors=${channels * numAnchors}.`,\n        );\n    }\n\n    type Candidate = {\n        anchorIdx: number;\n        x1: number;\n        y1: number;\n        x2: number;\n        y2: number;\n        classId: number;\n        confidence: number;\n    };\n    const candidates: Candidate[] = [];\n\n    for (let a = 0; a < numAnchors; a++) {\n        let bestCls = 0;\n        let bestScore = -Infinity;\n        for (let c = 0; c < numClasses; c++) {\n            const s = data[(4 + c) * numAnchors + a];\n            if (s !== undefined && s > bestScore) {\n                bestScore = s;\n                bestCls = c;\n            }\n        }\n        if (bestScore < confThreshold) continue;\n\n        const cx = data[a] as number;\n        const cy = data[numAnchors + a] as number;\n        const w = data[2 * numAnchors + a] as number;\n        const h = data[3 * numAnchors + a] as number;\n\n        let x1 = cx - w / 2;\n        let y1 = cy - h / 2;\n        let x2 = cx + w / 2;\n        let y2 = cy + h / 2;\n\n        x1 = (x1 - padLeft) / scale;\n        y1 = (y1 - padTop) / scale;\n        x2 = (x2 - padLeft) / scale;\n        y2 = (y2 - padTop) / scale;\n\n        x1 = Math.max(0, Math.min(originalWidth, x1));\n        y1 = Math.max(0, Math.min(originalHeight, y1));\n        x2 = Math.max(0, Math.min(originalWidth, x2));\n        y2 = Math.max(0, Math.min(originalHeight, y2));\n\n        candidates.push({ anchorIdx: a, x1, y1, x2, y2, classId: bestCls, confidence: bestScore });\n    }\n\n    if (candidates.length === 0) return emptyDecoded();\n\n    // Build flat arrays then delegate to batchedNms — same algorithm as before\n    // but funnelled through the public per-class NMS helper.\n    const flatBoxes = new Float32Array(candidates.length * 4);\n    const scoresArr = new Float32Array(candidates.length);\n    const idxsArr = new Int32Array(candidates.length);\n    for (let i = 0; i < candidates.length; i++) {\n        const c = candidates[i] as Candidate;\n        flatBoxes[i * 4] = c.x1;\n        flatBoxes[i * 4 + 1] = c.y1;\n        flatBoxes[i * 4 + 2] = c.x2;\n        flatBoxes[i * 4 + 3] = c.y2;\n        scoresArr[i] = c.confidence;\n        idxsArr[i] = c.classId;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const limited = Array.from(kept).slice(0, maxDetections);\n    const k = limited.length;\n    const anchorIndices = new Int32Array(k);\n    const boxesXyxy = new Float32Array(k * 4);\n    const classIds = new Int32Array(k);\n    const confidences = new Float32Array(k);\n    for (let i = 0; i < k; i++) {\n        const c = candidates[limited[i] as number] as Candidate;\n        anchorIndices[i] = c.anchorIdx;\n        boxesXyxy[i * 4] = c.x1;\n        boxesXyxy[i * 4 + 1] = c.y1;\n        boxesXyxy[i * 4 + 2] = c.x2;\n        boxesXyxy[i * 4 + 3] = c.y2;\n        classIds[i] = c.classId;\n        confidences[i] = c.confidence;\n    }\n    return { anchorIndices, boxesXyxy, classIds, confidences };\n}\n\nfunction emptyDecoded(): DecodedAnchors {\n    return {\n        anchorIndices: new Int32Array(0),\n        boxesXyxy: new Float32Array(0),\n        classIds: new Int32Array(0),\n        confidences: new Float32Array(0),\n    };\n}\n\nexport interface DecodeYoloOptions {\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    readonly padLeft: number;\n    readonly padTop: number;\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n}\n\nexport interface DecodedDetection {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n}\n\n/**\n * Decode an anchor-free YOLO detection output into a list of detections.\n *\n * Works for **YOLOv8 / v9 / v10 / v11 / v12** detect heads.\n *\n * Expected raw shape: `[1, 4 + numClasses, N]`. `numClasses` is inferred\n * from the channel count.\n */\nexport function decodeYolo(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    const channels = outputDims.length === 3 ? outputDims[1] : outputDims[0];\n    if (channels === undefined || channels < 5) {\n        throw new Error(`decodeYolo: invalid output channel count ${channels} (expected >= 5).`);\n    }\n    const numClasses = channels - 4;\n\n    const decoded = decodeYoloAnchors(output, outputDims, {\n        numClasses,\n        ...options,\n    });\n\n    const results: DecodedDetection[] = [];\n    for (let i = 0; i < decoded.classIds.length; i++) {\n        results.push({\n            bbox: new BoundingBox(\n                decoded.boxesXyxy[i * 4] as number,\n                decoded.boxesXyxy[i * 4 + 1] as number,\n                decoded.boxesXyxy[i * 4 + 2] as number,\n                decoded.boxesXyxy[i * 4 + 3] as number,\n            ),\n            classId: decoded.classIds[i] as number,\n            confidence: decoded.confidences[i] as number,\n        });\n    }\n    return results;\n}\n\nlet _warnedDecodeYoloV8 = false;\nlet _warnedDecodeYoloV8Anchors = false;\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYolo}. Same behavior; the\n * decoder covers v8/v9/v10/v11/v12 detect heads. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8(\n    output: Float32Array,\n    outputDims: readonly number[],\n    options: DecodeYoloOptions,\n): DecodedDetection[] {\n    if (!_warnedDecodeYoloV8) {\n        _warnedDecodeYoloV8 = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8 is deprecated since 0.2.0; use decodeYolo. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYolo(output, outputDims, options);\n}\n\n/**\n * @deprecated since 0.2.0 — use {@link decodeYoloAnchors}. Will be removed in 0.3.0.\n */\nexport function decodeYoloV8Anchors(\n    data: Float32Array,\n    dims: readonly number[],\n    options: DecodeYoloAnchorsOptions,\n): DecodedAnchors {\n    if (!_warnedDecodeYoloV8Anchors) {\n        _warnedDecodeYoloV8Anchors = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Anchors is deprecated since 0.2.0; use decodeYoloAnchors. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloAnchors(data, dims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloAnchorsOptions}. */\nexport type DecodeYoloV8AnchorsOptions = DecodeYoloAnchorsOptions;\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloOptions}. */\nexport type DecodeYoloV8Options = DecodeYoloOptions;\n"],"mappings":"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"}

package/dist/vision/postprocess/segmentation.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const ee=require("./detection.cjs"),I=require("../types.cjs");function _(t,o,l,s,e){let n=s;if(n.length===4){if(n[0]!==1)throw new Error(`decodeYoloSeg: expected batch size 1 in prototypes, got ${n[0]}.`);n=[n[1],n[2],n[3]]}if(n.length!==3)throw new Error(`decodeYoloSeg: expected 3-D prototypes after batch removal, got dims=${JSON.stringify(s)}.`);const u=n[0],i=n[1],r=n[2],m=o.length===3?o[1]:o[0],h=o.length===3?o[2]:o[1];if(m===void 0||h===void 0)throw new Error(`decodeYoloSeg: cannot read channels/numAnchors from dims=${JSON.stringify(o)}.`);const g=4+e.numClasses+u;if(m!==g)throw new Error(`decodeYoloSeg: channels=${m} does not match 4 + numClasses(${e.numClasses}) + numMaskCoefs(${u}) = ${g}.`);if(l.length!==u*i*r)throw new Error(`decodeYoloSeg: prototype length ${l.length} does not match dims=${JSON.stringify(s)}.`);const c=ee.decodeYoloAnchors(t,o,{numClasses:e.numClasses,originalWidth:e.originalWidth,originalHeight:e.originalHeight,padLeft:e.padLeft,padTop:e.padTop,scale:e.scale,confThreshold:e.confThreshold,iouThreshold:e.iouThreshold,maxDetections:e.maxDetections});if(c.anchorIndices.length===0)return[];const x=e.maskThreshold??.5,S=r/e.inputWidth,f=i/e.inputHeight,v=i*r,y=(4+e.numClasses)*h,M=[];for(let a=0;a<c.anchorIndices.length;a++){const X=c.anchorIndices[a],k=c.boxesXyxy[a*4],Y=c.boxesXyxy[a*4+1],T=c.boxesXyxy[a*4+2],B=c.boxesXyxy[a*4+3],L=new I.BoundingBox(k,Y,T,B),O=c.classIds[a],V=c.confidences[a],b=Math.max(0,Math.trunc(T)-Math.trunc(k)),w=Math.max(0,Math.trunc(B)-Math.trunc(Y));if(b===0||w===0){M.push({bbox:L,classId:O,confidence:V,mask:new I.Mask(new Uint8Array(0),0,0)});continue}const A=k*e.scale+e.padLeft,G=Y*e.scale+e.padTop,K=T*e.scale+e.padLeft,Q=B*e.scale+e.padTop,z=Math.max(0,Math.floor(A*S)),J=Math.max(0,Math.floor(G*f)),j=Math.min(r,Math.ceil(K*S)),p=Math.min(i,Math.ceil(Q*f));if(j<=z||p<=J){M.push({bbox:L,classId:O,confidence:V,mask:new I.Mask(new Uint8Array(b*w),b,w)});continue}const C=j-z,N=p-J,q=new Float32Array(C*N);for(let d=0;d<N;d++){const Z=J+d;for(let $=0;$<C;$++){const H=z+$;let F=0;for(let E=0;E<u;E++){const W=t[y+E*h+X],D=l[E*v+Z*r+H];F+=W*D}q[d*C+$]=oe(F)}}const R=te(q,C,N,b,w),U=new Uint8Array(b*w);for(let d=0;d<U.length;d++)U[d]=R[d]>=x?255:0;M.push({bbox:L,classId:O,confidence:V,mask:new I.Mask(U,b,w)})}return M}function oe(t){if(t>=0)return 1/(1+Math.exp(-t));const o=Math.exp(t);return o/(1+o)}let P=!1;function ne(t,o,l,s,e){return P||(P=!0,console.warn("[@ort-vision-sdk/web] decodeYoloV8Seg is deprecated since 0.2.0; use decodeYoloSeg. The alias will be removed in 0.3.0.")),_(t,o,l,s,e)}function te(t,o,l,s,e){const n=new Float32Array(s*e);if(s===0||e===0||o===0||l===0)return n;if(s===o&&e===l)return n.set(t),n;const u=o/s,i=l/e;for(let r=0;r<e;r++){const m=(r+.5)*i-.5,h=Math.max(0,Math.floor(m)),g=Math.min(l-1,h+1),c=Math.max(0,Math.min(1,m-h));for(let x=0;x<s;x++){const S=(x+.5)*u-.5,f=Math.max(0,Math.floor(S)),v=Math.min(o-1,f+1),y=Math.max(0,Math.min(1,S-f)),M=t[h*o+f],a=t[h*o+v],X=t[g*o+f],k=t[g*o+v],Y=M*(1-y)+a*y,T=X*(1-y)+k*y;n[r*s+x]=Y*(1-c)+T*c}}return n}exports.decodeYoloSeg=_;exports.decodeYoloV8Seg=ne;
-//# sourceMappingURL=segmentation.cjs.map
+const e=require("../types.cjs"),t=require("./detection.cjs");function n(n,i,a,s,c){let l=s;if(l.length===4){if(l[0]!==1)throw Error(`decodeYoloSeg: expected batch size 1 in prototypes, got ${l[0]}.`);l=[l[1],l[2],l[3]]}if(l.length!==3)throw Error(`decodeYoloSeg: expected 3-D prototypes after batch removal, got dims=${JSON.stringify(s)}.`);let u=l[0],d=l[1],f=l[2],p=i.length===3?i[1]:i[0],m=i.length===3?i[2]:i[1];if(p===void 0||m===void 0)throw Error(`decodeYoloSeg: cannot read channels/numAnchors from dims=${JSON.stringify(i)}.`);let h=4+c.numClasses+u;if(p!==h)throw Error(`decodeYoloSeg: channels=${p} does not match 4 + numClasses(${c.numClasses}) + numMaskCoefs(${u}) = ${h}.`);if(a.length!==u*d*f)throw Error(`decodeYoloSeg: prototype length ${a.length} does not match dims=${JSON.stringify(s)}.`);let g=t.decodeYoloAnchors(n,i,{numClasses:c.numClasses,originalWidth:c.originalWidth,originalHeight:c.originalHeight,padLeft:c.padLeft,padTop:c.padTop,scale:c.scale,confThreshold:c.confThreshold,iouThreshold:c.iouThreshold,maxDetections:c.maxDetections});if(g.anchorIndices.length===0)return[];let _=c.maskThreshold??.5,v=f/c.inputWidth,y=d/c.inputHeight,b=d*f,x=(4+c.numClasses)*m,S=[];for(let t=0;t<g.anchorIndices.length;t++){let i=g.anchorIndices[t],s=g.boxesXyxy[t*4],l=g.boxesXyxy[t*4+1],p=g.boxesXyxy[t*4+2],h=g.boxesXyxy[t*4+3],C=new e.BoundingBox(s,l,p,h),w=g.classIds[t],T=g.confidences[t],E=Math.max(0,Math.trunc(p)-Math.trunc(s)),D=Math.max(0,Math.trunc(h)-Math.trunc(l));if(E===0||D===0){S.push({bbox:C,classId:w,confidence:T,mask:new e.Mask(new Uint8Array,0,0)});continue}let O=s*c.scale+c.padLeft,k=l*c.scale+c.padTop,A=p*c.scale+c.padLeft,j=h*c.scale+c.padTop,M=Math.max(0,Math.floor(O*v)),N=Math.max(0,Math.floor(k*y)),P=Math.min(f,Math.ceil(A*v)),F=Math.min(d,Math.ceil(j*y));if(P<=M||F<=N){S.push({bbox:C,classId:w,confidence:T,mask:new e.Mask(new Uint8Array(E*D),E,D)});continue}let I=P-M,L=F-N,R=new Float32Array(I*L);for(let e=0;e<L;e++){let t=N+e;for(let o=0;o<I;o++){let s=M+o,c=0;for(let e=0;e<u;e++){let r=n[x+e*m+i],o=a[e*b+t*f+s];c+=r*o}R[e*I+o]=r(c)}}let z=o(R,I,L,E,D),B=new Uint8Array(E*D);for(let e=0;e<B.length;e++)B[e]=z[e]>=_?255:0;S.push({bbox:C,classId:w,confidence:T,mask:new e.Mask(B,E,D)})}return S}function r(e){if(e>=0)return 1/(1+Math.exp(-e));let t=Math.exp(e);return t/(1+t)}var i=!1;function a(e,t,r,a,o){return i||(i=!0,console.warn(`[@ort-vision-sdk/web] decodeYoloV8Seg is deprecated since 0.2.0; use decodeYoloSeg. The alias will be removed in 0.3.0.`)),n(e,t,r,a,o)}function o(e,t,n,r,i){let a=new Float32Array(r*i);if(r===0||i===0||t===0||n===0)return a;if(r===t&&i===n)return a.set(e),a;let o=t/r,s=n/i;for(let c=0;c<i;c++){let i=(c+.5)*s-.5,l=Math.max(0,Math.floor(i)),u=Math.min(n-1,l+1),d=Math.max(0,Math.min(1,i-l));for(let n=0;n<r;n++){let i=(n+.5)*o-.5,s=Math.max(0,Math.floor(i)),f=Math.min(t-1,s+1),p=Math.max(0,Math.min(1,i-s)),m=e[l*t+s],h=e[l*t+f],g=e[u*t+s],_=e[u*t+f],v=m*(1-p)+h*p,y=g*(1-p)+_*p;a[c*r+n]=v*(1-d)+y*d}}return a}exports.decodeYoloSeg=n,exports.decodeYoloV8Seg=a;
+//# sourceMappingURL=segmentation.cjs.map

package/dist/vision/postprocess/segmentation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"segmentation.cjs","sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/**\n * Segmentation head postprocessing: YOLO instance-segmentation decoding.\n *\n * Compatible with YOLOv8-seg / YOLOv11-seg exports (and any later seg head\n * sharing the layout). The model produces two output tensors:\n *\n * - `output0` of shape `(1, 4 + numClasses + numMaskCoefs, numAnchors)` — the\n *   same per-anchor predictions as plain YOLO detection plus an extra\n *   `numMaskCoefs` (typically 32) channels of mask coefficients.\n * - `output1` of shape `(1, numMaskCoefs, maskH, maskW)` — a set of \"prototype\"\n *   masks shared across all anchors.\n *\n * The per-anchor decode (xywh→xyxy, undo letterbox, per-class NMS, sort & cap)\n * is delegated to {@link decodeYoloAnchors}; this module only handles the\n * mask-specific work: matmul against prototypes, sigmoid, bilinear resize and\n * thresholding.\n */\n\nimport { decodeYoloAnchors } from \"./detection\";\nimport { BoundingBox, Mask } from \"../types\";\n\nexport interface DecodeYoloSegOptions {\n    readonly numClasses: number;\n    /** Model input `[width, height]` (post-letterbox). */\n    readonly inputWidth: number;\n    readonly inputHeight: number;\n    /** Original image `[width, height]`. */\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    /** Letterbox horizontal padding in input-tensor pixels. */\n    readonly padLeft: number;\n    /** Letterbox vertical padding in input-tensor pixels. */\n    readonly padTop: number;\n    /** Letterbox scale factor. */\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n    /** Probability cutoff applied to the soft mask. Defaults to `0.5`. */\n    readonly maskThreshold?: number;\n}\n\nexport interface DecodedSegmentation {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n    /** Binary mask cropped to `bbox`. Width/height match `bbox.asIntXyxy()` extents. */\n    readonly mask: Mask;\n}\n\n/**\n * Decode YOLO segmentation raw outputs into a list of segmented instances.\n *\n * Compatible with YOLOv8-seg / YOLOv11-seg.\n *\n * @param perAnchorData Flat `output0`, length `(4 + numClasses + numMaskCoefs) * numAnchors`.\n * @param perAnchorDims Dims as reported by ORT, e.g. `[1, 116, 8400]`.\n * @param prototypeData Flat `output1`, length `numMaskCoefs * maskH * maskW`.\n * @param prototypeDims Dims as reported by ORT, e.g. `[1, 32, 160, 160]`.\n */\nexport function decodeYoloSeg(\n    perAnchorData: Float32Array,\n    perAnchorDims: readonly number[],\n    prototypeData: Float32Array,\n    prototypeDims: readonly number[],\n    options: DecodeYoloSegOptions,\n): DecodedSegmentation[] {\n    // Strip batch dim from prototypes; perAnchor batch is validated by the helper.\n    let pDims = prototypeDims;\n    if (pDims.length === 4) {\n        if (pDims[0] !== 1) {\n            throw new Error(`decodeYoloSeg: expected batch size 1 in prototypes, got ${pDims[0]}.`);\n        }\n        pDims = [pDims[1] as number, pDims[2] as number, pDims[3] as number];\n    }\n    if (pDims.length !== 3) {\n        throw new Error(\n            `decodeYoloSeg: expected 3-D prototypes after batch removal, got dims=${JSON.stringify(prototypeDims)}.`,\n        );\n    }\n    const numMaskCoefs = pDims[0] as number;\n    const maskH = pDims[1] as number;\n    const maskW = pDims[2] as number;\n\n    const channels = perAnchorDims.length === 3 ? perAnchorDims[1] : perAnchorDims[0];\n    const numAnchors = perAnchorDims.length === 3 ? perAnchorDims[2] : perAnchorDims[1];\n    if (channels === undefined || numAnchors === undefined) {\n        throw new Error(\n            `decodeYoloSeg: cannot read channels/numAnchors from dims=${JSON.stringify(perAnchorDims)}.`,\n        );\n    }\n\n    const expectedChannels = 4 + options.numClasses + numMaskCoefs;\n    if (channels !== expectedChannels) {\n        throw new Error(\n            `decodeYoloSeg: channels=${channels} does not match 4 + numClasses(${options.numClasses}) + numMaskCoefs(${numMaskCoefs}) = ${expectedChannels}.`,\n        );\n    }\n    if (prototypeData.length !== numMaskCoefs * maskH * maskW) {\n        throw new Error(\n            `decodeYoloSeg: prototype length ${prototypeData.length} does not match dims=${JSON.stringify(prototypeDims)}.`,\n        );\n    }\n\n    const decoded = decodeYoloAnchors(perAnchorData, perAnchorDims, {\n        numClasses: options.numClasses,\n        originalWidth: options.originalWidth,\n        originalHeight: options.originalHeight,\n        padLeft: options.padLeft,\n        padTop: options.padTop,\n        scale: options.scale,\n        confThreshold: options.confThreshold,\n        iouThreshold: options.iouThreshold,\n        maxDetections: options.maxDetections,\n    });\n\n    if (decoded.anchorIndices.length === 0) return [];\n\n    const maskThreshold = options.maskThreshold ?? 0.5;\n    const scaleX = maskW / options.inputWidth;\n    const scaleY = maskH / options.inputHeight;\n    const protoPlane = maskH * maskW;\n    const coefBase = (4 + options.numClasses) * numAnchors;\n\n    const results: DecodedSegmentation[] = [];\n\n    for (let i = 0; i < decoded.anchorIndices.length; i++) {\n        const a = decoded.anchorIndices[i] as number;\n        const x1 = decoded.boxesXyxy[i * 4] as number;\n        const y1 = decoded.boxesXyxy[i * 4 + 1] as number;\n        const x2 = decoded.boxesXyxy[i * 4 + 2] as number;\n        const y2 = decoded.boxesXyxy[i * 4 + 3] as number;\n        const bbox = new BoundingBox(x1, y1, x2, y2);\n        const classId = decoded.classIds[i] as number;\n        const confidence = decoded.confidences[i] as number;\n\n        const bboxW = Math.max(0, Math.trunc(x2) - Math.trunc(x1));\n        const bboxH = Math.max(0, Math.trunc(y2) - Math.trunc(y1));\n\n        if (bboxW === 0 || bboxH === 0) {\n            results.push({ bbox, classId, confidence, mask: new Mask(new Uint8Array(0), 0, 0) });\n            continue;\n        }\n\n        // Bbox in input-tensor coords, then in low-res mask coords.\n        const ibx1 = x1 * options.scale + options.padLeft;\n        const iby1 = y1 * options.scale + options.padTop;\n        const ibx2 = x2 * options.scale + options.padLeft;\n        const iby2 = y2 * options.scale + options.padTop;\n\n        const mbx1 = Math.max(0, Math.floor(ibx1 * scaleX));\n        const mby1 = Math.max(0, Math.floor(iby1 * scaleY));\n        const mbx2 = Math.min(maskW, Math.ceil(ibx2 * scaleX));\n        const mby2 = Math.min(maskH, Math.ceil(iby2 * scaleY));\n\n        if (mbx2 <= mbx1 || mby2 <= mby1) {\n            results.push({\n                bbox,\n                classId,\n                confidence,\n                mask: new Mask(new Uint8Array(bboxW * bboxH), bboxW, bboxH),\n            });\n            continue;\n        }\n\n        // Compute soft mask only within the prototype region under this bbox.\n        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = new Float32Array(cropW * cropH);\n        for (let y = 0; y < cropH; y++) {\n            const py = mby1 + y;\n            for (let x = 0; x < cropW; x++) {\n                const px = mbx1 + x;\n                let sum = 0;\n                for (let kk = 0; kk < numMaskCoefs; kk++) {\n                    const coef = perAnchorData[coefBase + kk * numAnchors + a];\n                    const proto = prototypeData[kk * protoPlane + py * maskW + px];\n                    sum += coef * proto;\n                }\n                softCrop[y * cropW + x] = sigmoid(sum);\n            }\n        }\n\n        const resized = resizeBilinear(softCrop, cropW, cropH, bboxW, bboxH);\n        const binary = new Uint8Array(bboxW * bboxH);\n        for (let j = 0; j < binary.length; j++) {\n            binary[j] = resized[j] >= maskThreshold ? 255 : 0;\n        }\n\n        results.push({ bbox, classId, confidence, mask: new Mask(binary, bboxW, bboxH) });\n    }\n\n    return results;\n}\n\nfunction sigmoid(x: number): number {\n    if (x >= 0) {\n        return 1 / (1 + Math.exp(-x));\n    }\n    const e = Math.exp(x);\n    return e / (1 + e);\n}\n\nlet _warnedDecodeYoloV8Seg = false;\n\n/** @deprecated since 0.2.0 — use {@link decodeYoloSeg}. Will be removed in 0.3.0. */\nexport function decodeYoloV8Seg(\n    perAnchorData: Float32Array,\n    perAnchorDims: readonly number[],\n    prototypeData: Float32Array,\n    prototypeDims: readonly number[],\n    options: DecodeYoloSegOptions,\n): DecodedSegmentation[] {\n    if (!_warnedDecodeYoloV8Seg) {\n        _warnedDecodeYoloV8Seg = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Seg is deprecated since 0.2.0; use decodeYoloSeg. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloSeg(perAnchorData, perAnchorDims, prototypeData, prototypeDims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloSegOptions}. */\nexport type DecodeYoloV8SegOptions = DecodeYoloSegOptions;\n\nfunction resizeBilinear(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n): Float32Array {\n    const out = new Float32Array(targetWidth * targetHeight);\n    if (targetWidth === 0 || targetHeight === 0 || srcWidth === 0 || srcHeight === 0) {\n        return out;\n    }\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        out.set(src);\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    for (let y = 0; y < targetHeight; y++) {\n        const yy = (y + 0.5) * sy - 0.5;\n        const y0 = Math.max(0, Math.floor(yy));\n        const y1 = Math.min(srcHeight - 1, y0 + 1);\n        const wy = Math.max(0, Math.min(1, yy - y0));\n        for (let x = 0; x < targetWidth; x++) {\n            const xx = (x + 0.5) * sx - 0.5;\n            const x0 = Math.max(0, Math.floor(xx));\n            const x1 = Math.min(srcWidth - 1, x0 + 1);\n            const wx = Math.max(0, Math.min(1, xx - x0));\n            const v00 = src[y0 * srcWidth + x0];\n            const v01 = src[y0 * srcWidth + x1];\n            const v10 = src[y1 * srcWidth + x0];\n            const v11 = src[y1 * srcWidth + x1];\n            const top = v00 * (1 - wx) + v01 * wx;\n            const bot = v10 * (1 - wx) + v11 * wx;\n            out[y * targetWidth + x] = top * (1 - wy) + bot * wy;\n        }\n    }\n    return out;\n}\n"],"names":["decodeYoloSeg","perAnchorData","perAnchorDims","prototypeData","prototypeDims","options","pDims","numMaskCoefs","maskH","maskW","channels","numAnchors","expectedChannels","decoded","decodeYoloAnchors","maskThreshold","scaleX","scaleY","protoPlane","coefBase","results","i","a","x1","y1","x2","y2","bbox","BoundingBox","classId","confidence","bboxW","bboxH","Mask","ibx1","iby1","ibx2","iby2","mbx1","mby1","mbx2","mby2","cropW","cropH","softCrop","y","py","x","px","sum","kk","coef","proto","sigmoid","resized","resizeBilinear","binary","j","e","_warnedDecodeYoloV8Seg","decodeYoloV8Seg","src","srcWidth","srcHeight","targetWidth","targetHeight","out","sx","sy","yy","y0","wy","xx","x0","wx","v00","v01","v10","v11","top","bot"],"mappings":"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"}
+{"version":3,"file":"segmentation.cjs","names":[],"sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/**\n * Segmentation head postprocessing: YOLO instance-segmentation decoding.\n *\n * Compatible with YOLOv8-seg / YOLOv11-seg exports (and any later seg head\n * sharing the layout). The model produces two output tensors:\n *\n * - `output0` of shape `(1, 4 + numClasses + numMaskCoefs, numAnchors)` — the\n *   same per-anchor predictions as plain YOLO detection plus an extra\n *   `numMaskCoefs` (typically 32) channels of mask coefficients.\n * - `output1` of shape `(1, numMaskCoefs, maskH, maskW)` — a set of \"prototype\"\n *   masks shared across all anchors.\n *\n * The per-anchor decode (xywh→xyxy, undo letterbox, per-class NMS, sort & cap)\n * is delegated to {@link decodeYoloAnchors}; this module only handles the\n * mask-specific work: matmul against prototypes, sigmoid, bilinear resize and\n * thresholding.\n */\n\nimport { decodeYoloAnchors } from \"./detection\";\nimport { BoundingBox, Mask } from \"../types\";\n\nexport interface DecodeYoloSegOptions {\n    readonly numClasses: number;\n    /** Model input `[width, height]` (post-letterbox). */\n    readonly inputWidth: number;\n    readonly inputHeight: number;\n    /** Original image `[width, height]`. */\n    readonly originalWidth: number;\n    readonly originalHeight: number;\n    /** Letterbox horizontal padding in input-tensor pixels. */\n    readonly padLeft: number;\n    /** Letterbox vertical padding in input-tensor pixels. */\n    readonly padTop: number;\n    /** Letterbox scale factor. */\n    readonly scale: number;\n    readonly confThreshold: number;\n    readonly iouThreshold: number;\n    readonly maxDetections: number;\n    /** Probability cutoff applied to the soft mask. Defaults to `0.5`. */\n    readonly maskThreshold?: number;\n}\n\nexport interface DecodedSegmentation {\n    readonly bbox: BoundingBox;\n    readonly classId: number;\n    readonly confidence: number;\n    /** Binary mask cropped to `bbox`. Width/height match `bbox.asIntXyxy()` extents. */\n    readonly mask: Mask;\n}\n\n/**\n * Decode YOLO segmentation raw outputs into a list of segmented instances.\n *\n * Compatible with YOLOv8-seg / YOLOv11-seg.\n *\n * @param perAnchorData Flat `output0`, length `(4 + numClasses + numMaskCoefs) * numAnchors`.\n * @param perAnchorDims Dims as reported by ORT, e.g. `[1, 116, 8400]`.\n * @param prototypeData Flat `output1`, length `numMaskCoefs * maskH * maskW`.\n * @param prototypeDims Dims as reported by ORT, e.g. `[1, 32, 160, 160]`.\n */\nexport function decodeYoloSeg(\n    perAnchorData: Float32Array,\n    perAnchorDims: readonly number[],\n    prototypeData: Float32Array,\n    prototypeDims: readonly number[],\n    options: DecodeYoloSegOptions,\n): DecodedSegmentation[] {\n    // Strip batch dim from prototypes; perAnchor batch is validated by the helper.\n    let pDims = prototypeDims;\n    if (pDims.length === 4) {\n        if (pDims[0] !== 1) {\n            throw new Error(`decodeYoloSeg: expected batch size 1 in prototypes, got ${pDims[0]}.`);\n        }\n        pDims = [pDims[1] as number, pDims[2] as number, pDims[3] as number];\n    }\n    if (pDims.length !== 3) {\n        throw new Error(\n            `decodeYoloSeg: expected 3-D prototypes after batch removal, got dims=${JSON.stringify(prototypeDims)}.`,\n        );\n    }\n    const numMaskCoefs = pDims[0] as number;\n    const maskH = pDims[1] as number;\n    const maskW = pDims[2] as number;\n\n    const channels = perAnchorDims.length === 3 ? perAnchorDims[1] : perAnchorDims[0];\n    const numAnchors = perAnchorDims.length === 3 ? perAnchorDims[2] : perAnchorDims[1];\n    if (channels === undefined || numAnchors === undefined) {\n        throw new Error(\n            `decodeYoloSeg: cannot read channels/numAnchors from dims=${JSON.stringify(perAnchorDims)}.`,\n        );\n    }\n\n    const expectedChannels = 4 + options.numClasses + numMaskCoefs;\n    if (channels !== expectedChannels) {\n        throw new Error(\n            `decodeYoloSeg: channels=${channels} does not match 4 + numClasses(${options.numClasses}) + numMaskCoefs(${numMaskCoefs}) = ${expectedChannels}.`,\n        );\n    }\n    if (prototypeData.length !== numMaskCoefs * maskH * maskW) {\n        throw new Error(\n            `decodeYoloSeg: prototype length ${prototypeData.length} does not match dims=${JSON.stringify(prototypeDims)}.`,\n        );\n    }\n\n    const decoded = decodeYoloAnchors(perAnchorData, perAnchorDims, {\n        numClasses: options.numClasses,\n        originalWidth: options.originalWidth,\n        originalHeight: options.originalHeight,\n        padLeft: options.padLeft,\n        padTop: options.padTop,\n        scale: options.scale,\n        confThreshold: options.confThreshold,\n        iouThreshold: options.iouThreshold,\n        maxDetections: options.maxDetections,\n    });\n\n    if (decoded.anchorIndices.length === 0) return [];\n\n    const maskThreshold = options.maskThreshold ?? 0.5;\n    const scaleX = maskW / options.inputWidth;\n    const scaleY = maskH / options.inputHeight;\n    const protoPlane = maskH * maskW;\n    const coefBase = (4 + options.numClasses) * numAnchors;\n\n    const results: DecodedSegmentation[] = [];\n\n    for (let i = 0; i < decoded.anchorIndices.length; i++) {\n        const a = decoded.anchorIndices[i] as number;\n        const x1 = decoded.boxesXyxy[i * 4] as number;\n        const y1 = decoded.boxesXyxy[i * 4 + 1] as number;\n        const x2 = decoded.boxesXyxy[i * 4 + 2] as number;\n        const y2 = decoded.boxesXyxy[i * 4 + 3] as number;\n        const bbox = new BoundingBox(x1, y1, x2, y2);\n        const classId = decoded.classIds[i] as number;\n        const confidence = decoded.confidences[i] as number;\n\n        const bboxW = Math.max(0, Math.trunc(x2) - Math.trunc(x1));\n        const bboxH = Math.max(0, Math.trunc(y2) - Math.trunc(y1));\n\n        if (bboxW === 0 || bboxH === 0) {\n            results.push({ bbox, classId, confidence, mask: new Mask(new Uint8Array(0), 0, 0) });\n            continue;\n        }\n\n        // Bbox in input-tensor coords, then in low-res mask coords.\n        const ibx1 = x1 * options.scale + options.padLeft;\n        const iby1 = y1 * options.scale + options.padTop;\n        const ibx2 = x2 * options.scale + options.padLeft;\n        const iby2 = y2 * options.scale + options.padTop;\n\n        const mbx1 = Math.max(0, Math.floor(ibx1 * scaleX));\n        const mby1 = Math.max(0, Math.floor(iby1 * scaleY));\n        const mbx2 = Math.min(maskW, Math.ceil(ibx2 * scaleX));\n        const mby2 = Math.min(maskH, Math.ceil(iby2 * scaleY));\n\n        if (mbx2 <= mbx1 || mby2 <= mby1) {\n            results.push({\n                bbox,\n                classId,\n                confidence,\n                mask: new Mask(new Uint8Array(bboxW * bboxH), bboxW, bboxH),\n            });\n            continue;\n        }\n\n        // Compute soft mask only within the prototype region under this bbox.\n        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = new Float32Array(cropW * cropH);\n        for (let y = 0; y < cropH; y++) {\n            const py = mby1 + y;\n            for (let x = 0; x < cropW; x++) {\n                const px = mbx1 + x;\n                let sum = 0;\n                for (let kk = 0; kk < numMaskCoefs; kk++) {\n                    const coef = perAnchorData[coefBase + kk * numAnchors + a];\n                    const proto = prototypeData[kk * protoPlane + py * maskW + px];\n                    sum += coef * proto;\n                }\n                softCrop[y * cropW + x] = sigmoid(sum);\n            }\n        }\n\n        const resized = resizeBilinear(softCrop, cropW, cropH, bboxW, bboxH);\n        const binary = new Uint8Array(bboxW * bboxH);\n        for (let j = 0; j < binary.length; j++) {\n            binary[j] = resized[j] >= maskThreshold ? 255 : 0;\n        }\n\n        results.push({ bbox, classId, confidence, mask: new Mask(binary, bboxW, bboxH) });\n    }\n\n    return results;\n}\n\nfunction sigmoid(x: number): number {\n    if (x >= 0) {\n        return 1 / (1 + Math.exp(-x));\n    }\n    const e = Math.exp(x);\n    return e / (1 + e);\n}\n\nlet _warnedDecodeYoloV8Seg = false;\n\n/** @deprecated since 0.2.0 — use {@link decodeYoloSeg}. Will be removed in 0.3.0. */\nexport function decodeYoloV8Seg(\n    perAnchorData: Float32Array,\n    perAnchorDims: readonly number[],\n    prototypeData: Float32Array,\n    prototypeDims: readonly number[],\n    options: DecodeYoloSegOptions,\n): DecodedSegmentation[] {\n    if (!_warnedDecodeYoloV8Seg) {\n        _warnedDecodeYoloV8Seg = true;\n        console.warn(\n            \"[@ort-vision-sdk/web] decodeYoloV8Seg is deprecated since 0.2.0; use decodeYoloSeg. \" +\n                \"The alias will be removed in 0.3.0.\",\n        );\n    }\n    return decodeYoloSeg(perAnchorData, perAnchorDims, prototypeData, prototypeDims, options);\n}\n\n/** @deprecated since 0.2.0 — use {@link DecodeYoloSegOptions}. */\nexport type DecodeYoloV8SegOptions = DecodeYoloSegOptions;\n\nfunction resizeBilinear(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n): Float32Array {\n    const out = new Float32Array(targetWidth * targetHeight);\n    if (targetWidth === 0 || targetHeight === 0 || srcWidth === 0 || srcHeight === 0) {\n        return out;\n    }\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        out.set(src);\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    for (let y = 0; y < targetHeight; y++) {\n        const yy = (y + 0.5) * sy - 0.5;\n        const y0 = Math.max(0, Math.floor(yy));\n        const y1 = Math.min(srcHeight - 1, y0 + 1);\n        const wy = Math.max(0, Math.min(1, yy - y0));\n        for (let x = 0; x < targetWidth; x++) {\n            const xx = (x + 0.5) * sx - 0.5;\n            const x0 = Math.max(0, Math.floor(xx));\n            const x1 = Math.min(srcWidth - 1, x0 + 1);\n            const wx = Math.max(0, Math.min(1, xx - x0));\n            const v00 = src[y0 * srcWidth + x0];\n            const v01 = src[y0 * srcWidth + x1];\n            const v10 = src[y1 * srcWidth + x0];\n            const v11 = src[y1 * srcWidth + x1];\n            const top = v00 * (1 - wx) + v01 * wx;\n            const bot = v10 * (1 - wx) + v11 * wx;\n            out[y * targetWidth + x] = top * (1 - wy) + bot * wy;\n        }\n    }\n    return out;\n}\n"],"mappings":"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"}