tempest-react-sdk 0.22.0 → 0.24.0

package/dist/vision/postprocess/detection.js

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

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

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

package/dist/vision/postprocess/segmentation.cjs

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

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

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

package/dist/vision/postprocess/segmentation.js

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

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

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

package/dist/vision/preprocess/image.cjs

@@ -0,0 +1,2 @@
+const e=require("../../_virtual/_rolldown/runtime.cjs"),t=require("../types.cjs"),n=require("../core/canvas.cjs");let r=require("onnxruntime-web");r=e.__toESM(r,1);function i(e,t,r){if(t<=0||r<=0)throw Error(`Invalid resize target ${t}x${r}.`);if(t===e.width&&r===e.height)return e;let i=n.createCanvas(e.width,e.height);n.get2DContext(i).putImageData(n.rgbToImageData(e),0,0);let a=n.get2DContext(n.createCanvas(t,r));return a.imageSmoothingEnabled=!0,a.imageSmoothingQuality=`high`,a.drawImage(i,0,0,t,r),n.imageDataToRGB(a.getImageData(0,0,t,r))}function a(e,t,n,r=1/255){let i=new Float32Array(e.data.length),a=e.data,o=t[0],s=t[1],c=t[2],l=n[0],u=n[1],d=n[2];for(let e=0;e<a.length;e+=3)i[e]=(a[e]*r-o)/l,i[e+1]=(a[e+1]*r-s)/u,i[e+2]=(a[e+2]*r-c)/d;return i}function o(e,t=1/255){let n=new Float32Array(e.data.length),r=e.data;for(let e=0;e<r.length;e++)n[e]=r[e]*t;return n}function s(e,t,n,r=3){let i=t*n*r;if(e.length!==i)throw Error(`toCHW: expected length ${i} for ${t}x${n}x${r}, got ${e.length}.`);let a=new Float32Array(i),o=t*n;for(let i=0;i<n;i++)for(let n=0;n<t;n++){let s=(i*t+n)*r,c=i*t+n;for(let t=0;t<r;t++)a[t*o+c]=e[s+t]}return a}function c(e,t){return new r.Tensor(`float32`,e,t)}function l(e){return s(o(e),e.width,e.height,3)}function u(e,n,r){if(e.length!==n*r*3)throw Error(`fromCv2: data length ${e.length} does not match width * height * 3 = ${n*r*3}.`);let i=new Uint8Array(e.length);for(let t=0;t<e.length;t+=3)i[t]=e[t+2],i[t+1]=e[t+1],i[t+2]=e[t];return new t.RGBImage(i,n,r)}function d(e){let t=e.data,n=new Uint8Array(t.length);for(let e=0;e<t.length;e+=3)n[e]=t[e+2],n[e+1]=t[e+1],n[e+2]=t[e];return n}function f(e,n,r,a=[114,114,114]){let o=Math.min(n/e.width,r/e.height),s=Math.round(e.width*o),c=Math.round(e.height*o),l=i(e,s,c),u=new Uint8Array(n*r*3),d=a[0],f=a[1],p=a[2];for(let e=0;e<u.length;e+=3)u[e]=d,u[e+1]=f,u[e+2]=p;let m=Math.floor((n-s)/2),h=Math.floor((r-c)/2),g=s*3;for(let e=0;e<c;e++){let t=e*g,r=((h+e)*n+m)*3;u.set(l.data.subarray(t,t+g),r)}return{image:new t.RGBImage(u,n,r),scale:o,padLeft:m,padTop:h}}exports.fromCv2=u,exports.letterbox=f,exports.normalize=a,exports.resize=i,exports.toCHW=s,exports.toCv2=d,exports.toFloat32=o,exports.toFloat32Tensor=c,exports.toTensor=l;
+//# sourceMappingURL=image.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.cjs","names":[],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/**\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":"oKAeA,SAAgB,EAAO,EAAiB,EAAqB,EAAgC,CACzF,GAAI,GAAe,GAAK,GAAgB,EACpC,MAAU,MAAM,yBAAyB,EAAY,GAAG,EAAa,EAAE,EAE3E,GAAI,IAAgB,EAAM,OAAS,IAAiB,EAAM,OACtD,OAAO,EAGX,IAAM,EAAY,EAAA,aAAa,EAAM,MAAO,EAAM,MAAM,EAExD,EADe,aAAa,CAC5B,CAAA,CAAO,aAAa,EAAA,eAAe,CAAK,EAAG,EAAG,CAAC,EAG/C,IAAM,EAAS,EAAA,aADG,EAAA,aAAa,EAAa,CAChB,CAAS,EAMrC,MALA,GAAO,sBAAwB,GAC/B,EAAO,sBAAwB,OAC/B,EAAO,UAAU,EAAgC,EAAG,EAAG,EAAa,CAAY,EAGzE,EAAA,eADW,EAAO,aAAa,EAAG,EAAG,EAAa,CACnC,CAAS,CACnC,CAOA,SAAgB,EACZ,EACA,EACA,EACA,EAAgB,EAAI,IACR,CACZ,IAAM,EAAM,IAAI,aAAa,EAAM,KAAK,MAAM,EACxC,EAAO,EAAM,KACb,EAAK,EAAK,GACV,EAAK,EAAK,GACV,EAAK,EAAK,GACV,EAAK,EAAI,GACT,EAAK,EAAI,GACT,EAAK,EAAI,GACf,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,GAAK,EAClC,EAAI,IAAO,EAAK,GAAgB,EAAQ,GAAM,EAC9C,EAAI,EAAI,IAAO,EAAK,EAAI,GAAgB,EAAQ,GAAM,EACtD,EAAI,EAAI,IAAO,EAAK,EAAI,GAAgB,EAAQ,GAAM,EAE1D,OAAO,CACX,CAGA,SAAgB,EAAU,EAAiB,EAAgB,EAAI,IAAmB,CAC9E,IAAM,EAAM,IAAI,aAAa,EAAM,KAAK,MAAM,EACxC,EAAO,EAAM,KACnB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,IAC7B,EAAI,GAAM,EAAK,GAAgB,EAEnC,OAAO,CACX,CAOA,SAAgB,EACZ,EACA,EACA,EACA,EAAmB,EACP,CACZ,IAAM,EAAW,EAAQ,EAAS,EAClC,GAAI,EAAI,SAAW,EACf,MAAU,MACN,0BAA0B,EAAS,OAAO,EAAM,GAAG,EAAO,GAAG,EAAS,QAAQ,EAAI,OAAO,EAC7F,EAEJ,IAAM,EAAM,IAAI,aAAa,CAAQ,EAC/B,EAAQ,EAAQ,EACtB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IACxB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IAAK,CAC5B,IAAM,GAAW,EAAI,EAAQ,GAAK,EAC5B,EAAW,EAAI,EAAQ,EAC7B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAU,IAC1B,EAAI,EAAI,EAAQ,GAAY,EAAI,EAAU,EAElD,CAEJ,OAAO,CACX,CAGA,SAAgB,EAAgB,EAAoB,EAAqC,CACrF,OAAO,IAAI,EAAW,OAAO,UAAW,EAAM,CAAgB,CAClE,CAWA,SAAgB,EAAS,EAA+B,CAEpD,OAAO,EADK,EAAU,CACT,EAAK,EAAM,MAAO,EAAM,OAAQ,CAAC,CAClD,CAUA,SAAgB,EAAQ,EAAiB,EAAe,EAA0B,CAC9E,GAAI,EAAI,SAAW,EAAQ,EAAS,EAChC,MAAU,MACN,wBAAwB,EAAI,OAAO,uCAAuC,EAAQ,EAAS,EAAE,EACjG,EAEJ,IAAM,EAAM,IAAI,WAAW,EAAI,MAAM,EACrC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,GAAK,EACjC,EAAI,GAAK,EAAI,EAAI,GACjB,EAAI,EAAI,GAAK,EAAI,EAAI,GACrB,EAAI,EAAI,GAAK,EAAI,GAErB,OAAO,IAAI,EAAA,SAAS,EAAK,EAAO,CAAM,CAC1C,CAOA,SAAgB,EAAM,EAA6B,CAC/C,IAAM,EAAM,EAAM,KACZ,EAAM,IAAI,WAAW,EAAI,MAAM,EACrC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,GAAK,EACjC,EAAI,GAAK,EAAI,EAAI,GACjB,EAAI,EAAI,GAAK,EAAI,EAAI,GACrB,EAAI,EAAI,GAAK,EAAI,GAErB,OAAO,CACX,CAoBA,SAAgB,EACZ,EACA,EACA,EACA,EAA0C,CAAC,IAAK,IAAK,GAAG,EACzC,CACf,IAAM,EAAQ,KAAK,IAAI,EAAc,EAAM,MAAO,EAAe,EAAM,MAAM,EACvE,EAAO,KAAK,MAAM,EAAM,MAAQ,CAAK,EACrC,EAAO,KAAK,MAAM,EAAM,OAAS,CAAK,EACtC,EAAU,EAAO,EAAO,EAAM,CAAI,EAElC,EAAM,IAAI,WAAW,EAAc,EAAe,CAAC,EACnD,EAAK,EAAK,GACV,EAAK,EAAK,GACV,EAAK,EAAK,GAChB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,GAAK,EACjC,EAAI,GAAK,EACT,EAAI,EAAI,GAAK,EACb,EAAI,EAAI,GAAK,EAGjB,IAAM,EAAU,KAAK,OAAO,EAAc,GAAQ,CAAC,EAC7C,EAAS,KAAK,OAAO,EAAe,GAAQ,CAAC,EAC7C,EAAW,EAAO,EACxB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,IAAK,CAC3B,IAAM,EAAY,EAAI,EAChB,IAAc,EAAS,GAAK,EAAc,GAAW,EAC3D,EAAI,IAAI,EAAQ,KAAK,SAAS,EAAW,EAAY,CAAQ,EAAG,CAAS,CAC7E,CAEA,MAAO,CACH,MAAO,IAAI,EAAA,SAAS,EAAK,EAAa,CAAY,EAClD,QACA,UACA,QACJ,CACJ"}

package/dist/vision/preprocess/image.js

@@ -0,0 +1,72 @@
+import { RGBImage as e } from "../types.js";
+import { createCanvas as t, get2DContext as n, imageDataToRGB as r, rgbToImageData as i } from "../core/canvas.js";
+import * as a from "onnxruntime-web";
+//#region src/vision/preprocess/image.ts
+function o(e, a, o) {
+	if (a <= 0 || o <= 0) throw Error(`Invalid resize target ${a}x${o}.`);
+	if (a === e.width && o === e.height) return e;
+	let s = t(e.width, e.height);
+	n(s).putImageData(i(e), 0, 0);
+	let c = n(t(a, o));
+	return c.imageSmoothingEnabled = !0, c.imageSmoothingQuality = "high", c.drawImage(s, 0, 0, a, o), r(c.getImageData(0, 0, a, o));
+}
+function s(e, t, n, r = 1 / 255) {
+	let i = new Float32Array(e.data.length), a = e.data, o = t[0], s = t[1], c = t[2], l = n[0], u = n[1], d = n[2];
+	for (let e = 0; e < a.length; e += 3) i[e] = (a[e] * r - o) / l, i[e + 1] = (a[e + 1] * r - s) / u, i[e + 2] = (a[e + 2] * r - c) / d;
+	return i;
+}
+function c(e, t = 1 / 255) {
+	let n = new Float32Array(e.data.length), r = e.data;
+	for (let e = 0; e < r.length; e++) n[e] = r[e] * t;
+	return n;
+}
+function l(e, t, n, r = 3) {
+	let i = t * n * r;
+	if (e.length !== i) throw Error(`toCHW: expected length ${i} for ${t}x${n}x${r}, got ${e.length}.`);
+	let a = new Float32Array(i), o = t * n;
+	for (let i = 0; i < n; i++) for (let n = 0; n < t; n++) {
+		let s = (i * t + n) * r, c = i * t + n;
+		for (let t = 0; t < r; t++) a[t * o + c] = e[s + t];
+	}
+	return a;
+}
+function u(e, t) {
+	return new a.Tensor("float32", e, t);
+}
+function d(e) {
+	return l(c(e), e.width, e.height, 3);
+}
+function f(t, n, r) {
+	if (t.length !== n * r * 3) throw Error(`fromCv2: data length ${t.length} does not match width * height * 3 = ${n * r * 3}.`);
+	let i = new Uint8Array(t.length);
+	for (let e = 0; e < t.length; e += 3) i[e] = t[e + 2], i[e + 1] = t[e + 1], i[e + 2] = t[e];
+	return new e(i, n, r);
+}
+function p(e) {
+	let t = e.data, n = new Uint8Array(t.length);
+	for (let e = 0; e < t.length; e += 3) n[e] = t[e + 2], n[e + 1] = t[e + 1], n[e + 2] = t[e];
+	return n;
+}
+function m(t, n, r, i = [
+	114,
+	114,
+	114
+]) {
+	let a = Math.min(n / t.width, r / t.height), s = Math.round(t.width * a), c = Math.round(t.height * a), l = o(t, s, c), u = new Uint8Array(n * r * 3), d = i[0], f = i[1], p = i[2];
+	for (let e = 0; e < u.length; e += 3) u[e] = d, u[e + 1] = f, u[e + 2] = p;
+	let m = Math.floor((n - s) / 2), h = Math.floor((r - c) / 2), g = s * 3;
+	for (let e = 0; e < c; e++) {
+		let t = e * g, r = ((h + e) * n + m) * 3;
+		u.set(l.data.subarray(t, t + g), r);
+	}
+	return {
+		image: new e(u, n, r),
+		scale: a,
+		padLeft: m,
+		padTop: h
+	};
+}
+//#endregion
+export { f as fromCv2, m as letterbox, s as normalize, o as resize, l as toCHW, p as toCv2, c as toFloat32, u as toFloat32Tensor, d as toTensor };
+
+//# sourceMappingURL=image.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image.js","names":[],"sources":["../../../src/vision/preprocess/image.ts"],"sourcesContent":["/**\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/results.cjs

@@ -0,0 +1,2 @@
+var e=class{xyxy;cls;conf;origShape;constructor(e,t,n,r){this.xyxy=e,this.cls=t,this.conf=n,this.origShape=r}get length(){return this.cls.length}get shape(){return[this.length,4]}get xywh(){let e=new Float32Array(this.xyxy.length);for(let t=0;t<this.length;t++){let n=this.xyxy[t*4],r=this.xyxy[t*4+1],i=this.xyxy[t*4+2],a=this.xyxy[t*4+3];e[t*4]=(n+i)/2,e[t*4+1]=(r+a)/2,e[t*4+2]=i-n,e[t*4+3]=a-r}return e}get xyxyn(){let[e,t]=this.origShape,n=new Float32Array(this.xyxy.length);if(this.length===0||t<=0||e<=0)return n;for(let r=0;r<this.length;r++)n[r*4]=this.xyxy[r*4]/t,n[r*4+1]=this.xyxy[r*4+1]/e,n[r*4+2]=this.xyxy[r*4+2]/t,n[r*4+3]=this.xyxy[r*4+3]/e;return n}get xywhn(){let e=this.xywh,[t,n]=this.origShape;if(this.length===0||n<=0||t<=0)return e;for(let r=0;r<this.length;r++)e[r*4]=e[r*4]/n,e[r*4+1]=e[r*4+1]/t,e[r*4+2]=e[r*4+2]/n,e[r*4+3]=e[r*4+3]/t;return e}get data(){let e=new Float32Array(this.length*6);for(let t=0;t<this.length;t++)e[t*6]=this.xyxy[t*4],e[t*6+1]=this.xyxy[t*4+1],e[t*6+2]=this.xyxy[t*4+2],e[t*6+3]=this.xyxy[t*4+3],e[t*6+4]=this.conf[t],e[t*6+5]=this.cls[t];return e}},t=class{data;constructor(e){this.data=e}get length(){return this.data.length}get shape(){return[this.length]}get top1(){if(this.data.length===0)return 0;let e=0,t=this.data[0];for(let n=1;n<this.data.length;n++){let r=this.data[n];r>t&&(e=n,t=r)}return e}get top1conf(){return this.data.length===0?0:this.data[this.top1]}get top5(){return this._topK(5).indices}get top5conf(){return this._topK(5).values}_topK(e){let t=Math.min(e,this.data.length),n=[];for(let e=0;e<this.data.length;e++)n.push(e);n.sort((e,t)=>this.data[t]-this.data[e]);let r=new Int32Array(t),i=new Float32Array(t);for(let e=0;e<t;e++)r[e]=n[e],i[e]=this.data[n[e]];return{indices:r,values:i}}},n=class{data;xyxy;origShape;constructor(e,t,n){this.data=e,this.xyxy=t,this.origShape=n}get length(){return this.data.length}get shape(){return[this.length]}[Symbol.iterator](){return this.data[Symbol.iterator]()}},r=class{boxes;detections;names;origImg;origShape;path;speed;constructor(e,t,n,r,i,a=null,o={}){this.boxes=e,this.detections=t,this.names=n,this.origImg=r,this.origShape=i,this.path=a,this.speed=o}get length(){return this.detections.length}get(e){return this.detections[e]}[Symbol.iterator](){return this.detections[Symbol.iterator]()}},i=class{probs;result;names;origImg;origShape;path;speed;constructor(e,t,n,r,i,a=null,o={}){this.probs=e,this.result=t,this.names=n,this.origImg=r,this.origShape=i,this.path=a,this.speed=o}get cls(){return this.probs.top1}get conf(){return this.probs.top1conf}get name(){return this.names[this.cls]??`class_${this.cls}`}get probabilities(){return this.result.probabilities}},a=class{boxes;masks;detections;names;origImg;origShape;path;speed;constructor(e,t,n,r,i,a,o=null,s={}){this.boxes=e,this.masks=t,this.detections=n,this.names=r,this.origImg=i,this.origShape=a,this.path=o,this.speed=s}get length(){return this.detections.length}get(e){return this.detections[e]}[Symbol.iterator](){return this.detections[Symbol.iterator]()}};exports.Boxes=e,exports.ClassificationResults=i,exports.DetectionResults=r,exports.Masks=n,exports.Probs=t,exports.SegmentationResults=a;
+//# sourceMappingURL=results.cjs.map

package/dist/vision/results.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"results.cjs","names":[],"sources":["../../src/vision/results.ts"],"sourcesContent":["/**\n * Per-image result envelopes — Ultralytics-style `Results` for the SDK.\n *\n * Each `predict()` call returns a 1-element array of these envelopes,\n * mirroring `YOLO(\"img.jpg\")`. Each envelope holds:\n *\n * - A bulk-array view of the predictions (`Boxes`, `Probs`, `Masks`) with\n *   the exact attribute names Ultralytics uses (`xyxy`, `xywh`, `xyxyn`,\n *   `xywhn`, `cls`, `conf`, `data`, `top1`, `top5`).\n * - Per-instance dataclasses (`DetectionResult`, `SegmentationResult`,\n *   `ClassProbability`) for callers who prefer the OO interface.\n * - `names`: `Record<number, string>` matching Ultralytics' `model.names`.\n * - `origImg` / `origShape` / `path`: provenance for the original input.\n */\n\nimport {\n    type ClassificationResult,\n    type DetectionResult,\n    type RGBImage,\n    type SegmentationResult,\n} from \"./types\";\n\n/**\n * Bulk numpy-style view of detected boxes for a single image.\n *\n * Mirrors Ultralytics' `Boxes` interface. Coordinates in {@link xyxy} and\n * {@link xywh} are absolute pixels in the original image; the `*n` variants\n * are normalized to `[0, 1]` using `origShape`.\n */\nexport class Boxes {\n    /**\n     * @param xyxy Flat array of length `4 * N` in `[x1, y1, x2, y2, ...]` order.\n     * @param cls One class index per box, length `N`.\n     * @param conf One confidence per box, length `N`.\n     * @param origShape `[height, width]` of the original image.\n     */\n    constructor(\n        public readonly xyxy: Float32Array,\n        public readonly cls: Int32Array,\n        public readonly conf: Float32Array,\n        public readonly origShape: readonly [number, number],\n    ) {}\n\n    /** Number of detected boxes. */\n    get length(): number {\n        return this.cls.length;\n    }\n\n    /** `[N, 4]` shape of the `xyxy` view. */\n    get shape(): readonly [number, number] {\n        return [this.length, 4];\n    }\n\n    /** Boxes as `[N, 4]` `[cx, cy, w, h]` flat array in absolute pixels. */\n    get xywh(): Float32Array {\n        const out = new Float32Array(this.xyxy.length);\n        for (let i = 0; i < this.length; i++) {\n            const x1 = this.xyxy[i * 4] as number;\n            const y1 = this.xyxy[i * 4 + 1] as number;\n            const x2 = this.xyxy[i * 4 + 2] as number;\n            const y2 = this.xyxy[i * 4 + 3] as number;\n            out[i * 4] = (x1 + x2) / 2;\n            out[i * 4 + 1] = (y1 + y2) / 2;\n            out[i * 4 + 2] = x2 - x1;\n            out[i * 4 + 3] = y2 - y1;\n        }\n        return out;\n    }\n\n    /** Boxes as `[N, 4]` `[x1, y1, x2, y2]` normalized to `[0, 1]`. */\n    get xyxyn(): Float32Array {\n        const [h, w] = this.origShape;\n        const out = new Float32Array(this.xyxy.length);\n        if (this.length === 0 || w <= 0 || h <= 0) return out;\n        for (let i = 0; i < this.length; i++) {\n            out[i * 4] = (this.xyxy[i * 4] as number) / w;\n            out[i * 4 + 1] = (this.xyxy[i * 4 + 1] as number) / h;\n            out[i * 4 + 2] = (this.xyxy[i * 4 + 2] as number) / w;\n            out[i * 4 + 3] = (this.xyxy[i * 4 + 3] as number) / h;\n        }\n        return out;\n    }\n\n    /** Boxes as `[N, 4]` `[cx, cy, w, h]` normalized to `[0, 1]`. */\n    get xywhn(): Float32Array {\n        const xywh = this.xywh;\n        const [h, w] = this.origShape;\n        if (this.length === 0 || w <= 0 || h <= 0) return xywh;\n        for (let i = 0; i < this.length; i++) {\n            xywh[i * 4] = (xywh[i * 4] as number) / w;\n            xywh[i * 4 + 1] = (xywh[i * 4 + 1] as number) / h;\n            xywh[i * 4 + 2] = (xywh[i * 4 + 2] as number) / w;\n            xywh[i * 4 + 3] = (xywh[i * 4 + 3] as number) / h;\n        }\n        return xywh;\n    }\n\n    /**\n     * Concatenated `[N, 6]` array of `[x1, y1, x2, y2, conf, cls]`.\n     *\n     * Matches Ultralytics' `boxes.data`.\n     */\n    get data(): Float32Array {\n        const out = new Float32Array(this.length * 6);\n        for (let i = 0; i < this.length; i++) {\n            out[i * 6] = this.xyxy[i * 4] as number;\n            out[i * 6 + 1] = this.xyxy[i * 4 + 1] as number;\n            out[i * 6 + 2] = this.xyxy[i * 4 + 2] as number;\n            out[i * 6 + 3] = this.xyxy[i * 4 + 3] as number;\n            out[i * 6 + 4] = this.conf[i] as number;\n            out[i * 6 + 5] = this.cls[i] as number;\n        }\n        return out;\n    }\n}\n\n/**\n * Top-k classification probabilities for a single image.\n *\n * Mirrors Ultralytics' `Probs` interface.\n */\nexport class Probs {\n    /** @param data `[numClasses]` per-class probabilities, indexed by class id. */\n    constructor(public readonly data: Float32Array) {}\n\n    /** Number of classes. */\n    get length(): number {\n        return this.data.length;\n    }\n\n    /** `[numClasses]` shape of the underlying vector. */\n    get shape(): readonly [number] {\n        return [this.length];\n    }\n\n    /** Index of the most probable class. */\n    get top1(): number {\n        if (this.data.length === 0) return 0;\n        let best = 0;\n        let bestVal = this.data[0] as number;\n        for (let i = 1; i < this.data.length; i++) {\n            const v = this.data[i] as number;\n            if (v > bestVal) {\n                best = i;\n                bestVal = v;\n            }\n        }\n        return best;\n    }\n\n    /** Probability of the top-1 class. */\n    get top1conf(): number {\n        if (this.data.length === 0) return 0;\n        return this.data[this.top1] as number;\n    }\n\n    /** Indices of the top-5 most probable classes, descending. */\n    get top5(): Int32Array {\n        return this._topK(5).indices;\n    }\n\n    /** Probabilities of the top-5 classes, descending. */\n    get top5conf(): Float32Array {\n        return this._topK(5).values;\n    }\n\n    private _topK(k: number): { indices: Int32Array; values: Float32Array } {\n        const n = Math.min(k, this.data.length);\n        const order: number[] = [];\n        for (let i = 0; i < this.data.length; i++) order.push(i);\n        order.sort((a, b) => (this.data[b] as number) - (this.data[a] as number));\n        const indices = new Int32Array(n);\n        const values = new Float32Array(n);\n        for (let i = 0; i < n; i++) {\n            indices[i] = order[i] as number;\n            values[i] = this.data[order[i] as number] as number;\n        }\n        return { indices, values };\n    }\n}\n\n/**\n * Per-instance binary masks for a single image.\n *\n * Each mask is cropped to its instance's bounding box. To paint masks onto\n * a full-image canvas, use `xyxy[i]` as the top-left target.\n */\nexport class Masks {\n    /**\n     * @param data Per-instance binary masks (`Mask` objects from `types.ts`).\n     * @param xyxy Flat `[N, 4]` of bounding-box coordinates in original pixels.\n     * @param origShape `[height, width]` of the original image.\n     */\n    constructor(\n        public readonly data: ReadonlyArray<{\n            readonly data: Uint8Array;\n            readonly width: number;\n            readonly height: number;\n        }>,\n        public readonly xyxy: Float32Array,\n        public readonly origShape: readonly [number, number],\n    ) {}\n\n    /** Number of instance masks. */\n    get length(): number {\n        return this.data.length;\n    }\n\n    /** `[N]` shape of the masks collection. */\n    get shape(): readonly [number] {\n        return [this.length];\n    }\n\n    [Symbol.iterator](): Iterator<{\n        readonly data: Uint8Array;\n        readonly width: number;\n        readonly height: number;\n    }> {\n        return this.data[Symbol.iterator]();\n    }\n}\n\n/**\n * Per-image detection envelope (Ultralytics-style `Results`).\n *\n * Iterating yields per-instance {@link DetectionResult} entries, so legacy\n * code that did `for (const d of detector.predict(img))` only needs an\n * extra `[0]` to bridge:\n *\n * ```typescript\n * for (const d of (await detector.predict(img))[0]) {\n *   console.log(d.cls, d.conf, d.box.xyxy);\n * }\n * ```\n *\n * For numpy-style bulk access, use the `boxes` collection.\n */\nexport class DetectionResults implements Iterable<DetectionResult> {\n    constructor(\n        public readonly boxes: Boxes,\n        public readonly detections: readonly DetectionResult[],\n        public readonly names: Readonly<Record<number, string>>,\n        public readonly origImg: RGBImage,\n        public readonly origShape: readonly [number, number],\n        public readonly path: string | null = null,\n        public readonly speed: Readonly<Record<string, number>> = {},\n    ) {}\n\n    /** Number of surviving detections. */\n    get length(): number {\n        return this.detections.length;\n    }\n\n    /** Index into the per-instance detections. */\n    get(index: number): DetectionResult | undefined {\n        return this.detections[index];\n    }\n\n    [Symbol.iterator](): Iterator<DetectionResult> {\n        return this.detections[Symbol.iterator]();\n    }\n}\n\n/**\n * Per-image classification envelope (Ultralytics-style `Results`).\n */\nexport class ClassificationResults {\n    constructor(\n        public readonly probs: Probs,\n        public readonly result: ClassificationResult,\n        public readonly names: Readonly<Record<number, string>>,\n        public readonly origImg: RGBImage,\n        public readonly origShape: readonly [number, number],\n        public readonly path: string | null = null,\n        public readonly speed: Readonly<Record<string, number>> = {},\n    ) {}\n\n    /** Top-1 class index (Ultralytics-style alias). */\n    get cls(): number {\n        return this.probs.top1;\n    }\n\n    /** Top-1 confidence (Ultralytics-style alias). */\n    get conf(): number {\n        return this.probs.top1conf;\n    }\n\n    /** Top-1 class name. */\n    get name(): string {\n        return this.names[this.cls] ?? `class_${this.cls}`;\n    }\n\n    /** Per-class probability list, sorted descending (legacy field). */\n    get probabilities(): readonly ClassificationResult[\"probabilities\"][number][] {\n        return this.result.probabilities;\n    }\n}\n\n/**\n * Per-image instance-segmentation envelope (Ultralytics-style `Results`).\n *\n * Iterating yields per-instance {@link SegmentationResult} entries. `boxes`\n * and `masks` mirror Ultralytics' bulk-array views.\n */\nexport class SegmentationResults implements Iterable<SegmentationResult> {\n    constructor(\n        public readonly boxes: Boxes,\n        public readonly masks: Masks,\n        public readonly detections: readonly SegmentationResult[],\n        public readonly names: Readonly<Record<number, string>>,\n        public readonly origImg: RGBImage,\n        public readonly origShape: readonly [number, number],\n        public readonly path: string | null = null,\n        public readonly speed: Readonly<Record<string, number>> = {},\n    ) {}\n\n    /** Number of surviving instances. */\n    get length(): number {\n        return this.detections.length;\n    }\n\n    /** Index into the per-instance results. */\n    get(index: number): SegmentationResult | undefined {\n        return this.detections[index];\n    }\n\n    [Symbol.iterator](): Iterator<SegmentationResult> {\n        return this.detections[Symbol.iterator]();\n    }\n}\n"],"mappings":"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"}