tempest-react-sdk 0.78.0 → 0.79.0

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

@@ -1 +1 @@
-{"version":3,"file":"detection.cjs","names":[],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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. Boxes tied on\n *   score are visited lowest-index first, so the survivor of a tie is\n *   deterministic and matches both `torchvision` and the Python SDK.\n *\n * The boxes are copied once into score order, so the inner loop walks a\n * contiguous `Float32Array` instead of hopping through `order` into the caller's\n * layout. A pair with no horizontal overlap is skipped before the vertical\n * extent is computed: its IoU is `0`, which suppresses nothing for any\n * non-negative threshold — the shortcut is gated on that so a negative\n * threshold keeps the exact semantics.\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 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) || a - b);\n\n    const sorted = new Float32Array(n * 4);\n    const areas = new Float32Array(n);\n    for (let k = 0; k < n; k++) {\n        const i = (order[k] as number) * 4;\n        const x1 = boxes[i] as number;\n        const y1 = boxes[i + 1] as number;\n        const x2 = boxes[i + 2] as number;\n        const y2 = boxes[i + 3] as number;\n        sorted[k * 4] = x1;\n        sorted[k * 4 + 1] = y1;\n        sorted[k * 4 + 2] = x2;\n        sorted[k * 4 + 3] = y2;\n        areas[k] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const skipDisjoint = iouThreshold >= 0;\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let k = 0; k < n; k++) {\n        if (suppressed[k]) continue;\n        keep.push(order[k] as number);\n\n        const ax1 = sorted[k * 4] as number;\n        const ay1 = sorted[k * 4 + 1] as number;\n        const ax2 = sorted[k * 4 + 2] as number;\n        const ay2 = sorted[k * 4 + 3] as number;\n        const ak = areas[k] as number;\n\n        for (let m = k + 1; m < n; m++) {\n            if (suppressed[m]) continue;\n            const bx1 = sorted[m * 4] as number;\n            const by1 = sorted[m * 4 + 1] as number;\n            const bx2 = sorted[m * 4 + 2] as number;\n            const by2 = sorted[m * 4 + 3] as number;\n            const iw = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));\n            if (iw === 0 && skipDisjoint) continue;\n            const ih = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));\n            const inter = iw * ih;\n            const union = ak + (areas[m] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[m] = 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 * @returns Indices of kept boxes, sorted by descending score across all\n *   classes. Survivors from different classes that are tied on score are\n *   ordered lowest-index first — an explicit tie-break, because the order the\n *   per-class loop emits them in is an implementation detail (here, `Map`\n *   insertion order; in Python, sorted class order).\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) || a - b);\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 * Candidates are found in two passes, mirroring the Python decoder. The first\n * walks each class row contiguously and only *marks* anchors holding some score\n * at or above the threshold — an anchor's best score clears the threshold\n * exactly when one of its scores does, so no running maximum is needed and the\n * hot loop never writes on a typical frame. The anchor-major scan it replaces\n * read `numClasses` values spaced `numAnchors` apart for every one of the 8400\n * anchors and cost ~1 ms even on a frame with no candidates. The winning class\n * is then picked only for the marked anchors — a few hundred, not 8400 — with\n * the same strict `>` that keeps the lowest class id on a tie.\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    const hit = new Uint8Array(numAnchors);\n    const classEnd = (4 + numClasses) * numAnchors;\n    for (let row = 4 * numAnchors; row < classEnd; row += numAnchors) {\n        for (let a = 0; a < numAnchors; a++) {\n            if ((data[row + a] as number) >= confThreshold) hit[a] = 1;\n        }\n    }\n\n    let count = 0;\n    const candidateAnchors = new Int32Array(numAnchors);\n    for (let a = 0; a < numAnchors; a++) {\n        if (hit[a] === 1) candidateAnchors[count++] = a;\n    }\n    if (count === 0) return emptyDecoded();\n\n    const flatBoxes = new Float32Array(count * 4);\n    const scoresArr = new Float32Array(count);\n    const idxsArr = new Int32Array(count);\n    for (let i = 0; i < count; i++) {\n        const a = candidateAnchors[i] as number;\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        const x1 = (cx - w / 2 - padLeft) / scale;\n        const y1 = (cy - h / 2 - padTop) / scale;\n        const x2 = (cx + w / 2 - padLeft) / scale;\n        const y2 = (cy + h / 2 - padTop) / scale;\n        flatBoxes[i * 4] = Math.max(0, Math.min(originalWidth, x1));\n        flatBoxes[i * 4 + 1] = Math.max(0, Math.min(originalHeight, y1));\n        flatBoxes[i * 4 + 2] = Math.max(0, Math.min(originalWidth, x2));\n        flatBoxes[i * 4 + 3] = Math.max(0, Math.min(originalHeight, y2));\n        let bestScore = -Infinity;\n        let bestClass = 0;\n        for (let c = 0, at = 4 * numAnchors + a; c < numClasses; c++, at += numAnchors) {\n            const score = data[at] as number;\n            if (score > bestScore) {\n                bestScore = score;\n                bestClass = c;\n            }\n        }\n        scoresArr[i] = bestScore;\n        idxsArr[i] = bestClass;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const k = Math.min(kept.length, maxDetections);\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 j = kept[i] as number;\n        anchorIndices[i] = candidateAnchors[j] as number;\n        boxesXyxy[i * 4] = flatBoxes[j * 4] as number;\n        boxesXyxy[i * 4 + 1] = flatBoxes[j * 4 + 1] as number;\n        boxesXyxy[i * 4 + 2] = flatBoxes[j * 4 + 2] as number;\n        boxesXyxy[i * 4 + 3] = flatBoxes[j * 4 + 3] as number;\n        classIds[i] = idxsArr[j] as number;\n        confidences[i] = scoresArr[j] as number;\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"],"mappings":"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"}
+{"version":3,"file":"detection.cjs","names":["BoundingBox","require_types","nms","n","scores","order","i","b","a","sorted","areas","k","x1","boxes","y1","x2","y2","skipDisjoint","iouThreshold","suppressed","keep","ax1","ay1","ax2","ay2","ak","m","bx1","by1","bx2","by2","iw","inter","union","batchedNms","byClass","idxs","c","list","indices","subBoxes","subScores","subKeep","decodeYoloAnchors","normalized","dims","channels","numAnchors","options","numClasses","data","hit","classEnd","row","confThreshold","count","candidateAnchors","emptyDecoded","flatBoxes","scoresArr","idxsArr","cx","cy","w","h","padLeft","scale","padTop","originalWidth","originalHeight","bestScore","bestClass","at","score","kept","maxDetections","anchorIndices","boxesXyxy","classIds","confidences","j","decodeYolo","outputDims","decoded","output","results"],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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. Boxes tied on\n *   score are visited lowest-index first, so the survivor of a tie is\n *   deterministic and matches both `torchvision` and the Python SDK.\n *\n * The boxes are copied once into score order, so the inner loop walks a\n * contiguous `Float32Array` instead of hopping through `order` into the caller's\n * layout. A pair with no horizontal overlap is skipped before the vertical\n * extent is computed: its IoU is `0`, which suppresses nothing for any\n * non-negative threshold — the shortcut is gated on that so a negative\n * threshold keeps the exact semantics.\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 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) || a - b);\n\n    const sorted = new Float32Array(n * 4);\n    const areas = new Float32Array(n);\n    for (let k = 0; k < n; k++) {\n        const i = (order[k] as number) * 4;\n        const x1 = boxes[i] as number;\n        const y1 = boxes[i + 1] as number;\n        const x2 = boxes[i + 2] as number;\n        const y2 = boxes[i + 3] as number;\n        sorted[k * 4] = x1;\n        sorted[k * 4 + 1] = y1;\n        sorted[k * 4 + 2] = x2;\n        sorted[k * 4 + 3] = y2;\n        areas[k] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const skipDisjoint = iouThreshold >= 0;\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let k = 0; k < n; k++) {\n        if (suppressed[k]) continue;\n        keep.push(order[k] as number);\n\n        const ax1 = sorted[k * 4] as number;\n        const ay1 = sorted[k * 4 + 1] as number;\n        const ax2 = sorted[k * 4 + 2] as number;\n        const ay2 = sorted[k * 4 + 3] as number;\n        const ak = areas[k] as number;\n\n        for (let m = k + 1; m < n; m++) {\n            if (suppressed[m]) continue;\n            const bx1 = sorted[m * 4] as number;\n            const by1 = sorted[m * 4 + 1] as number;\n            const bx2 = sorted[m * 4 + 2] as number;\n            const by2 = sorted[m * 4 + 3] as number;\n            const iw = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));\n            if (iw === 0 && skipDisjoint) continue;\n            const ih = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));\n            const inter = iw * ih;\n            const union = ak + (areas[m] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[m] = 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 * @returns Indices of kept boxes, sorted by descending score across all\n *   classes. Survivors from different classes that are tied on score are\n *   ordered lowest-index first — an explicit tie-break, because the order the\n *   per-class loop emits them in is an implementation detail (here, `Map`\n *   insertion order; in Python, sorted class order).\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) || a - b);\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 * Candidates are found in two passes, mirroring the Python decoder. The first\n * walks each class row contiguously and only *marks* anchors holding some score\n * at or above the threshold — an anchor's best score clears the threshold\n * exactly when one of its scores does, so no running maximum is needed and the\n * hot loop never writes on a typical frame. The anchor-major scan it replaces\n * read `numClasses` values spaced `numAnchors` apart for every one of the 8400\n * anchors and cost ~1 ms even on a frame with no candidates. The winning class\n * is then picked only for the marked anchors — a few hundred, not 8400 — with\n * the same strict `>` that keeps the lowest class id on a tie.\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    const hit = new Uint8Array(numAnchors);\n    const classEnd = (4 + numClasses) * numAnchors;\n    for (let row = 4 * numAnchors; row < classEnd; row += numAnchors) {\n        for (let a = 0; a < numAnchors; a++) {\n            if ((data[row + a] as number) >= confThreshold) hit[a] = 1;\n        }\n    }\n\n    let count = 0;\n    const candidateAnchors = new Int32Array(numAnchors);\n    for (let a = 0; a < numAnchors; a++) {\n        if (hit[a] === 1) candidateAnchors[count++] = a;\n    }\n    if (count === 0) return emptyDecoded();\n\n    const flatBoxes = new Float32Array(count * 4);\n    const scoresArr = new Float32Array(count);\n    const idxsArr = new Int32Array(count);\n    for (let i = 0; i < count; i++) {\n        const a = candidateAnchors[i] as number;\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        const x1 = (cx - w / 2 - padLeft) / scale;\n        const y1 = (cy - h / 2 - padTop) / scale;\n        const x2 = (cx + w / 2 - padLeft) / scale;\n        const y2 = (cy + h / 2 - padTop) / scale;\n        flatBoxes[i * 4] = Math.max(0, Math.min(originalWidth, x1));\n        flatBoxes[i * 4 + 1] = Math.max(0, Math.min(originalHeight, y1));\n        flatBoxes[i * 4 + 2] = Math.max(0, Math.min(originalWidth, x2));\n        flatBoxes[i * 4 + 3] = Math.max(0, Math.min(originalHeight, y2));\n        let bestScore = -Infinity;\n        let bestClass = 0;\n        for (let c = 0, at = 4 * numAnchors + a; c < numClasses; c++, at += numAnchors) {\n            const score = data[at] as number;\n            if (score > bestScore) {\n                bestScore = score;\n                bestClass = c;\n            }\n        }\n        scoresArr[i] = bestScore;\n        idxsArr[i] = bestClass;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const k = Math.min(kept.length, maxDetections);\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 j = kept[i] as number;\n        anchorIndices[i] = candidateAnchors[j] as number;\n        boxesXyxy[i * 4] = flatBoxes[j * 4] as number;\n        boxesXyxy[i * 4 + 1] = flatBoxes[j * 4 + 1] as number;\n        boxesXyxy[i * 4 + 2] = flatBoxes[j * 4 + 2] as number;\n        boxesXyxy[i * 4 + 3] = flatBoxes[j * 4 + 3] as number;\n        classIds[i] = idxsArr[j] as number;\n        confidences[i] = scoresArr[j] as number;\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"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"detection.js","names":[],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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. Boxes tied on\n *   score are visited lowest-index first, so the survivor of a tie is\n *   deterministic and matches both `torchvision` and the Python SDK.\n *\n * The boxes are copied once into score order, so the inner loop walks a\n * contiguous `Float32Array` instead of hopping through `order` into the caller's\n * layout. A pair with no horizontal overlap is skipped before the vertical\n * extent is computed: its IoU is `0`, which suppresses nothing for any\n * non-negative threshold — the shortcut is gated on that so a negative\n * threshold keeps the exact semantics.\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 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) || a - b);\n\n    const sorted = new Float32Array(n * 4);\n    const areas = new Float32Array(n);\n    for (let k = 0; k < n; k++) {\n        const i = (order[k] as number) * 4;\n        const x1 = boxes[i] as number;\n        const y1 = boxes[i + 1] as number;\n        const x2 = boxes[i + 2] as number;\n        const y2 = boxes[i + 3] as number;\n        sorted[k * 4] = x1;\n        sorted[k * 4 + 1] = y1;\n        sorted[k * 4 + 2] = x2;\n        sorted[k * 4 + 3] = y2;\n        areas[k] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const skipDisjoint = iouThreshold >= 0;\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let k = 0; k < n; k++) {\n        if (suppressed[k]) continue;\n        keep.push(order[k] as number);\n\n        const ax1 = sorted[k * 4] as number;\n        const ay1 = sorted[k * 4 + 1] as number;\n        const ax2 = sorted[k * 4 + 2] as number;\n        const ay2 = sorted[k * 4 + 3] as number;\n        const ak = areas[k] as number;\n\n        for (let m = k + 1; m < n; m++) {\n            if (suppressed[m]) continue;\n            const bx1 = sorted[m * 4] as number;\n            const by1 = sorted[m * 4 + 1] as number;\n            const bx2 = sorted[m * 4 + 2] as number;\n            const by2 = sorted[m * 4 + 3] as number;\n            const iw = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));\n            if (iw === 0 && skipDisjoint) continue;\n            const ih = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));\n            const inter = iw * ih;\n            const union = ak + (areas[m] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[m] = 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 * @returns Indices of kept boxes, sorted by descending score across all\n *   classes. Survivors from different classes that are tied on score are\n *   ordered lowest-index first — an explicit tie-break, because the order the\n *   per-class loop emits them in is an implementation detail (here, `Map`\n *   insertion order; in Python, sorted class order).\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) || a - b);\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 * Candidates are found in two passes, mirroring the Python decoder. The first\n * walks each class row contiguously and only *marks* anchors holding some score\n * at or above the threshold — an anchor's best score clears the threshold\n * exactly when one of its scores does, so no running maximum is needed and the\n * hot loop never writes on a typical frame. The anchor-major scan it replaces\n * read `numClasses` values spaced `numAnchors` apart for every one of the 8400\n * anchors and cost ~1 ms even on a frame with no candidates. The winning class\n * is then picked only for the marked anchors — a few hundred, not 8400 — with\n * the same strict `>` that keeps the lowest class id on a tie.\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    const hit = new Uint8Array(numAnchors);\n    const classEnd = (4 + numClasses) * numAnchors;\n    for (let row = 4 * numAnchors; row < classEnd; row += numAnchors) {\n        for (let a = 0; a < numAnchors; a++) {\n            if ((data[row + a] as number) >= confThreshold) hit[a] = 1;\n        }\n    }\n\n    let count = 0;\n    const candidateAnchors = new Int32Array(numAnchors);\n    for (let a = 0; a < numAnchors; a++) {\n        if (hit[a] === 1) candidateAnchors[count++] = a;\n    }\n    if (count === 0) return emptyDecoded();\n\n    const flatBoxes = new Float32Array(count * 4);\n    const scoresArr = new Float32Array(count);\n    const idxsArr = new Int32Array(count);\n    for (let i = 0; i < count; i++) {\n        const a = candidateAnchors[i] as number;\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        const x1 = (cx - w / 2 - padLeft) / scale;\n        const y1 = (cy - h / 2 - padTop) / scale;\n        const x2 = (cx + w / 2 - padLeft) / scale;\n        const y2 = (cy + h / 2 - padTop) / scale;\n        flatBoxes[i * 4] = Math.max(0, Math.min(originalWidth, x1));\n        flatBoxes[i * 4 + 1] = Math.max(0, Math.min(originalHeight, y1));\n        flatBoxes[i * 4 + 2] = Math.max(0, Math.min(originalWidth, x2));\n        flatBoxes[i * 4 + 3] = Math.max(0, Math.min(originalHeight, y2));\n        let bestScore = -Infinity;\n        let bestClass = 0;\n        for (let c = 0, at = 4 * numAnchors + a; c < numClasses; c++, at += numAnchors) {\n            const score = data[at] as number;\n            if (score > bestScore) {\n                bestScore = score;\n                bestClass = c;\n            }\n        }\n        scoresArr[i] = bestScore;\n        idxsArr[i] = bestClass;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const k = Math.min(kept.length, maxDetections);\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 j = kept[i] as number;\n        anchorIndices[i] = candidateAnchors[j] as number;\n        boxesXyxy[i * 4] = flatBoxes[j * 4] as number;\n        boxesXyxy[i * 4 + 1] = flatBoxes[j * 4 + 1] as number;\n        boxesXyxy[i * 4 + 2] = flatBoxes[j * 4 + 2] as number;\n        boxesXyxy[i * 4 + 3] = flatBoxes[j * 4 + 3] as number;\n        classIds[i] = idxsArr[j] as number;\n        confidences[i] = scoresArr[j] as number;\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"],"mappings":"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"}
+{"version":3,"file":"detection.js","names":["nms","n","scores","order","i","b","a","sorted","areas","k","x1","boxes","y1","x2","y2","skipDisjoint","iouThreshold","suppressed","keep","ax1","ay1","ax2","ay2","ak","m","bx1","by1","bx2","by2","iw","inter","union","batchedNms","byClass","idxs","c","list","indices","subBoxes","subScores","subKeep","decodeYoloAnchors","normalized","dims","channels","numAnchors","options","numClasses","data","hit","classEnd","row","confThreshold","count","candidateAnchors","emptyDecoded","flatBoxes","scoresArr","idxsArr","cx","cy","w","h","padLeft","scale","padTop","originalWidth","originalHeight","bestScore","bestClass","at","score","kept","maxDetections","anchorIndices","boxesXyxy","classIds","confidences","j","decodeYolo","outputDims","decoded","output","results","BoundingBox"],"sources":["../../../src/vision/postprocess/detection.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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. Boxes tied on\n *   score are visited lowest-index first, so the survivor of a tie is\n *   deterministic and matches both `torchvision` and the Python SDK.\n *\n * The boxes are copied once into score order, so the inner loop walks a\n * contiguous `Float32Array` instead of hopping through `order` into the caller's\n * layout. A pair with no horizontal overlap is skipped before the vertical\n * extent is computed: its IoU is `0`, which suppresses nothing for any\n * non-negative threshold — the shortcut is gated on that so a negative\n * threshold keeps the exact semantics.\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 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) || a - b);\n\n    const sorted = new Float32Array(n * 4);\n    const areas = new Float32Array(n);\n    for (let k = 0; k < n; k++) {\n        const i = (order[k] as number) * 4;\n        const x1 = boxes[i] as number;\n        const y1 = boxes[i + 1] as number;\n        const x2 = boxes[i + 2] as number;\n        const y2 = boxes[i + 3] as number;\n        sorted[k * 4] = x1;\n        sorted[k * 4 + 1] = y1;\n        sorted[k * 4 + 2] = x2;\n        sorted[k * 4 + 3] = y2;\n        areas[k] = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);\n    }\n\n    const skipDisjoint = iouThreshold >= 0;\n    const suppressed = new Uint8Array(n);\n    const keep: number[] = [];\n\n    for (let k = 0; k < n; k++) {\n        if (suppressed[k]) continue;\n        keep.push(order[k] as number);\n\n        const ax1 = sorted[k * 4] as number;\n        const ay1 = sorted[k * 4 + 1] as number;\n        const ax2 = sorted[k * 4 + 2] as number;\n        const ay2 = sorted[k * 4 + 3] as number;\n        const ak = areas[k] as number;\n\n        for (let m = k + 1; m < n; m++) {\n            if (suppressed[m]) continue;\n            const bx1 = sorted[m * 4] as number;\n            const by1 = sorted[m * 4 + 1] as number;\n            const bx2 = sorted[m * 4 + 2] as number;\n            const by2 = sorted[m * 4 + 3] as number;\n            const iw = Math.max(0, Math.min(ax2, bx2) - Math.max(ax1, bx1));\n            if (iw === 0 && skipDisjoint) continue;\n            const ih = Math.max(0, Math.min(ay2, by2) - Math.max(ay1, by1));\n            const inter = iw * ih;\n            const union = ak + (areas[m] as number) - inter;\n            const iou = union > 0 ? inter / union : 0;\n            if (iou > iouThreshold) suppressed[m] = 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 * @returns Indices of kept boxes, sorted by descending score across all\n *   classes. Survivors from different classes that are tied on score are\n *   ordered lowest-index first — an explicit tie-break, because the order the\n *   per-class loop emits them in is an implementation detail (here, `Map`\n *   insertion order; in Python, sorted class order).\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) || a - b);\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 * Candidates are found in two passes, mirroring the Python decoder. The first\n * walks each class row contiguously and only *marks* anchors holding some score\n * at or above the threshold — an anchor's best score clears the threshold\n * exactly when one of its scores does, so no running maximum is needed and the\n * hot loop never writes on a typical frame. The anchor-major scan it replaces\n * read `numClasses` values spaced `numAnchors` apart for every one of the 8400\n * anchors and cost ~1 ms even on a frame with no candidates. The winning class\n * is then picked only for the marked anchors — a few hundred, not 8400 — with\n * the same strict `>` that keeps the lowest class id on a tie.\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    const hit = new Uint8Array(numAnchors);\n    const classEnd = (4 + numClasses) * numAnchors;\n    for (let row = 4 * numAnchors; row < classEnd; row += numAnchors) {\n        for (let a = 0; a < numAnchors; a++) {\n            if ((data[row + a] as number) >= confThreshold) hit[a] = 1;\n        }\n    }\n\n    let count = 0;\n    const candidateAnchors = new Int32Array(numAnchors);\n    for (let a = 0; a < numAnchors; a++) {\n        if (hit[a] === 1) candidateAnchors[count++] = a;\n    }\n    if (count === 0) return emptyDecoded();\n\n    const flatBoxes = new Float32Array(count * 4);\n    const scoresArr = new Float32Array(count);\n    const idxsArr = new Int32Array(count);\n    for (let i = 0; i < count; i++) {\n        const a = candidateAnchors[i] as number;\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        const x1 = (cx - w / 2 - padLeft) / scale;\n        const y1 = (cy - h / 2 - padTop) / scale;\n        const x2 = (cx + w / 2 - padLeft) / scale;\n        const y2 = (cy + h / 2 - padTop) / scale;\n        flatBoxes[i * 4] = Math.max(0, Math.min(originalWidth, x1));\n        flatBoxes[i * 4 + 1] = Math.max(0, Math.min(originalHeight, y1));\n        flatBoxes[i * 4 + 2] = Math.max(0, Math.min(originalWidth, x2));\n        flatBoxes[i * 4 + 3] = Math.max(0, Math.min(originalHeight, y2));\n        let bestScore = -Infinity;\n        let bestClass = 0;\n        for (let c = 0, at = 4 * numAnchors + a; c < numClasses; c++, at += numAnchors) {\n            const score = data[at] as number;\n            if (score > bestScore) {\n                bestScore = score;\n                bestClass = c;\n            }\n        }\n        scoresArr[i] = bestScore;\n        idxsArr[i] = bestClass;\n    }\n    const kept = batchedNms(flatBoxes, scoresArr, idxsArr, iouThreshold);\n    if (kept.length === 0) return emptyDecoded();\n\n    const k = Math.min(kept.length, maxDetections);\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 j = kept[i] as number;\n        anchorIndices[i] = candidateAnchors[j] as number;\n        boxesXyxy[i * 4] = flatBoxes[j * 4] as number;\n        boxesXyxy[i * 4 + 1] = flatBoxes[j * 4 + 1] as number;\n        boxesXyxy[i * 4 + 2] = flatBoxes[j * 4 + 2] as number;\n        boxesXyxy[i * 4 + 3] = flatBoxes[j * 4 + 3] as number;\n        classIds[i] = idxsArr[j] as number;\n        confidences[i] = scoresArr[j] as number;\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"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"segmentation.cjs","names":[],"sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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 * The prototypes' batch axis is stripped here; the per-anchor batch axis is\n * validated by {@link decodeYoloAnchors}. Each instance's box is mapped back\n * into input-tensor coordinates and from there into the low-resolution\n * prototype grid, and only the prototype pixels under it are assembled.\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    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        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        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = softMaskCrop(\n            perAnchorData,\n            prototypeData,\n            coefBase + a,\n            numAnchors,\n            numMaskCoefs,\n            maskW,\n            protoPlane,\n            mbx1,\n            mby1,\n            cropW,\n            cropH,\n        );\n        const binary = resizeBilinearThreshold(softCrop, cropW, cropH, bboxW, bboxH, maskThreshold);\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\n/**\n * Assemble one instance's soft mask over the prototype region under its box.\n *\n * The loop runs coefficient-major: for each of the `numMaskCoefs` prototypes it\n * walks the crop row by row, so every read of `prototypeData` is contiguous.\n * The pixel-major order it replaces jumped a whole prototype plane (25 600\n * floats for a 160×160 head) between consecutive reads, touching a fresh cache\n * line on every multiply. The accumulator is a `Float64Array` so each pixel's\n * sum is still built in double precision and in the same coefficient order as a\n * scalar `let sum = 0` — the result is bit-identical, only the memory walk\n * changed.\n *\n * @param perAnchorData Flat `output0`.\n * @param prototypeData Flat `output1`.\n * @param coefOffset Index of this anchor's first mask coefficient.\n * @param numAnchors Stride between consecutive coefficients of one anchor.\n * @param numMaskCoefs Number of prototypes.\n * @param maskW Prototype width.\n * @param protoPlane Prototype plane size, `maskW * maskH`.\n * @param left First prototype column of the crop.\n * @param top First prototype row of the crop.\n * @param cropW Crop width in prototype pixels.\n * @param cropH Crop height in prototype pixels.\n * @returns The sigmoid of the mask logits, `cropW * cropH`, row-major.\n */\nfunction softMaskCrop(\n    perAnchorData: Float32Array,\n    prototypeData: Float32Array,\n    coefOffset: number,\n    numAnchors: number,\n    numMaskCoefs: number,\n    maskW: number,\n    protoPlane: number,\n    left: number,\n    top: number,\n    cropW: number,\n    cropH: number,\n): Float32Array {\n    const acc = new Float64Array(cropW * cropH);\n    for (let kk = 0; kk < numMaskCoefs; kk++) {\n        const coef = perAnchorData[coefOffset + kk * numAnchors] as number;\n        const planeBase = kk * protoPlane + left;\n        for (let y = 0; y < cropH; y++) {\n            const src = planeBase + (top + y) * maskW;\n            const dst = y * cropW;\n            for (let x = 0; x < cropW; x++) {\n                acc[dst + x] = (acc[dst + x] as number) + coef * (prototypeData[src + x] as number);\n            }\n        }\n    }\n    const soft = new Float32Array(acc.length);\n    for (let j = 0; j < acc.length; j++) soft[j] = sigmoid(acc[j] as number);\n    return soft;\n}\n\n/**\n * Bilinearly resize a soft mask and threshold it in the same pass.\n *\n * Half-pixel-centre sampling, matching `cv2.resize(..., INTER_LINEAR)` and the\n * Python SDK. The interpolation is separable and runs that way, like the\n * Python `_resize_bilinear`: first along x over the few source rows, into a\n * `Float64Array` so every horizontal blend keeps its exact double value, then\n * along y between two of those rows. Each output pixel costs two reads and one\n * blend instead of four reads and three, with the same values as blending all\n * four directly. The thresholded byte is written directly instead of\n * materialising a `Float32Array` of the resized mask first.\n * Each interpolated value is rounded to float32 with `Math.fround` before the\n * comparison, because that is the value the intermediate array used to hold —\n * comparing the unrounded double would flip pixels sitting exactly on the\n * threshold.\n *\n * @param src Soft mask, `srcWidth * srcHeight`, row-major.\n * @param srcWidth Source width.\n * @param srcHeight Source height.\n * @param targetWidth Output width, at least 1.\n * @param targetHeight Output height, at least 1.\n * @param threshold Probability at or above which a pixel is foreground.\n * @returns `255` for foreground and `0` for background, `targetWidth * targetHeight`.\n */\nfunction resizeBilinearThreshold(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n    threshold: number,\n): Uint8Array {\n    const out = new Uint8Array(targetWidth * targetHeight);\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        for (let j = 0; j < out.length; j++) out[j] = (src[j] as number) >= threshold ? 255 : 0;\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    const x0s = new Int32Array(targetWidth);\n    const x1s = new Int32Array(targetWidth);\n    const wxs = new Float64Array(targetWidth);\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        x0s[x] = x0;\n        x1s[x] = Math.min(srcWidth - 1, x0 + 1);\n        wxs[x] = Math.max(0, Math.min(1, xx - x0));\n    }\n    const across = new Float64Array(srcHeight * targetWidth);\n    for (let r = 0; r < srcHeight; r++) {\n        const row = r * srcWidth;\n        const dst = r * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const wx = wxs[x] as number;\n            across[dst + x] =\n                (src[row + (x0s[x] as number)] as number) * (1 - wx) +\n                (src[row + (x1s[x] as number)] as number) * wx;\n        }\n    }\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        const top = y0 * targetWidth;\n        const bot = y1 * targetWidth;\n        const dst = y * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const value = (across[top + x] as number) * (1 - wy) + (across[bot + x] as number) * wy;\n            out[dst + x] = Math.fround(value) >= threshold ? 255 : 0;\n        }\n    }\n    return out;\n}\n"],"mappings":"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"}
+{"version":3,"file":"segmentation.cjs","names":["decodeYoloAnchors","BoundingBox","Mask","require_types","require_detection","decodeYoloSeg","pDims","prototypeDims","numMaskCoefs","maskH","maskW","channels","perAnchorDims","numAnchors","expectedChannels","options","prototypeData","decoded","perAnchorData","maskThreshold","scaleX","scaleY","protoPlane","coefBase","results","i","a","x1","y1","x2","y2","bbox","classId","confidence","bboxW","bboxH","ibx1","iby1","ibx2","iby2","mbx1","mby1","mbx2","mby2","cropW","cropH","binary","resizeBilinearThreshold","softMaskCrop","sigmoid","x","e","acc","kk","coef","coefOffset","planeBase","left","y","src","top","dst","soft","j","out","targetWidth","targetHeight","srcWidth","srcHeight","threshold","sx","sy","x0s","x1s","wxs","xx","x0","across","r","row","wx","yy","y0","wy","bot","value"],"sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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 * The prototypes' batch axis is stripped here; the per-anchor batch axis is\n * validated by {@link decodeYoloAnchors}. Each instance's box is mapped back\n * into input-tensor coordinates and from there into the low-resolution\n * prototype grid, and only the prototype pixels under it are assembled.\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    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        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        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = softMaskCrop(\n            perAnchorData,\n            prototypeData,\n            coefBase + a,\n            numAnchors,\n            numMaskCoefs,\n            maskW,\n            protoPlane,\n            mbx1,\n            mby1,\n            cropW,\n            cropH,\n        );\n        const binary = resizeBilinearThreshold(softCrop, cropW, cropH, bboxW, bboxH, maskThreshold);\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\n/**\n * Assemble one instance's soft mask over the prototype region under its box.\n *\n * The loop runs coefficient-major: for each of the `numMaskCoefs` prototypes it\n * walks the crop row by row, so every read of `prototypeData` is contiguous.\n * The pixel-major order it replaces jumped a whole prototype plane (25 600\n * floats for a 160×160 head) between consecutive reads, touching a fresh cache\n * line on every multiply. The accumulator is a `Float64Array` so each pixel's\n * sum is still built in double precision and in the same coefficient order as a\n * scalar `let sum = 0` — the result is bit-identical, only the memory walk\n * changed.\n *\n * @param perAnchorData Flat `output0`.\n * @param prototypeData Flat `output1`.\n * @param coefOffset Index of this anchor's first mask coefficient.\n * @param numAnchors Stride between consecutive coefficients of one anchor.\n * @param numMaskCoefs Number of prototypes.\n * @param maskW Prototype width.\n * @param protoPlane Prototype plane size, `maskW * maskH`.\n * @param left First prototype column of the crop.\n * @param top First prototype row of the crop.\n * @param cropW Crop width in prototype pixels.\n * @param cropH Crop height in prototype pixels.\n * @returns The sigmoid of the mask logits, `cropW * cropH`, row-major.\n */\nfunction softMaskCrop(\n    perAnchorData: Float32Array,\n    prototypeData: Float32Array,\n    coefOffset: number,\n    numAnchors: number,\n    numMaskCoefs: number,\n    maskW: number,\n    protoPlane: number,\n    left: number,\n    top: number,\n    cropW: number,\n    cropH: number,\n): Float32Array {\n    const acc = new Float64Array(cropW * cropH);\n    for (let kk = 0; kk < numMaskCoefs; kk++) {\n        const coef = perAnchorData[coefOffset + kk * numAnchors] as number;\n        const planeBase = kk * protoPlane + left;\n        for (let y = 0; y < cropH; y++) {\n            const src = planeBase + (top + y) * maskW;\n            const dst = y * cropW;\n            for (let x = 0; x < cropW; x++) {\n                acc[dst + x] = (acc[dst + x] as number) + coef * (prototypeData[src + x] as number);\n            }\n        }\n    }\n    const soft = new Float32Array(acc.length);\n    for (let j = 0; j < acc.length; j++) soft[j] = sigmoid(acc[j] as number);\n    return soft;\n}\n\n/**\n * Bilinearly resize a soft mask and threshold it in the same pass.\n *\n * Half-pixel-centre sampling, matching `cv2.resize(..., INTER_LINEAR)` and the\n * Python SDK. The interpolation is separable and runs that way, like the\n * Python `_resize_bilinear`: first along x over the few source rows, into a\n * `Float64Array` so every horizontal blend keeps its exact double value, then\n * along y between two of those rows. Each output pixel costs two reads and one\n * blend instead of four reads and three, with the same values as blending all\n * four directly. The thresholded byte is written directly instead of\n * materialising a `Float32Array` of the resized mask first.\n * Each interpolated value is rounded to float32 with `Math.fround` before the\n * comparison, because that is the value the intermediate array used to hold —\n * comparing the unrounded double would flip pixels sitting exactly on the\n * threshold.\n *\n * @param src Soft mask, `srcWidth * srcHeight`, row-major.\n * @param srcWidth Source width.\n * @param srcHeight Source height.\n * @param targetWidth Output width, at least 1.\n * @param targetHeight Output height, at least 1.\n * @param threshold Probability at or above which a pixel is foreground.\n * @returns `255` for foreground and `0` for background, `targetWidth * targetHeight`.\n */\nfunction resizeBilinearThreshold(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n    threshold: number,\n): Uint8Array {\n    const out = new Uint8Array(targetWidth * targetHeight);\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        for (let j = 0; j < out.length; j++) out[j] = (src[j] as number) >= threshold ? 255 : 0;\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    const x0s = new Int32Array(targetWidth);\n    const x1s = new Int32Array(targetWidth);\n    const wxs = new Float64Array(targetWidth);\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        x0s[x] = x0;\n        x1s[x] = Math.min(srcWidth - 1, x0 + 1);\n        wxs[x] = Math.max(0, Math.min(1, xx - x0));\n    }\n    const across = new Float64Array(srcHeight * targetWidth);\n    for (let r = 0; r < srcHeight; r++) {\n        const row = r * srcWidth;\n        const dst = r * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const wx = wxs[x] as number;\n            across[dst + x] =\n                (src[row + (x0s[x] as number)] as number) * (1 - wx) +\n                (src[row + (x1s[x] as number)] as number) * wx;\n        }\n    }\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        const top = y0 * targetWidth;\n        const bot = y1 * targetWidth;\n        const dst = y * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const value = (across[top + x] as number) * (1 - wy) + (across[bot + x] as number) * wy;\n            out[dst + x] = Math.fround(value) >= threshold ? 255 : 0;\n        }\n    }\n    return out;\n}\n"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"segmentation.js","names":[],"sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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 * The prototypes' batch axis is stripped here; the per-anchor batch axis is\n * validated by {@link decodeYoloAnchors}. Each instance's box is mapped back\n * into input-tensor coordinates and from there into the low-resolution\n * prototype grid, and only the prototype pixels under it are assembled.\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    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        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        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = softMaskCrop(\n            perAnchorData,\n            prototypeData,\n            coefBase + a,\n            numAnchors,\n            numMaskCoefs,\n            maskW,\n            protoPlane,\n            mbx1,\n            mby1,\n            cropW,\n            cropH,\n        );\n        const binary = resizeBilinearThreshold(softCrop, cropW, cropH, bboxW, bboxH, maskThreshold);\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\n/**\n * Assemble one instance's soft mask over the prototype region under its box.\n *\n * The loop runs coefficient-major: for each of the `numMaskCoefs` prototypes it\n * walks the crop row by row, so every read of `prototypeData` is contiguous.\n * The pixel-major order it replaces jumped a whole prototype plane (25 600\n * floats for a 160×160 head) between consecutive reads, touching a fresh cache\n * line on every multiply. The accumulator is a `Float64Array` so each pixel's\n * sum is still built in double precision and in the same coefficient order as a\n * scalar `let sum = 0` — the result is bit-identical, only the memory walk\n * changed.\n *\n * @param perAnchorData Flat `output0`.\n * @param prototypeData Flat `output1`.\n * @param coefOffset Index of this anchor's first mask coefficient.\n * @param numAnchors Stride between consecutive coefficients of one anchor.\n * @param numMaskCoefs Number of prototypes.\n * @param maskW Prototype width.\n * @param protoPlane Prototype plane size, `maskW * maskH`.\n * @param left First prototype column of the crop.\n * @param top First prototype row of the crop.\n * @param cropW Crop width in prototype pixels.\n * @param cropH Crop height in prototype pixels.\n * @returns The sigmoid of the mask logits, `cropW * cropH`, row-major.\n */\nfunction softMaskCrop(\n    perAnchorData: Float32Array,\n    prototypeData: Float32Array,\n    coefOffset: number,\n    numAnchors: number,\n    numMaskCoefs: number,\n    maskW: number,\n    protoPlane: number,\n    left: number,\n    top: number,\n    cropW: number,\n    cropH: number,\n): Float32Array {\n    const acc = new Float64Array(cropW * cropH);\n    for (let kk = 0; kk < numMaskCoefs; kk++) {\n        const coef = perAnchorData[coefOffset + kk * numAnchors] as number;\n        const planeBase = kk * protoPlane + left;\n        for (let y = 0; y < cropH; y++) {\n            const src = planeBase + (top + y) * maskW;\n            const dst = y * cropW;\n            for (let x = 0; x < cropW; x++) {\n                acc[dst + x] = (acc[dst + x] as number) + coef * (prototypeData[src + x] as number);\n            }\n        }\n    }\n    const soft = new Float32Array(acc.length);\n    for (let j = 0; j < acc.length; j++) soft[j] = sigmoid(acc[j] as number);\n    return soft;\n}\n\n/**\n * Bilinearly resize a soft mask and threshold it in the same pass.\n *\n * Half-pixel-centre sampling, matching `cv2.resize(..., INTER_LINEAR)` and the\n * Python SDK. The interpolation is separable and runs that way, like the\n * Python `_resize_bilinear`: first along x over the few source rows, into a\n * `Float64Array` so every horizontal blend keeps its exact double value, then\n * along y between two of those rows. Each output pixel costs two reads and one\n * blend instead of four reads and three, with the same values as blending all\n * four directly. The thresholded byte is written directly instead of\n * materialising a `Float32Array` of the resized mask first.\n * Each interpolated value is rounded to float32 with `Math.fround` before the\n * comparison, because that is the value the intermediate array used to hold —\n * comparing the unrounded double would flip pixels sitting exactly on the\n * threshold.\n *\n * @param src Soft mask, `srcWidth * srcHeight`, row-major.\n * @param srcWidth Source width.\n * @param srcHeight Source height.\n * @param targetWidth Output width, at least 1.\n * @param targetHeight Output height, at least 1.\n * @param threshold Probability at or above which a pixel is foreground.\n * @returns `255` for foreground and `0` for background, `targetWidth * targetHeight`.\n */\nfunction resizeBilinearThreshold(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n    threshold: number,\n): Uint8Array {\n    const out = new Uint8Array(targetWidth * targetHeight);\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        for (let j = 0; j < out.length; j++) out[j] = (src[j] as number) >= threshold ? 255 : 0;\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    const x0s = new Int32Array(targetWidth);\n    const x1s = new Int32Array(targetWidth);\n    const wxs = new Float64Array(targetWidth);\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        x0s[x] = x0;\n        x1s[x] = Math.min(srcWidth - 1, x0 + 1);\n        wxs[x] = Math.max(0, Math.min(1, xx - x0));\n    }\n    const across = new Float64Array(srcHeight * targetWidth);\n    for (let r = 0; r < srcHeight; r++) {\n        const row = r * srcWidth;\n        const dst = r * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const wx = wxs[x] as number;\n            across[dst + x] =\n                (src[row + (x0s[x] as number)] as number) * (1 - wx) +\n                (src[row + (x1s[x] as number)] as number) * wx;\n        }\n    }\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        const top = y0 * targetWidth;\n        const bot = y1 * targetWidth;\n        const dst = y * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const value = (across[top + x] as number) * (1 - wy) + (across[bot + x] as number) * wy;\n            out[dst + x] = Math.fround(value) >= threshold ? 255 : 0;\n        }\n    }\n    return out;\n}\n"],"mappings":";;;AAkEA,SAAgB,EACZ,GACA,GACA,GACA,GACA,GACqB;CACrB,IAAI,IAAQ;CACZ,IAAI,EAAM,WAAW,GAAG;EACpB,IAAI,EAAM,OAAO,GACb,MAAU,MAAM,2DAA2D,EAAM,GAAG,EAAE;EAE1F,IAAQ;GAAC,EAAM;GAAc,EAAM;GAAc,EAAM;EAAY;CACvE;CACA,IAAI,EAAM,WAAW,GACjB,MAAU,MACN,wEAAwE,KAAK,UAAU,CAAa,EAAE,EAC1G;CAEJ,IAAM,IAAe,EAAM,IACrB,IAAQ,EAAM,IACd,IAAQ,EAAM,IAEd,IAAW,EAAc,WAAW,IAAI,EAAc,KAAK,EAAc,IACzE,IAAa,EAAc,WAAW,IAAI,EAAc,KAAK,EAAc;CACjF,IAAI,MAAa,KAAA,KAAa,MAAe,KAAA,GACzC,MAAU,MACN,4DAA4D,KAAK,UAAU,CAAa,EAAE,EAC9F;CAGJ,IAAM,IAAmB,IAAI,EAAQ,aAAa;CAClD,IAAI,MAAa,GACb,MAAU,MACN,2BAA2B,EAAS,iCAAiC,EAAQ,WAAW,mBAAmB,EAAa,MAAM,EAAiB,EACnJ;CAEJ,IAAI,EAAc,WAAW,IAAe,IAAQ,GAChD,MAAU,MACN,mCAAmC,EAAc,OAAO,uBAAuB,KAAK,UAAU,CAAa,EAAE,EACjH;CAGJ,IAAM,IAAU,EAAkB,GAAe,GAAe;EAC5D,YAAY,EAAQ;EACpB,eAAe,EAAQ;EACvB,gBAAgB,EAAQ;EACxB,SAAS,EAAQ;EACjB,QAAQ,EAAQ;EAChB,OAAO,EAAQ;EACf,eAAe,EAAQ;EACvB,cAAc,EAAQ;EACtB,eAAe,EAAQ;CAC3B,CAAC;CAED,IAAI,EAAQ,cAAc,WAAW,GAAG,OAAO,CAAC;CAEhD,IAAM,IAAgB,EAAQ,iBAAiB,IACzC,IAAS,IAAQ,EAAQ,YACzB,IAAS,IAAQ,EAAQ,aACzB,IAAa,IAAQ,GACrB,KAAY,IAAI,EAAQ,cAAc,GAEtC,IAAiC,CAAC;CAExC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAQ,cAAc,QAAQ,KAAK;EACnD,IAAM,IAAI,EAAQ,cAAc,IAC1B,IAAK,EAAQ,UAAU,IAAI,IAC3B,IAAK,EAAQ,UAAU,IAAI,IAAI,IAC/B,IAAK,EAAQ,UAAU,IAAI,IAAI,IAC/B,IAAK,EAAQ,UAAU,IAAI,IAAI,IAC/B,IAAO,IAAI,EAAY,GAAI,GAAI,GAAI,CAAE,GACrC,IAAU,EAAQ,SAAS,IAC3B,IAAa,EAAQ,YAAY,IAEjC,IAAQ,KAAK,IAAI,GAAG,KAAK,MAAM,CAAE,IAAI,KAAK,MAAM,CAAE,CAAC,GACnD,IAAQ,KAAK,IAAI,GAAG,KAAK,MAAM,CAAE,IAAI,KAAK,MAAM,CAAE,CAAC;EAEzD,IAAI,MAAU,KAAK,MAAU,GAAG;GAC5B,EAAQ,KAAK;IAAE;IAAM;IAAS;IAAY,MAAM,IAAI,kBAAK,IAAI,WAAY,GAAG,GAAG,CAAC;GAAE,CAAC;GACnF;EACJ;EAEA,IAAM,IAAO,IAAK,EAAQ,QAAQ,EAAQ,SACpC,IAAO,IAAK,EAAQ,QAAQ,EAAQ,QACpC,IAAO,IAAK,EAAQ,QAAQ,EAAQ,SACpC,IAAO,IAAK,EAAQ,QAAQ,EAAQ,QAEpC,IAAO,KAAK,IAAI,GAAG,KAAK,MAAM,IAAO,CAAM,CAAC,GAC5C,IAAO,KAAK,IAAI,GAAG,KAAK,MAAM,IAAO,CAAM,CAAC,GAC5C,IAAO,KAAK,IAAI,GAAO,KAAK,KAAK,IAAO,CAAM,CAAC,GAC/C,IAAO,KAAK,IAAI,GAAO,KAAK,KAAK,IAAO,CAAM,CAAC;EAErD,IAAI,KAAQ,KAAQ,KAAQ,GAAM;GAC9B,EAAQ,KAAK;IACT;IACA;IACA;IACA,MAAM,IAAI,EAAK,IAAI,WAAW,IAAQ,CAAK,GAAG,GAAO,CAAK;GAC9D,CAAC;GACD;EACJ;EAEA,IAAM,IAAQ,IAAO,GACf,IAAQ,IAAO,GAcf,IAAS,EAbE,EACb,GACA,GACA,IAAW,GACX,GACA,GACA,GACA,GACA,GACA,GACA,GACA,CAEmC,GAAU,GAAO,GAAO,GAAO,GAAO,CAAa;EAE1F,EAAQ,KAAK;GAAE;GAAM;GAAS;GAAY,MAAM,IAAI,EAAK,GAAQ,GAAO,CAAK;EAAE,CAAC;CACpF;CAEA,OAAO;AACX;AAEA,SAAS,EAAQ,GAAmB;CAChC,IAAI,KAAK,GACL,OAAO,KAAK,IAAI,KAAK,IAAI,CAAC,CAAC;CAE/B,IAAM,IAAI,KAAK,IAAI,CAAC;CACpB,OAAO,KAAK,IAAI;AACpB;AA2BA,SAAS,EACL,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACY;CACZ,IAAM,IAAM,IAAI,aAAa,IAAQ,CAAK;CAC1C,KAAK,IAAI,IAAK,GAAG,IAAK,GAAc,KAAM;EACtC,IAAM,IAAO,EAAc,IAAa,IAAK,IACvC,IAAY,IAAK,IAAa;EACpC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KAAK;GAC5B,IAAM,IAAM,KAAa,IAAM,KAAK,GAC9B,IAAM,IAAI;GAChB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAO,KACvB,EAAI,IAAM,KAAM,EAAI,IAAM,KAAgB,IAAQ,EAAc,IAAM;EAE9E;CACJ;CACA,IAAM,IAAO,IAAI,aAAa,EAAI,MAAM;CACxC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAI,QAAQ,KAAK,EAAK,KAAK,EAAQ,EAAI,EAAY;CACvE,OAAO;AACX;AA0BA,SAAS,EACL,GACA,GACA,GACA,GACA,GACA,GACU;CACV,IAAM,IAAM,IAAI,WAAW,IAAc,CAAY;CACrD,IAAI,MAAgB,KAAY,MAAiB,GAAW;EACxD,KAAK,IAAI,IAAI,GAAG,IAAI,EAAI,QAAQ,KAAK,EAAI,KAAM,EAAI,MAAiB,IAAY,MAAM;EACtF,OAAO;CACX;CACA,IAAM,IAAK,IAAW,GAChB,IAAK,IAAY,GACjB,IAAM,IAAI,WAAW,CAAW,GAChC,IAAM,IAAI,WAAW,CAAW,GAChC,IAAM,IAAI,aAAa,CAAW;CACxC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAa,KAAK;EAClC,IAAM,KAAM,IAAI,MAAO,IAAK,IACtB,IAAK,KAAK,IAAI,GAAG,KAAK,MAAM,CAAE,CAAC;EAGrC,AAFA,EAAI,KAAK,GACT,EAAI,KAAK,KAAK,IAAI,IAAW,GAAG,IAAK,CAAC,GACtC,EAAI,KAAK,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,IAAK,CAAE,CAAC;CAC7C;CACA,IAAM,IAAS,IAAI,aAAa,IAAY,CAAW;CACvD,KAAK,IAAI,IAAI,GAAG,IAAI,GAAW,KAAK;EAChC,IAAM,IAAM,IAAI,GACV,IAAM,IAAI;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAa,KAAK;GAClC,IAAM,IAAK,EAAI;GACf,EAAO,IAAM,KACR,EAAI,IAAO,EAAI,OAA6B,IAAI,KAChD,EAAI,IAAO,EAAI,MAA4B;EACpD;CACJ;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,GAAc,KAAK;EACnC,IAAM,KAAM,IAAI,MAAO,IAAK,IACtB,IAAK,KAAK,IAAI,GAAG,KAAK,MAAM,CAAE,CAAC,GAC/B,IAAK,KAAK,IAAI,IAAY,GAAG,IAAK,CAAC,GACnC,IAAK,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,IAAK,CAAE,CAAC,GACrC,IAAM,IAAK,GACX,IAAM,IAAK,GACX,IAAM,IAAI;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAa,KAAK;GAClC,IAAM,IAAS,EAAO,IAAM,MAAiB,IAAI,KAAO,EAAO,IAAM,KAAgB;GACrF,EAAI,IAAM,KAAK,KAAK,OAAO,CAAK,KAAK,IAAY,MAAM;EAC3D;CACJ;CACA,OAAO;AACX"}
+{"version":3,"file":"segmentation.js","names":["decodeYoloSeg","pDims","prototypeDims","numMaskCoefs","maskH","maskW","channels","perAnchorDims","numAnchors","expectedChannels","options","prototypeData","decoded","decodeYoloAnchors","perAnchorData","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","binary","resizeBilinearThreshold","softMaskCrop","sigmoid","x","e","acc","kk","coef","coefOffset","planeBase","left","y","src","top","dst","soft","j","out","targetWidth","targetHeight","srcWidth","srcHeight","threshold","sx","sy","x0s","x1s","wxs","xx","x0","across","r","row","wx","yy","y0","wy","bot","value"],"sources":["../../../src/vision/postprocess/segmentation.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\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 * The prototypes' batch axis is stripped here; the per-anchor batch axis is\n * validated by {@link decodeYoloAnchors}. Each instance's box is mapped back\n * into input-tensor coordinates and from there into the low-resolution\n * prototype grid, and only the prototype pixels under it are assembled.\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    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        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        const cropW = mbx2 - mbx1;\n        const cropH = mby2 - mby1;\n        const softCrop = softMaskCrop(\n            perAnchorData,\n            prototypeData,\n            coefBase + a,\n            numAnchors,\n            numMaskCoefs,\n            maskW,\n            protoPlane,\n            mbx1,\n            mby1,\n            cropW,\n            cropH,\n        );\n        const binary = resizeBilinearThreshold(softCrop, cropW, cropH, bboxW, bboxH, maskThreshold);\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\n/**\n * Assemble one instance's soft mask over the prototype region under its box.\n *\n * The loop runs coefficient-major: for each of the `numMaskCoefs` prototypes it\n * walks the crop row by row, so every read of `prototypeData` is contiguous.\n * The pixel-major order it replaces jumped a whole prototype plane (25 600\n * floats for a 160×160 head) between consecutive reads, touching a fresh cache\n * line on every multiply. The accumulator is a `Float64Array` so each pixel's\n * sum is still built in double precision and in the same coefficient order as a\n * scalar `let sum = 0` — the result is bit-identical, only the memory walk\n * changed.\n *\n * @param perAnchorData Flat `output0`.\n * @param prototypeData Flat `output1`.\n * @param coefOffset Index of this anchor's first mask coefficient.\n * @param numAnchors Stride between consecutive coefficients of one anchor.\n * @param numMaskCoefs Number of prototypes.\n * @param maskW Prototype width.\n * @param protoPlane Prototype plane size, `maskW * maskH`.\n * @param left First prototype column of the crop.\n * @param top First prototype row of the crop.\n * @param cropW Crop width in prototype pixels.\n * @param cropH Crop height in prototype pixels.\n * @returns The sigmoid of the mask logits, `cropW * cropH`, row-major.\n */\nfunction softMaskCrop(\n    perAnchorData: Float32Array,\n    prototypeData: Float32Array,\n    coefOffset: number,\n    numAnchors: number,\n    numMaskCoefs: number,\n    maskW: number,\n    protoPlane: number,\n    left: number,\n    top: number,\n    cropW: number,\n    cropH: number,\n): Float32Array {\n    const acc = new Float64Array(cropW * cropH);\n    for (let kk = 0; kk < numMaskCoefs; kk++) {\n        const coef = perAnchorData[coefOffset + kk * numAnchors] as number;\n        const planeBase = kk * protoPlane + left;\n        for (let y = 0; y < cropH; y++) {\n            const src = planeBase + (top + y) * maskW;\n            const dst = y * cropW;\n            for (let x = 0; x < cropW; x++) {\n                acc[dst + x] = (acc[dst + x] as number) + coef * (prototypeData[src + x] as number);\n            }\n        }\n    }\n    const soft = new Float32Array(acc.length);\n    for (let j = 0; j < acc.length; j++) soft[j] = sigmoid(acc[j] as number);\n    return soft;\n}\n\n/**\n * Bilinearly resize a soft mask and threshold it in the same pass.\n *\n * Half-pixel-centre sampling, matching `cv2.resize(..., INTER_LINEAR)` and the\n * Python SDK. The interpolation is separable and runs that way, like the\n * Python `_resize_bilinear`: first along x over the few source rows, into a\n * `Float64Array` so every horizontal blend keeps its exact double value, then\n * along y between two of those rows. Each output pixel costs two reads and one\n * blend instead of four reads and three, with the same values as blending all\n * four directly. The thresholded byte is written directly instead of\n * materialising a `Float32Array` of the resized mask first.\n * Each interpolated value is rounded to float32 with `Math.fround` before the\n * comparison, because that is the value the intermediate array used to hold —\n * comparing the unrounded double would flip pixels sitting exactly on the\n * threshold.\n *\n * @param src Soft mask, `srcWidth * srcHeight`, row-major.\n * @param srcWidth Source width.\n * @param srcHeight Source height.\n * @param targetWidth Output width, at least 1.\n * @param targetHeight Output height, at least 1.\n * @param threshold Probability at or above which a pixel is foreground.\n * @returns `255` for foreground and `0` for background, `targetWidth * targetHeight`.\n */\nfunction resizeBilinearThreshold(\n    src: Float32Array,\n    srcWidth: number,\n    srcHeight: number,\n    targetWidth: number,\n    targetHeight: number,\n    threshold: number,\n): Uint8Array {\n    const out = new Uint8Array(targetWidth * targetHeight);\n    if (targetWidth === srcWidth && targetHeight === srcHeight) {\n        for (let j = 0; j < out.length; j++) out[j] = (src[j] as number) >= threshold ? 255 : 0;\n        return out;\n    }\n    const sx = srcWidth / targetWidth;\n    const sy = srcHeight / targetHeight;\n    const x0s = new Int32Array(targetWidth);\n    const x1s = new Int32Array(targetWidth);\n    const wxs = new Float64Array(targetWidth);\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        x0s[x] = x0;\n        x1s[x] = Math.min(srcWidth - 1, x0 + 1);\n        wxs[x] = Math.max(0, Math.min(1, xx - x0));\n    }\n    const across = new Float64Array(srcHeight * targetWidth);\n    for (let r = 0; r < srcHeight; r++) {\n        const row = r * srcWidth;\n        const dst = r * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const wx = wxs[x] as number;\n            across[dst + x] =\n                (src[row + (x0s[x] as number)] as number) * (1 - wx) +\n                (src[row + (x1s[x] as number)] as number) * wx;\n        }\n    }\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        const top = y0 * targetWidth;\n        const bot = y1 * targetWidth;\n        const dst = y * targetWidth;\n        for (let x = 0; x < targetWidth; x++) {\n            const value = (across[top + x] as number) * (1 - wy) + (across[bot + x] as number) * wy;\n            out[dst + x] = Math.fround(value) >= threshold ? 255 : 0;\n        }\n    }\n    return out;\n}\n"],"mappings":"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"}

package/dist/vision/preprocess/image.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"image.cjs","names":[],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\n * Composable image preprocessing primitives (resize, normalize, letterbox, layout).\n *\n * Mirrors the Python `preprocess.image` module. Operates on the canonical\n * {@link RGBImage} (HWC RGB uint8) and produces uint8 or float32 buffers\n * depending on the operation.\n */\n\nimport * as ortRuntime from \"onnxruntime-web\";\nimport type * as ort from \"onnxruntime-web\";\n\nimport { createCanvas, get2DContext, imageDataToRGB, rgbToImageData } from \"../core/canvas\";\nimport { RGBImage } from \"../types\";\n\n/** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */\nexport function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage {\n    if (targetWidth <= 0 || targetHeight <= 0) {\n        throw new Error(`Invalid resize target ${targetWidth}x${targetHeight}.`);\n    }\n    if (targetWidth === image.width && targetHeight === image.height) {\n        return image;\n    }\n\n    const srcCanvas = createCanvas(image.width, image.height);\n    const srcCtx = get2DContext(srcCanvas);\n    srcCtx.putImageData(rgbToImageData(image), 0, 0);\n\n    const dstCanvas = createCanvas(targetWidth, targetHeight);\n    const dstCtx = get2DContext(dstCanvas);\n    dstCtx.imageSmoothingEnabled = true;\n    dstCtx.imageSmoothingQuality = \"high\";\n    dstCtx.drawImage(srcCanvas as CanvasImageSource, 0, 0, targetWidth, targetHeight);\n\n    const imageData = dstCtx.getImageData(0, 0, targetWidth, targetHeight);\n    return imageDataToRGB(imageData);\n}\n\n/**\n * Convert a uint8 image to a normalized float32 array (HWC layout preserved).\n *\n * Applies `(pixel * scale - mean) / std` channel-wise.\n */\nexport function normalize(\n    image: RGBImage,\n    mean: readonly [number, number, number],\n    std: readonly [number, number, number],\n    scale: number = 1 / 255,\n): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    const m0 = mean[0];\n    const m1 = mean[1];\n    const m2 = mean[2];\n    const s0 = std[0];\n    const s1 = std[1];\n    const s2 = std[2];\n    for (let i = 0; i < data.length; i += 3) {\n        out[i] = ((data[i] as number) * scale - m0) / s0;\n        out[i + 1] = ((data[i + 1] as number) * scale - m1) / s1;\n        out[i + 2] = ((data[i + 2] as number) * scale - m2) / s2;\n    }\n    return out;\n}\n\n/** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */\nexport function toFloat32(image: RGBImage, scale: number = 1 / 255): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    for (let i = 0; i < data.length; i++) {\n        out[i] = (data[i] as number) * scale;\n    }\n    return out;\n}\n\n/**\n * Transpose interleaved HWC data to planar CHW layout.\n *\n * @param hwc Source array of length `width * height * channels`.\n */\nexport function toCHW(\n    hwc: Float32Array,\n    width: number,\n    height: number,\n    channels: number = 3,\n): Float32Array {\n    const expected = width * height * channels;\n    if (hwc.length !== expected) {\n        throw new Error(\n            `toCHW: expected length ${expected} for ${width}x${height}x${channels}, got ${hwc.length}.`,\n        );\n    }\n    const chw = new Float32Array(expected);\n    const plane = width * height;\n    for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n            const hwcBase = (y * width + x) * channels;\n            const planeIdx = y * width + x;\n            for (let c = 0; c < channels; c++) {\n                chw[c * plane + planeIdx] = hwc[hwcBase + c] as number;\n            }\n        }\n    }\n    return chw;\n}\n\n/** Wrap a Float32 buffer into an `ort.Tensor`. */\nexport function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor {\n    return new ortRuntime.Tensor(\"float32\", data, dims as number[]);\n}\n\n/**\n * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.\n *\n * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,\n * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that\n * don't require ImageNet normalization.\n *\n * @returns CHW `Float32Array` of length `width * height * 3`.\n */\nexport function toTensor(image: RGBImage): Float32Array {\n    const f32 = toFloat32(image);\n    return toCHW(f32, image.width, image.height, 3);\n}\n\n/**\n * Convert an HWC BGR uint8 buffer (OpenCV layout) to the SDK's HWC RGB.\n *\n * Use when you receive image bytes from `cv2.imencode` over the wire and\n * want to feed them to the SDK without going through a canvas decode.\n *\n * @param bgr Flat BGR Uint8Array of length `width * height * 3`.\n */\nexport function fromCv2(bgr: Uint8Array, width: number, height: number): RGBImage {\n    if (bgr.length !== width * height * 3) {\n        throw new Error(\n            `fromCv2: data length ${bgr.length} does not match width * height * 3 = ${width * height * 3}.`,\n        );\n    }\n    const rgb = new Uint8Array(bgr.length);\n    for (let i = 0; i < bgr.length; i += 3) {\n        rgb[i] = bgr[i + 2] as number;\n        rgb[i + 1] = bgr[i + 1] as number;\n        rgb[i + 2] = bgr[i] as number;\n    }\n    return new RGBImage(rgb, width, height);\n}\n\n/**\n * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).\n *\n * Useful for round-tripping data to a Python OpenCV consumer.\n */\nexport function toCv2(image: RGBImage): Uint8Array {\n    const rgb = image.data;\n    const bgr = new Uint8Array(rgb.length);\n    for (let i = 0; i < rgb.length; i += 3) {\n        bgr[i] = rgb[i + 2] as number;\n        bgr[i + 1] = rgb[i + 1] as number;\n        bgr[i + 2] = rgb[i] as number;\n    }\n    return bgr;\n}\n\nexport interface LetterboxResult {\n    /** The padded image at the target size. */\n    readonly image: RGBImage;\n    /** The factor applied to the original image (`< 1` if downscaled). */\n    readonly scale: number;\n    /** Horizontal padding in pixels (left side; right side has the same or +1). */\n    readonly padLeft: number;\n    /** Vertical padding in pixels (top side). */\n    readonly padTop: number;\n}\n\n/**\n * Resize preserving aspect ratio, padding to `(targetWidth, targetHeight)`\n * with a constant fill color.\n *\n * Standard YOLO preprocessing — returning `scale` and `padLeft`/`padTop`\n * lets callers map detections back to the original image coordinates.\n */\nexport function letterbox(\n    image: RGBImage,\n    targetWidth: number,\n    targetHeight: number,\n    fill: readonly [number, number, number] = [114, 114, 114],\n): LetterboxResult {\n    const scale = Math.min(targetWidth / image.width, targetHeight / image.height);\n    const newW = Math.round(image.width * scale);\n    const newH = Math.round(image.height * scale);\n    const resized = resize(image, newW, newH);\n\n    const out = new Uint8Array(targetWidth * targetHeight * 3);\n    const f0 = fill[0];\n    const f1 = fill[1];\n    const f2 = fill[2];\n    for (let i = 0; i < out.length; i += 3) {\n        out[i] = f0;\n        out[i + 1] = f1;\n        out[i + 2] = f2;\n    }\n\n    const padLeft = Math.floor((targetWidth - newW) / 2);\n    const padTop = Math.floor((targetHeight - newH) / 2);\n    const rowBytes = newW * 3;\n    for (let y = 0; y < newH; y++) {\n        const srcOffset = y * rowBytes;\n        const dstOffset = ((padTop + y) * targetWidth + padLeft) * 3;\n        out.set(resized.data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);\n    }\n\n    return {\n        image: new RGBImage(out, targetWidth, targetHeight),\n        scale,\n        padLeft,\n        padTop,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"image.cjs","names":["createCanvas","get2DContext","rgbToImageData","imageDataToRGB","ortRuntime","RGBImage","require_runtime","require_types","require_canvas","onnxruntime_web","resize","targetWidth","targetHeight","image","srcCanvas","dstCanvas","dstCtx","imageData","normalize","out","data","m0","mean","m1","m2","s0","std","s1","s2","i","scale","toFloat32","toCHW","expected","width","height","channels","hwc","chw","plane","y","x","hwcBase","planeIdx","c","toFloat32Tensor","dims","toTensor","fromCv2","bgr","rgb","toCv2","letterbox","newW","newH","resized","f0","fill","f1","f2","padLeft","padTop","rowBytes","srcOffset","dstOffset"],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\n * Composable image preprocessing primitives (resize, normalize, letterbox, layout).\n *\n * Mirrors the Python `preprocess.image` module. Operates on the canonical\n * {@link RGBImage} (HWC RGB uint8) and produces uint8 or float32 buffers\n * depending on the operation.\n */\n\nimport * as ortRuntime from \"onnxruntime-web\";\nimport type * as ort from \"onnxruntime-web\";\n\nimport { createCanvas, get2DContext, imageDataToRGB, rgbToImageData } from \"../core/canvas\";\nimport { RGBImage } from \"../types\";\n\n/** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */\nexport function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage {\n    if (targetWidth <= 0 || targetHeight <= 0) {\n        throw new Error(`Invalid resize target ${targetWidth}x${targetHeight}.`);\n    }\n    if (targetWidth === image.width && targetHeight === image.height) {\n        return image;\n    }\n\n    const srcCanvas = createCanvas(image.width, image.height);\n    const srcCtx = get2DContext(srcCanvas);\n    srcCtx.putImageData(rgbToImageData(image), 0, 0);\n\n    const dstCanvas = createCanvas(targetWidth, targetHeight);\n    const dstCtx = get2DContext(dstCanvas);\n    dstCtx.imageSmoothingEnabled = true;\n    dstCtx.imageSmoothingQuality = \"high\";\n    dstCtx.drawImage(srcCanvas as CanvasImageSource, 0, 0, targetWidth, targetHeight);\n\n    const imageData = dstCtx.getImageData(0, 0, targetWidth, targetHeight);\n    return imageDataToRGB(imageData);\n}\n\n/**\n * Convert a uint8 image to a normalized float32 array (HWC layout preserved).\n *\n * Applies `(pixel * scale - mean) / std` channel-wise.\n */\nexport function normalize(\n    image: RGBImage,\n    mean: readonly [number, number, number],\n    std: readonly [number, number, number],\n    scale: number = 1 / 255,\n): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    const m0 = mean[0];\n    const m1 = mean[1];\n    const m2 = mean[2];\n    const s0 = std[0];\n    const s1 = std[1];\n    const s2 = std[2];\n    for (let i = 0; i < data.length; i += 3) {\n        out[i] = ((data[i] as number) * scale - m0) / s0;\n        out[i + 1] = ((data[i + 1] as number) * scale - m1) / s1;\n        out[i + 2] = ((data[i + 2] as number) * scale - m2) / s2;\n    }\n    return out;\n}\n\n/** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */\nexport function toFloat32(image: RGBImage, scale: number = 1 / 255): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    for (let i = 0; i < data.length; i++) {\n        out[i] = (data[i] as number) * scale;\n    }\n    return out;\n}\n\n/**\n * Transpose interleaved HWC data to planar CHW layout.\n *\n * @param hwc Source array of length `width * height * channels`.\n */\nexport function toCHW(\n    hwc: Float32Array,\n    width: number,\n    height: number,\n    channels: number = 3,\n): Float32Array {\n    const expected = width * height * channels;\n    if (hwc.length !== expected) {\n        throw new Error(\n            `toCHW: expected length ${expected} for ${width}x${height}x${channels}, got ${hwc.length}.`,\n        );\n    }\n    const chw = new Float32Array(expected);\n    const plane = width * height;\n    for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n            const hwcBase = (y * width + x) * channels;\n            const planeIdx = y * width + x;\n            for (let c = 0; c < channels; c++) {\n                chw[c * plane + planeIdx] = hwc[hwcBase + c] as number;\n            }\n        }\n    }\n    return chw;\n}\n\n/** Wrap a Float32 buffer into an `ort.Tensor`. */\nexport function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor {\n    return new ortRuntime.Tensor(\"float32\", data, dims as number[]);\n}\n\n/**\n * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.\n *\n * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,\n * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that\n * don't require ImageNet normalization.\n *\n * @returns CHW `Float32Array` of length `width * height * 3`.\n */\nexport function toTensor(image: RGBImage): Float32Array {\n    const f32 = toFloat32(image);\n    return toCHW(f32, image.width, image.height, 3);\n}\n\n/**\n * Convert an HWC BGR uint8 buffer (OpenCV layout) to the SDK's HWC RGB.\n *\n * Use when you receive image bytes from `cv2.imencode` over the wire and\n * want to feed them to the SDK without going through a canvas decode.\n *\n * @param bgr Flat BGR Uint8Array of length `width * height * 3`.\n */\nexport function fromCv2(bgr: Uint8Array, width: number, height: number): RGBImage {\n    if (bgr.length !== width * height * 3) {\n        throw new Error(\n            `fromCv2: data length ${bgr.length} does not match width * height * 3 = ${width * height * 3}.`,\n        );\n    }\n    const rgb = new Uint8Array(bgr.length);\n    for (let i = 0; i < bgr.length; i += 3) {\n        rgb[i] = bgr[i + 2] as number;\n        rgb[i + 1] = bgr[i + 1] as number;\n        rgb[i + 2] = bgr[i] as number;\n    }\n    return new RGBImage(rgb, width, height);\n}\n\n/**\n * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).\n *\n * Useful for round-tripping data to a Python OpenCV consumer.\n */\nexport function toCv2(image: RGBImage): Uint8Array {\n    const rgb = image.data;\n    const bgr = new Uint8Array(rgb.length);\n    for (let i = 0; i < rgb.length; i += 3) {\n        bgr[i] = rgb[i + 2] as number;\n        bgr[i + 1] = rgb[i + 1] as number;\n        bgr[i + 2] = rgb[i] as number;\n    }\n    return bgr;\n}\n\nexport interface LetterboxResult {\n    /** The padded image at the target size. */\n    readonly image: RGBImage;\n    /** The factor applied to the original image (`< 1` if downscaled). */\n    readonly scale: number;\n    /** Horizontal padding in pixels (left side; right side has the same or +1). */\n    readonly padLeft: number;\n    /** Vertical padding in pixels (top side). */\n    readonly padTop: number;\n}\n\n/**\n * Resize preserving aspect ratio, padding to `(targetWidth, targetHeight)`\n * with a constant fill color.\n *\n * Standard YOLO preprocessing — returning `scale` and `padLeft`/`padTop`\n * lets callers map detections back to the original image coordinates.\n */\nexport function letterbox(\n    image: RGBImage,\n    targetWidth: number,\n    targetHeight: number,\n    fill: readonly [number, number, number] = [114, 114, 114],\n): LetterboxResult {\n    const scale = Math.min(targetWidth / image.width, targetHeight / image.height);\n    const newW = Math.round(image.width * scale);\n    const newH = Math.round(image.height * scale);\n    const resized = resize(image, newW, newH);\n\n    const out = new Uint8Array(targetWidth * targetHeight * 3);\n    const f0 = fill[0];\n    const f1 = fill[1];\n    const f2 = fill[2];\n    for (let i = 0; i < out.length; i += 3) {\n        out[i] = f0;\n        out[i + 1] = f1;\n        out[i + 2] = f2;\n    }\n\n    const padLeft = Math.floor((targetWidth - newW) / 2);\n    const padTop = Math.floor((targetHeight - newH) / 2);\n    const rowBytes = newW * 3;\n    for (let y = 0; y < newH; y++) {\n        const srcOffset = y * rowBytes;\n        const dstOffset = ((padTop + y) * targetWidth + padLeft) * 3;\n        out.set(resized.data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);\n    }\n\n    return {\n        image: new RGBImage(out, targetWidth, targetHeight),\n        scale,\n        padLeft,\n        padTop,\n    };\n}\n"],"mappings":"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"}

package/dist/vision/preprocess/image.js.map

@@ -1 +1 @@
-{"version":3,"file":"image.js","names":[],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\n * Composable image preprocessing primitives (resize, normalize, letterbox, layout).\n *\n * Mirrors the Python `preprocess.image` module. Operates on the canonical\n * {@link RGBImage} (HWC RGB uint8) and produces uint8 or float32 buffers\n * depending on the operation.\n */\n\nimport * as ortRuntime from \"onnxruntime-web\";\nimport type * as ort from \"onnxruntime-web\";\n\nimport { createCanvas, get2DContext, imageDataToRGB, rgbToImageData } from \"../core/canvas\";\nimport { RGBImage } from \"../types\";\n\n/** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */\nexport function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage {\n    if (targetWidth <= 0 || targetHeight <= 0) {\n        throw new Error(`Invalid resize target ${targetWidth}x${targetHeight}.`);\n    }\n    if (targetWidth === image.width && targetHeight === image.height) {\n        return image;\n    }\n\n    const srcCanvas = createCanvas(image.width, image.height);\n    const srcCtx = get2DContext(srcCanvas);\n    srcCtx.putImageData(rgbToImageData(image), 0, 0);\n\n    const dstCanvas = createCanvas(targetWidth, targetHeight);\n    const dstCtx = get2DContext(dstCanvas);\n    dstCtx.imageSmoothingEnabled = true;\n    dstCtx.imageSmoothingQuality = \"high\";\n    dstCtx.drawImage(srcCanvas as CanvasImageSource, 0, 0, targetWidth, targetHeight);\n\n    const imageData = dstCtx.getImageData(0, 0, targetWidth, targetHeight);\n    return imageDataToRGB(imageData);\n}\n\n/**\n * Convert a uint8 image to a normalized float32 array (HWC layout preserved).\n *\n * Applies `(pixel * scale - mean) / std` channel-wise.\n */\nexport function normalize(\n    image: RGBImage,\n    mean: readonly [number, number, number],\n    std: readonly [number, number, number],\n    scale: number = 1 / 255,\n): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    const m0 = mean[0];\n    const m1 = mean[1];\n    const m2 = mean[2];\n    const s0 = std[0];\n    const s1 = std[1];\n    const s2 = std[2];\n    for (let i = 0; i < data.length; i += 3) {\n        out[i] = ((data[i] as number) * scale - m0) / s0;\n        out[i + 1] = ((data[i + 1] as number) * scale - m1) / s1;\n        out[i + 2] = ((data[i + 2] as number) * scale - m2) / s2;\n    }\n    return out;\n}\n\n/** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */\nexport function toFloat32(image: RGBImage, scale: number = 1 / 255): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    for (let i = 0; i < data.length; i++) {\n        out[i] = (data[i] as number) * scale;\n    }\n    return out;\n}\n\n/**\n * Transpose interleaved HWC data to planar CHW layout.\n *\n * @param hwc Source array of length `width * height * channels`.\n */\nexport function toCHW(\n    hwc: Float32Array,\n    width: number,\n    height: number,\n    channels: number = 3,\n): Float32Array {\n    const expected = width * height * channels;\n    if (hwc.length !== expected) {\n        throw new Error(\n            `toCHW: expected length ${expected} for ${width}x${height}x${channels}, got ${hwc.length}.`,\n        );\n    }\n    const chw = new Float32Array(expected);\n    const plane = width * height;\n    for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n            const hwcBase = (y * width + x) * channels;\n            const planeIdx = y * width + x;\n            for (let c = 0; c < channels; c++) {\n                chw[c * plane + planeIdx] = hwc[hwcBase + c] as number;\n            }\n        }\n    }\n    return chw;\n}\n\n/** Wrap a Float32 buffer into an `ort.Tensor`. */\nexport function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor {\n    return new ortRuntime.Tensor(\"float32\", data, dims as number[]);\n}\n\n/**\n * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.\n *\n * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,\n * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that\n * don't require ImageNet normalization.\n *\n * @returns CHW `Float32Array` of length `width * height * 3`.\n */\nexport function toTensor(image: RGBImage): Float32Array {\n    const f32 = toFloat32(image);\n    return toCHW(f32, image.width, image.height, 3);\n}\n\n/**\n * Convert an HWC BGR uint8 buffer (OpenCV layout) to the SDK's HWC RGB.\n *\n * Use when you receive image bytes from `cv2.imencode` over the wire and\n * want to feed them to the SDK without going through a canvas decode.\n *\n * @param bgr Flat BGR Uint8Array of length `width * height * 3`.\n */\nexport function fromCv2(bgr: Uint8Array, width: number, height: number): RGBImage {\n    if (bgr.length !== width * height * 3) {\n        throw new Error(\n            `fromCv2: data length ${bgr.length} does not match width * height * 3 = ${width * height * 3}.`,\n        );\n    }\n    const rgb = new Uint8Array(bgr.length);\n    for (let i = 0; i < bgr.length; i += 3) {\n        rgb[i] = bgr[i + 2] as number;\n        rgb[i + 1] = bgr[i + 1] as number;\n        rgb[i + 2] = bgr[i] as number;\n    }\n    return new RGBImage(rgb, width, height);\n}\n\n/**\n * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).\n *\n * Useful for round-tripping data to a Python OpenCV consumer.\n */\nexport function toCv2(image: RGBImage): Uint8Array {\n    const rgb = image.data;\n    const bgr = new Uint8Array(rgb.length);\n    for (let i = 0; i < rgb.length; i += 3) {\n        bgr[i] = rgb[i + 2] as number;\n        bgr[i + 1] = rgb[i + 1] as number;\n        bgr[i + 2] = rgb[i] as number;\n    }\n    return bgr;\n}\n\nexport interface LetterboxResult {\n    /** The padded image at the target size. */\n    readonly image: RGBImage;\n    /** The factor applied to the original image (`< 1` if downscaled). */\n    readonly scale: number;\n    /** Horizontal padding in pixels (left side; right side has the same or +1). */\n    readonly padLeft: number;\n    /** Vertical padding in pixels (top side). */\n    readonly padTop: number;\n}\n\n/**\n * Resize preserving aspect ratio, padding to `(targetWidth, targetHeight)`\n * with a constant fill color.\n *\n * Standard YOLO preprocessing — returning `scale` and `padLeft`/`padTop`\n * lets callers map detections back to the original image coordinates.\n */\nexport function letterbox(\n    image: RGBImage,\n    targetWidth: number,\n    targetHeight: number,\n    fill: readonly [number, number, number] = [114, 114, 114],\n): LetterboxResult {\n    const scale = Math.min(targetWidth / image.width, targetHeight / image.height);\n    const newW = Math.round(image.width * scale);\n    const newH = Math.round(image.height * scale);\n    const resized = resize(image, newW, newH);\n\n    const out = new Uint8Array(targetWidth * targetHeight * 3);\n    const f0 = fill[0];\n    const f1 = fill[1];\n    const f2 = fill[2];\n    for (let i = 0; i < out.length; i += 3) {\n        out[i] = f0;\n        out[i + 1] = f1;\n        out[i + 2] = f2;\n    }\n\n    const padLeft = Math.floor((targetWidth - newW) / 2);\n    const padTop = Math.floor((targetHeight - newH) / 2);\n    const rowBytes = newW * 3;\n    for (let y = 0; y < newH; y++) {\n        const srcOffset = y * rowBytes;\n        const dstOffset = ((padTop + y) * targetWidth + padLeft) * 3;\n        out.set(resized.data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);\n    }\n\n    return {\n        image: new RGBImage(out, targetWidth, targetHeight),\n        scale,\n        padLeft,\n        padTop,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"image.js","names":["ortRuntime","resize","targetWidth","targetHeight","image","srcCanvas","createCanvas","rgbToImageData","dstCanvas","dstCtx","get2DContext","imageData","imageDataToRGB","normalize","out","data","m0","mean","m1","m2","s0","std","s1","s2","i","scale","toFloat32","toCHW","expected","width","height","channels","hwc","chw","plane","y","x","hwcBase","planeIdx","c","toFloat32Tensor","dims","toTensor","fromCv2","bgr","rgb","RGBImage","toCv2","letterbox","newW","newH","resized","f0","fill","f1","f2","padLeft","padTop","rowBytes","srcOffset","dstOffset"],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/** @generated Vendored from @mauriciobenjamin700/ort-vision-sdk-web. Do not hand-edit — regenerate with `npm run vendor:vision`. */\n/**\n * Composable image preprocessing primitives (resize, normalize, letterbox, layout).\n *\n * Mirrors the Python `preprocess.image` module. Operates on the canonical\n * {@link RGBImage} (HWC RGB uint8) and produces uint8 or float32 buffers\n * depending on the operation.\n */\n\nimport * as ortRuntime from \"onnxruntime-web\";\nimport type * as ort from \"onnxruntime-web\";\n\nimport { createCanvas, get2DContext, imageDataToRGB, rgbToImageData } from \"../core/canvas\";\nimport { RGBImage } from \"../types\";\n\n/** Resize an image to `(targetWidth, targetHeight)` using high-quality canvas resampling. */\nexport function resize(image: RGBImage, targetWidth: number, targetHeight: number): RGBImage {\n    if (targetWidth <= 0 || targetHeight <= 0) {\n        throw new Error(`Invalid resize target ${targetWidth}x${targetHeight}.`);\n    }\n    if (targetWidth === image.width && targetHeight === image.height) {\n        return image;\n    }\n\n    const srcCanvas = createCanvas(image.width, image.height);\n    const srcCtx = get2DContext(srcCanvas);\n    srcCtx.putImageData(rgbToImageData(image), 0, 0);\n\n    const dstCanvas = createCanvas(targetWidth, targetHeight);\n    const dstCtx = get2DContext(dstCanvas);\n    dstCtx.imageSmoothingEnabled = true;\n    dstCtx.imageSmoothingQuality = \"high\";\n    dstCtx.drawImage(srcCanvas as CanvasImageSource, 0, 0, targetWidth, targetHeight);\n\n    const imageData = dstCtx.getImageData(0, 0, targetWidth, targetHeight);\n    return imageDataToRGB(imageData);\n}\n\n/**\n * Convert a uint8 image to a normalized float32 array (HWC layout preserved).\n *\n * Applies `(pixel * scale - mean) / std` channel-wise.\n */\nexport function normalize(\n    image: RGBImage,\n    mean: readonly [number, number, number],\n    std: readonly [number, number, number],\n    scale: number = 1 / 255,\n): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    const m0 = mean[0];\n    const m1 = mean[1];\n    const m2 = mean[2];\n    const s0 = std[0];\n    const s1 = std[1];\n    const s2 = std[2];\n    for (let i = 0; i < data.length; i += 3) {\n        out[i] = ((data[i] as number) * scale - m0) / s0;\n        out[i + 1] = ((data[i + 1] as number) * scale - m1) / s1;\n        out[i + 2] = ((data[i + 2] as number) * scale - m2) / s2;\n    }\n    return out;\n}\n\n/** Convert a uint8 image to a `Float32Array` in `[0, 1]` (HWC layout preserved). */\nexport function toFloat32(image: RGBImage, scale: number = 1 / 255): Float32Array {\n    const out = new Float32Array(image.data.length);\n    const data = image.data;\n    for (let i = 0; i < data.length; i++) {\n        out[i] = (data[i] as number) * scale;\n    }\n    return out;\n}\n\n/**\n * Transpose interleaved HWC data to planar CHW layout.\n *\n * @param hwc Source array of length `width * height * channels`.\n */\nexport function toCHW(\n    hwc: Float32Array,\n    width: number,\n    height: number,\n    channels: number = 3,\n): Float32Array {\n    const expected = width * height * channels;\n    if (hwc.length !== expected) {\n        throw new Error(\n            `toCHW: expected length ${expected} for ${width}x${height}x${channels}, got ${hwc.length}.`,\n        );\n    }\n    const chw = new Float32Array(expected);\n    const plane = width * height;\n    for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n            const hwcBase = (y * width + x) * channels;\n            const planeIdx = y * width + x;\n            for (let c = 0; c < channels; c++) {\n                chw[c * plane + planeIdx] = hwc[hwcBase + c] as number;\n            }\n        }\n    }\n    return chw;\n}\n\n/** Wrap a Float32 buffer into an `ort.Tensor`. */\nexport function toFloat32Tensor(data: Float32Array, dims: readonly number[]): ort.Tensor {\n    return new ortRuntime.Tensor(\"float32\", data, dims as number[]);\n}\n\n/**\n * Convert an HWC uint8 image to a CHW `Float32Array` scaled to `[0, 1]`.\n *\n * Mirrors `torchvision.transforms.ToTensor()` semantics: HWC → CHW,\n * `uint8 → float32 / 255`. Useful as input to YOLO-style detectors that\n * don't require ImageNet normalization.\n *\n * @returns CHW `Float32Array` of length `width * height * 3`.\n */\nexport function toTensor(image: RGBImage): Float32Array {\n    const f32 = toFloat32(image);\n    return toCHW(f32, image.width, image.height, 3);\n}\n\n/**\n * Convert an HWC BGR uint8 buffer (OpenCV layout) to the SDK's HWC RGB.\n *\n * Use when you receive image bytes from `cv2.imencode` over the wire and\n * want to feed them to the SDK without going through a canvas decode.\n *\n * @param bgr Flat BGR Uint8Array of length `width * height * 3`.\n */\nexport function fromCv2(bgr: Uint8Array, width: number, height: number): RGBImage {\n    if (bgr.length !== width * height * 3) {\n        throw new Error(\n            `fromCv2: data length ${bgr.length} does not match width * height * 3 = ${width * height * 3}.`,\n        );\n    }\n    const rgb = new Uint8Array(bgr.length);\n    for (let i = 0; i < bgr.length; i += 3) {\n        rgb[i] = bgr[i + 2] as number;\n        rgb[i + 1] = bgr[i + 1] as number;\n        rgb[i + 2] = bgr[i] as number;\n    }\n    return new RGBImage(rgb, width, height);\n}\n\n/**\n * Convert the SDK's HWC RGB image to an HWC BGR `Uint8Array` (OpenCV layout).\n *\n * Useful for round-tripping data to a Python OpenCV consumer.\n */\nexport function toCv2(image: RGBImage): Uint8Array {\n    const rgb = image.data;\n    const bgr = new Uint8Array(rgb.length);\n    for (let i = 0; i < rgb.length; i += 3) {\n        bgr[i] = rgb[i + 2] as number;\n        bgr[i + 1] = rgb[i + 1] as number;\n        bgr[i + 2] = rgb[i] as number;\n    }\n    return bgr;\n}\n\nexport interface LetterboxResult {\n    /** The padded image at the target size. */\n    readonly image: RGBImage;\n    /** The factor applied to the original image (`< 1` if downscaled). */\n    readonly scale: number;\n    /** Horizontal padding in pixels (left side; right side has the same or +1). */\n    readonly padLeft: number;\n    /** Vertical padding in pixels (top side). */\n    readonly padTop: number;\n}\n\n/**\n * Resize preserving aspect ratio, padding to `(targetWidth, targetHeight)`\n * with a constant fill color.\n *\n * Standard YOLO preprocessing — returning `scale` and `padLeft`/`padTop`\n * lets callers map detections back to the original image coordinates.\n */\nexport function letterbox(\n    image: RGBImage,\n    targetWidth: number,\n    targetHeight: number,\n    fill: readonly [number, number, number] = [114, 114, 114],\n): LetterboxResult {\n    const scale = Math.min(targetWidth / image.width, targetHeight / image.height);\n    const newW = Math.round(image.width * scale);\n    const newH = Math.round(image.height * scale);\n    const resized = resize(image, newW, newH);\n\n    const out = new Uint8Array(targetWidth * targetHeight * 3);\n    const f0 = fill[0];\n    const f1 = fill[1];\n    const f2 = fill[2];\n    for (let i = 0; i < out.length; i += 3) {\n        out[i] = f0;\n        out[i + 1] = f1;\n        out[i + 2] = f2;\n    }\n\n    const padLeft = Math.floor((targetWidth - newW) / 2);\n    const padTop = Math.floor((targetHeight - newH) / 2);\n    const rowBytes = newW * 3;\n    for (let y = 0; y < newH; y++) {\n        const srcOffset = y * rowBytes;\n        const dstOffset = ((padTop + y) * targetWidth + padLeft) * 3;\n        out.set(resized.data.subarray(srcOffset, srcOffset + rowBytes), dstOffset);\n    }\n\n    return {\n        image: new RGBImage(out, targetWidth, targetHeight),\n        scale,\n        padLeft,\n        padTop,\n    };\n}\n"],"mappings":"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"}