@jax-data-science/sci-image-visualizer 0.1.0

package/esm2022/lib/toolbar/crop/slide-crop.mjs

@@ -0,0 +1,57 @@
+/**
+ * Browser "slide crop": extract the box region (data coords) from a cached image
+ * frame as an RGBA image, clamped to the image bounds. Grayscale frames are
+ * replicated across R/G/B; RGB tuples are copied through. Returns null when the
+ * box is empty/outside the image.
+ *
+ * The output feeds an automatic segmenter (e.g. cellpose-SAM): run it on the
+ * crop, then offset the resulting masks by (matrixX0, matrixY0) to place them
+ * back on the full frame.
+ */
+export function cropImageRegion(cached, frameIndex, box) {
+    const rx = cached.ratios[0] || 1;
+    const ry = cached.ratios[0] || 1;
+    const ox = cached.originX ?? 0;
+    const oy = cached.originY ?? 0;
+    // data -> image (matrix) coords, normalized + clamped to the frame.
+    let mx0 = Math.round((Math.min(box.x0, box.x1) - ox) / rx);
+    let my0 = Math.round((Math.min(box.y0, box.y1) - oy) / ry);
+    let mx1 = Math.round((Math.max(box.x0, box.x1) - ox) / rx);
+    let my1 = Math.round((Math.max(box.y0, box.y1) - oy) / ry);
+    mx0 = Math.max(0, Math.min(cached.width, mx0));
+    my0 = Math.max(0, Math.min(cached.height, my0));
+    mx1 = Math.max(0, Math.min(cached.width, mx1));
+    my1 = Math.max(0, Math.min(cached.height, my1));
+    const cw = mx1 - mx0;
+    const ch = my1 - my0;
+    if (cw <= 0 || ch <= 0)
+        return null;
+    const frame = cached.frames[frameIndex] ?? cached.frames[0];
+    const data = new Uint8ClampedArray(cw * ch * 4);
+    for (let y = 0; y < ch; y++) {
+        const row = frame?.[my0 + y];
+        for (let x = 0; x < cw; x++) {
+            const o = (y * cw + x) * 4;
+            const px = row?.[mx0 + x];
+            if (px == null) {
+                data[o + 3] = 255;
+                continue;
+            }
+            if (cached.isGrayscale) {
+                const v = px;
+                data[o] = v;
+                data[o + 1] = v;
+                data[o + 2] = v;
+            }
+            else {
+                const t = px;
+                data[o] = t[0];
+                data[o + 1] = t[1];
+                data[o + 2] = t[2];
+            }
+            data[o + 3] = 255;
+        }
+    }
+    return { data, width: cw, height: ch, matrixX0: mx0, matrixY0: my0 };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpZGUtY3JvcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdG9vbGJhci9jcm9wL3NsaWRlLWNyb3AudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBaUJBOzs7Ozs7Ozs7R0FTRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQzdCLE1BQXVCLEVBQUUsVUFBa0IsRUFBRSxHQUFZO0lBRXpELE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2pDLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2pDLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxPQUFPLElBQUksQ0FBQyxDQUFDO0lBQy9CLE1BQU0sRUFBRSxHQUFHLE1BQU0sQ0FBQyxPQUFPLElBQUksQ0FBQyxDQUFDO0lBQy9CLG9FQUFvRTtJQUNwRSxJQUFJLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUMzRCxJQUFJLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUMzRCxJQUFJLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUMzRCxJQUFJLEdBQUcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUMzRCxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDL0MsR0FBRyxHQUFHLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLE1BQU0sRUFBRSxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2hELEdBQUcsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsRUFBRSxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEVBQUUsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUMvQyxHQUFHLEdBQUcsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDaEQsTUFBTSxFQUFFLEdBQUcsR0FBRyxHQUFHLEdBQUcsQ0FBQztJQUNyQixNQUFNLEVBQUUsR0FBRyxHQUFHLEdBQUcsR0FBRyxDQUFDO0lBQ3JCLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQztRQUFFLE9BQU8sSUFBSSxDQUFDO0lBRXBDLE1BQU0sS0FBSyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsVUFBVSxDQUFDLElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUM1RCxNQUFNLElBQUksR0FBRyxJQUFJLGlCQUFpQixDQUFDLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDaEQsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQzVCLE1BQU0sR0FBRyxHQUFHLEtBQUssRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQztRQUM3QixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7WUFDNUIsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUMzQixNQUFNLEVBQUUsR0FBRyxHQUFHLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUM7WUFDMUIsSUFBSSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUM7Z0JBQUMsSUFBSSxDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBRyxHQUFHLENBQUM7Z0JBQUMsU0FBUztZQUFDLENBQUM7WUFDaEQsSUFBSSxNQUFNLENBQUMsV0FBVyxFQUFFLENBQUM7Z0JBQ3ZCLE1BQU0sQ0FBQyxHQUFHLEVBQVksQ0FBQztnQkFDdkIsSUFBSSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUNoRCxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sTUFBTSxDQUFDLEdBQUcsRUFBYyxDQUFDO2dCQUN6QixJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3pELENBQUM7WUFDRCxJQUFJLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxHQUFHLEdBQUcsQ0FBQztRQUNwQixDQUFDO0lBQ0gsQ0FBQztJQUNELE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsRUFBRSxFQUFFLFFBQVEsRUFBRSxHQUFHLEVBQUUsUUFBUSxFQUFFLEdBQUcsRUFBRSxDQUFDO0FBQ3ZFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDYWNoZWRJbWFnZURhdGEgfSBmcm9tICcuLi93YW5kL3dhbmQtdG9vbC5zZXJ2aWNlJztcblxuLyoqIEEgY2xpZW50LXNpZGUgY3JvcCBvZiB0aGUgbG9hZGVkIGltYWdlIOKAlCB0aGUgYnJvd3NlciBlcXVpdmFsZW50IG9mIHRoZSBKSVRcbiAqICBzZXJ2ZXIgc2xpZGUtY3JvcCwgdGFrZW4gZnJvbSB0aGUgcGl4ZWxzIGFscmVhZHkgaW4gdGhlIHZpZXdlci4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ3JvcHBlZEltYWdlIHtcbiAgLyoqIFJHQkEgcGl4ZWxzIG9mIHRoZSBjcm9wLCByb3ctbWFqb3IuICovXG4gIGRhdGE6IFVpbnQ4Q2xhbXBlZEFycmF5O1xuICB3aWR0aDogbnVtYmVyO1xuICBoZWlnaHQ6IG51bWJlcjtcbiAgLyoqIENyb3Agb3JpZ2luIGluIGltYWdlIChtYXRyaXgpIGNvb3JkcyDigJQgbGV0cyBtYXNrcyBtYXAgYmFjayB0byB0aGUgZnJhbWUuICovXG4gIG1hdHJpeFgwOiBudW1iZXI7XG4gIG1hdHJpeFkwOiBudW1iZXI7XG59XG5cbi8qKiBBIGJveCBpbiBpbWFnZSAqZGF0YSogY29vcmRpbmF0ZXMgKGFzIHN0b3JlZCBvbiBhIFJlY3RhbmdsZSByZWdpb24pLiAqL1xuZXhwb3J0IGludGVyZmFjZSBEYXRhQm94IHsgeDA6IG51bWJlcjsgeTA6IG51bWJlcjsgeDE6IG51bWJlcjsgeTE6IG51bWJlcjsgfVxuXG4vKipcbiAqIEJyb3dzZXIgXCJzbGlkZSBjcm9wXCI6IGV4dHJhY3QgdGhlIGJveCByZWdpb24gKGRhdGEgY29vcmRzKSBmcm9tIGEgY2FjaGVkIGltYWdlXG4gKiBmcmFtZSBhcyBhbiBSR0JBIGltYWdlLCBjbGFtcGVkIHRvIHRoZSBpbWFnZSBib3VuZHMuIEdyYXlzY2FsZSBmcmFtZXMgYXJlXG4gKiByZXBsaWNhdGVkIGFjcm9zcyBSL0cvQjsgUkdCIHR1cGxlcyBhcmUgY29waWVkIHRocm91Z2guIFJldHVybnMgbnVsbCB3aGVuIHRoZVxuICogYm94IGlzIGVtcHR5L291dHNpZGUgdGhlIGltYWdlLlxuICpcbiAqIFRoZSBvdXRwdXQgZmVlZHMgYW4gYXV0b21hdGljIHNlZ21lbnRlciAoZS5nLiBjZWxscG9zZS1TQU0pOiBydW4gaXQgb24gdGhlXG4gKiBjcm9wLCB0aGVuIG9mZnNldCB0aGUgcmVzdWx0aW5nIG1hc2tzIGJ5IChtYXRyaXhYMCwgbWF0cml4WTApIHRvIHBsYWNlIHRoZW1cbiAqIGJhY2sgb24gdGhlIGZ1bGwgZnJhbWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcm9wSW1hZ2VSZWdpb24oXG4gIGNhY2hlZDogQ2FjaGVkSW1hZ2VEYXRhLCBmcmFtZUluZGV4OiBudW1iZXIsIGJveDogRGF0YUJveCxcbik6IENyb3BwZWRJbWFnZSB8IG51bGwge1xuICBjb25zdCByeCA9IGNhY2hlZC5yYXRpb3NbMF0gfHwgMTtcbiAgY29uc3QgcnkgPSBjYWNoZWQucmF0aW9zWzBdIHx8IDE7XG4gIGNvbnN0IG94ID0gY2FjaGVkLm9yaWdpblggPz8gMDtcbiAgY29uc3Qgb3kgPSBjYWNoZWQub3JpZ2luWSA/PyAwO1xuICAvLyBkYXRhIC0+IGltYWdlIChtYXRyaXgpIGNvb3Jkcywgbm9ybWFsaXplZCArIGNsYW1wZWQgdG8gdGhlIGZyYW1lLlxuICBsZXQgbXgwID0gTWF0aC5yb3VuZCgoTWF0aC5taW4oYm94LngwLCBib3gueDEpIC0gb3gpIC8gcngpO1xuICBsZXQgbXkwID0gTWF0aC5yb3VuZCgoTWF0aC5taW4oYm94LnkwLCBib3gueTEpIC0gb3kpIC8gcnkpO1xuICBsZXQgbXgxID0gTWF0aC5yb3VuZCgoTWF0aC5tYXgoYm94LngwLCBib3gueDEpIC0gb3gpIC8gcngpO1xuICBsZXQgbXkxID0gTWF0aC5yb3VuZCgoTWF0aC5tYXgoYm94LnkwLCBib3gueTEpIC0gb3kpIC8gcnkpO1xuICBteDAgPSBNYXRoLm1heCgwLCBNYXRoLm1pbihjYWNoZWQud2lkdGgsIG14MCkpO1xuICBteTAgPSBNYXRoLm1heCgwLCBNYXRoLm1pbihjYWNoZWQuaGVpZ2h0LCBteTApKTtcbiAgbXgxID0gTWF0aC5tYXgoMCwgTWF0aC5taW4oY2FjaGVkLndpZHRoLCBteDEpKTtcbiAgbXkxID0gTWF0aC5tYXgoMCwgTWF0aC5taW4oY2FjaGVkLmhlaWdodCwgbXkxKSk7XG4gIGNvbnN0IGN3ID0gbXgxIC0gbXgwO1xuICBjb25zdCBjaCA9IG15MSAtIG15MDtcbiAgaWYgKGN3IDw9IDAgfHwgY2ggPD0gMCkgcmV0dXJuIG51bGw7XG5cbiAgY29uc3QgZnJhbWUgPSBjYWNoZWQuZnJhbWVzW2ZyYW1lSW5kZXhdID8/IGNhY2hlZC5mcmFtZXNbMF07XG4gIGNvbnN0IGRhdGEgPSBuZXcgVWludDhDbGFtcGVkQXJyYXkoY3cgKiBjaCAqIDQpO1xuICBmb3IgKGxldCB5ID0gMDsgeSA8IGNoOyB5KyspIHtcbiAgICBjb25zdCByb3cgPSBmcmFtZT8uW215MCArIHldO1xuICAgIGZvciAobGV0IHggPSAwOyB4IDwgY3c7IHgrKykge1xuICAgICAgY29uc3QgbyA9ICh5ICogY3cgKyB4KSAqIDQ7XG4gICAgICBjb25zdCBweCA9IHJvdz8uW214MCArIHhdO1xuICAgICAgaWYgKHB4ID09IG51bGwpIHsgZGF0YVtvICsgM10gPSAyNTU7IGNvbnRpbnVlOyB9XG4gICAgICBpZiAoY2FjaGVkLmlzR3JheXNjYWxlKSB7XG4gICAgICAgIGNvbnN0IHYgPSBweCBhcyBudW1iZXI7XG4gICAgICAgIGRhdGFbb10gPSB2OyBkYXRhW28gKyAxXSA9IHY7IGRhdGFbbyArIDJdID0gdjtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGNvbnN0IHQgPSBweCBhcyBudW1iZXJbXTtcbiAgICAgICAgZGF0YVtvXSA9IHRbMF07IGRhdGFbbyArIDFdID0gdFsxXTsgZGF0YVtvICsgMl0gPSB0WzJdO1xuICAgICAgfVxuICAgICAgZGF0YVtvICsgM10gPSAyNTU7XG4gICAgfVxuICB9XG4gIHJldHVybiB7IGRhdGEsIHdpZHRoOiBjdywgaGVpZ2h0OiBjaCwgbWF0cml4WDA6IG14MCwgbWF0cml4WTA6IG15MCB9O1xufVxuIl19

package/esm2022/lib/toolbar/segmentation/cell-segment-tool.service.mjs

@@ -0,0 +1,115 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { WandService } from '../wand/wand.service';
+import { cropImageRegion } from '../crop/slide-crop';
+import { Region, Polygon, Rectangle } from '../../models/region';
+import * as i0 from "@angular/core";
+import * as i1 from "../wand/wand.service";
+/** Yield to the event loop (a macrotask) so the toast can repaint the latest
+ *  status / animate the spinner before the next main-thread-blocking step. */
+const tick = () => new Promise((r) => setTimeout(r, 0));
+/**
+ * Automatic cell segmentation inside drawn boxes (jit-ui#90). For each rectangle
+ * it client slide-crops the box from the loaded image, runs an automatic
+ * segmenter (cellpose-SAM, supplied by the host via {@link ICellSegmenter}) on
+ * the crop, and turns every cell instance into a region — offset back onto the
+ * frame. The prompt rectangle is replaced by its cell regions.
+ *
+ * This is the complement to the promptable SAM tool: cellpose-SAM can't take a
+ * box prompt, so the box just bounds the crop it segments automatically.
+ */
+export class CellSegmentToolService {
+    constructor(wandService) {
+        this.wandService = wandService;
+        this.status$ = new BehaviorSubject('');
+        this.busy$ = new BehaviorSubject(false);
+        this.progress$ = new BehaviorSubject(-1);
+    }
+    bindHost(host) { this.host = host; }
+    /**
+     * Crop + cellpose-segment every rectangle; append the cell regions and drop
+     * the prompt rectangles that produced cells. Returns the number of regions added.
+     */
+    async segmentBoxes(segmenter) {
+        if (!this.host)
+            return 0;
+        const cached = this.host.getCachedImageData();
+        if (!cached || cached.frames.length === 0) {
+            this.status$.next('No image loaded.');
+            return 0;
+        }
+        const regions = this.host.getRegions();
+        const rects = regions.filter((r) => r.bounds instanceof Rectangle);
+        if (rects.length === 0) {
+            this.status$.next('Draw one or more rectangles, then run Cellpose.');
+            return 0;
+        }
+        const rx = cached.ratios[0] || 1;
+        const ry = cached.ratios[0] || 1;
+        const ox = cached.originX ?? 0;
+        const oy = cached.originY ?? 0;
+        const frameIdx = this.host.getActiveFrameIndex();
+        this.busy$.next(true);
+        try {
+            const masks = [];
+            const consumed = new Set();
+            let added = 0;
+            for (let i = 0; i < rects.length; i++) {
+                const b = rects[i].bounds;
+                // Prefix each phase with the box index when there's more than one.
+                const prefix = rects.length > 1 ? `Box ${i + 1}/${rects.length}: ` : '';
+                this.status$.next(`${prefix}Cropping…`);
+                await tick(); // let the status paint before the (main-thread) crop
+                const crop = cropImageRegion(cached, frameIdx, { x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height });
+                if (!crop)
+                    continue;
+                const seg = await segmenter.segmentCells({ data: crop.data, width: crop.width, height: crop.height }, { onProgress: (f) => this.progress$.next(f), onStatus: (s) => this.status$.next(prefix + s) });
+                this.status$.next(`${prefix}Tracing cells…`);
+                await tick(); // paint before the (main-thread) contour tracing
+                const polys = this.wandService.labelsToPolygons(seg.labels, seg.width, seg.height, seg.width, seg.height, 0, 0);
+                if (polys.length === 0)
+                    continue;
+                for (const poly of polys) {
+                    // crop-pixel → frame-matrix (offset by crop origin) → data coords.
+                    const xData = poly.xpoints.map((x) => ox + (crop.matrixX0 + x) * rx);
+                    const yData = poly.ypoints.map((y) => oy + (crop.matrixY0 + y) * ry);
+                    masks.push(this.makeRegion(xData, yData, rects[i].color)); // inherit the box's color
+                    added++;
+                }
+                consumed.add(rects[i]);
+            }
+            this.host.setRegions(regions.filter((r) => !consumed.has(r)).concat(masks));
+            this.status$.next(added > 0 ? `Added ${added} cell region(s).` : 'No cells found.');
+            return added;
+        }
+        catch (err) {
+            this.status$.next(err instanceof Error ? err.message : 'Cellpose segmentation failed.');
+            return 0;
+        }
+        finally {
+            this.busy$.next(false);
+            this.progress$.next(-1);
+        }
+    }
+    makeRegion(xData, yData, color) {
+        const poly = new Polygon();
+        poly.npoints = xData.length;
+        poly.xpoints = xData;
+        poly.ypoints = yData;
+        poly.coordinates = xData.map((x, i) => [x, yData[i]]);
+        poly.closed = true;
+        const region = new Region();
+        region.bounds = poly;
+        // Inherit the source box's color; fall back to the host default.
+        region.color = color || this.host.getShapeColor();
+        region.label = 'cell';
+        return region;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellSegmentToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellSegmentToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellSegmentToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.WandService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell-segment-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/cell-segment-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { WandService } from '../wand/wand.service';\nimport { WandToolHost } from '../wand/wand-tool.service';\nimport { cropImageRegion } from '../crop/slide-crop';\nimport { ICellSegmenter } from '../../contracts/cell-segmenter.contract';\nimport { Region, Polygon, Rectangle } from '../../models/region';\n\n/** Yield to the event loop (a macrotask) so the toast can repaint the latest\n *  status / animate the spinner before the next main-thread-blocking step. */\nconst tick = (): Promise<void> => new Promise((r) => setTimeout(r, 0));\n\n/**\n * Automatic cell segmentation inside drawn boxes (jit-ui#90). For each rectangle\n * it client slide-crops the box from the loaded image, runs an automatic\n * segmenter (cellpose-SAM, supplied by the host via {@link ICellSegmenter}) on\n * the crop, and turns every cell instance into a region — offset back onto the\n * frame. The prompt rectangle is replaced by its cell regions.\n *\n * This is the complement to the promptable SAM tool: cellpose-SAM can't take a\n * box prompt, so the box just bounds the crop it segments automatically.\n */\n@Injectable({ providedIn: 'root' })\nexport class CellSegmentToolService {\n  private host!: WandToolHost;\n\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(private wandService: WandService) {}\n\n  bindHost(host: WandToolHost): void { this.host = host; }\n\n  /**\n   * Crop + cellpose-segment every rectangle; append the cell regions and drop\n   * the prompt rectangles that produced cells. Returns the number of regions added.\n   */\n  async segmentBoxes(segmenter: ICellSegmenter): Promise<number> {\n    if (!this.host) return 0;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) { this.status$.next('No image loaded.'); return 0; }\n\n    const regions = this.host.getRegions();\n    const rects = regions.filter((r) => r.bounds instanceof Rectangle);\n    if (rects.length === 0) {\n      this.status$.next('Draw one or more rectangles, then run Cellpose.');\n      return 0;\n    }\n\n    const rx = cached.ratios[0] || 1;\n    const ry = cached.ratios[0] || 1;\n    const ox = cached.originX ?? 0;\n    const oy = cached.originY ?? 0;\n    const frameIdx = this.host.getActiveFrameIndex();\n\n    this.busy$.next(true);\n    try {\n      const masks: Region[] = [];\n      const consumed = new Set<Region>();\n      let added = 0;\n      for (let i = 0; i < rects.length; i++) {\n        const b = rects[i].bounds as Rectangle;\n        // Prefix each phase with the box index when there's more than one.\n        const prefix = rects.length > 1 ? `Box ${i + 1}/${rects.length}: ` : '';\n        this.status$.next(`${prefix}Cropping…`);\n        await tick(); // let the status paint before the (main-thread) crop\n        const crop = cropImageRegion(\n          cached, frameIdx, { x0: b.x, y0: b.y, x1: b.x + b.width, y1: b.y + b.height },\n        );\n        if (!crop) continue;\n        const seg = await segmenter.segmentCells(\n          { data: crop.data, width: crop.width, height: crop.height },\n          { onProgress: (f) => this.progress$.next(f), onStatus: (s) => this.status$.next(prefix + s) },\n        );\n        this.status$.next(`${prefix}Tracing cells…`);\n        await tick(); // paint before the (main-thread) contour tracing\n        const polys = this.wandService.labelsToPolygons(\n          seg.labels, seg.width, seg.height, seg.width, seg.height, 0, 0,\n        );\n        if (polys.length === 0) continue;\n        for (const poly of polys) {\n          // crop-pixel → frame-matrix (offset by crop origin) → data coords.\n          const xData = poly.xpoints.map((x) => ox + (crop.matrixX0 + x) * rx);\n          const yData = poly.ypoints.map((y) => oy + (crop.matrixY0 + y) * ry);\n          masks.push(this.makeRegion(xData, yData, rects[i].color)); // inherit the box's color\n          added++;\n        }\n        consumed.add(rects[i]);\n      }\n      this.host.setRegions(regions.filter((r) => !consumed.has(r)).concat(masks));\n      this.status$.next(added > 0 ? `Added ${added} cell region(s).` : 'No cells found.');\n      return added;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'Cellpose segmentation failed.');\n      return 0;\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  private makeRegion(xData: number[], yData: number[], color?: string): Region {\n    const poly = new Polygon();\n    poly.npoints = xData.length;\n    poly.xpoints = xData;\n    poly.ypoints = yData;\n    poly.coordinates = xData.map((x, i) => [x, yData[i]]);\n    poly.closed = true;\n    const region = new Region();\n    region.bounds = poly;\n    // Inherit the source box's color; fall back to the host default.\n    region.color = color || this.host.getShapeColor();\n    region.label = 'cell';\n    return region;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/cellpose-segmenter.service.mjs

@@ -0,0 +1,84 @@
+import { Injectable } from '@angular/core';
+import { getOrtWasmBase } from './ort-runtime-config';
+import * as i0 from "@angular/core";
+/** Hosted cellpose-SAM ONNX (CPSAM, fp16). Override via {@link setModelUrl}. */
+const DEFAULT_MODEL_URL = 'https://huggingface.co/ballon999/cellpose-sam-onnx/resolve/main/cpsam_fp16.onnx';
+/**
+ * Default in-library {@link ICellSegmenter} backed by cellpose-js (WebGPU/WASM
+ * ONNX) — so the toolbar's automatic **Cellpose** tool works out of the box in
+ * any app, with no host wiring (jit-ui#90). `cellpose-js` is a peer dependency
+ * and is **lazy-imported** on first use, so apps that never run Cellpose pay
+ * nothing for it. A host can still override the {@link CELL_SEGMENTER} token to
+ * supply a different implementation.
+ *
+ * Owns a single shared {@link Cellpose} instance (one model load, one WebGPU
+ * session, one worker). {@link getModel} exposes that instance so a host's
+ * processing pipeline can reuse it instead of loading the ~588 MB model twice.
+ */
+export class CellposeSegmenterService {
+    constructor() {
+        this.instance = null;
+        this.loading = null;
+        this.modelUrl = DEFAULT_MODEL_URL;
+    }
+    /** Point the segmenter at a different hosted CPSAM ONNX (before first use). */
+    setModelUrl(url) {
+        this.modelUrl = url;
+    }
+    async segmentCells(image, progress) {
+        let announcedDownload = false;
+        const cp = await this.getModel((loaded, total) => {
+            if (total)
+                progress?.onProgress?.(loaded / total);
+            if (loaded > 0 && !announcedDownload) {
+                announcedDownload = true;
+                progress?.onStatus?.('Downloading Cellpose-SAM model…');
+            }
+        }, (status) => progress?.onStatus?.(status));
+        progress?.onStatus?.('Preprocessing image…');
+        const out = await cp.segment({ data: image.data, width: image.width, height: image.height, channels: 4 }, {
+            // cellpose-js runs inference in its worker (these fire between tiles) and
+            // averaging/dynamics on the main thread; surface both so the toast shows
+            // real progress instead of looking stuck.
+            onTileProgress: (done, total) => progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Computing flow dynamics…'),
+        });
+        return { labels: out.masks, width: out.width, height: out.height, count: out.count };
+    }
+    /**
+     * The shared Cellpose instance, lazily created on first use and reused
+     * thereafter (deduped across concurrent callers). Exposed so a host pipeline
+     * engine can run richer `segment()` options on the same instance. `onProgress`
+     * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`
+     * reports worker-init phase strings.
+     */
+    getModel(onProgress, onStatus) {
+        if (this.instance)
+            return Promise.resolve(this.instance);
+        if (!this.loading) {
+            this.loading = (async () => {
+                // Lazy: keep cellpose-js + its ORT runtime out of the initial bundle.
+                const { Cellpose, configureOrt } = await import('cellpose-js');
+                configureOrt({ wasmPaths: getOrtWasmBase() });
+                const cp = await Cellpose.fromPretrained(this.modelUrl, {
+                    preload: true,
+                    onProgress: ({ loaded, total }) => onProgress?.(loaded, total),
+                    onStatus: (s) => onStatus?.(s),
+                });
+                this.instance = cp;
+                return cp;
+            })();
+        }
+        return this.loading;
+    }
+    /** Whether the shared model is already loaded (warm). */
+    isLoaded() {
+        return this.instance !== null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellposeSegmenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellposeSegmenterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: CellposeSegmenterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cellpose-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/cellpose-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\n\nimport type { ICellSegmenter, CellSegmentation, CellSegmentProgress } from '../../contracts/cell-segmenter.contract';\nimport type { Cellpose } from 'cellpose-js';\n\n/** Hosted cellpose-SAM ONNX (CPSAM, fp16). Override via {@link setModelUrl}. */\nconst DEFAULT_MODEL_URL =\n  'https://huggingface.co/ballon999/cellpose-sam-onnx/resolve/main/cpsam_fp16.onnx';\n\n/**\n * Default in-library {@link ICellSegmenter} backed by cellpose-js (WebGPU/WASM\n * ONNX) — so the toolbar's automatic **Cellpose** tool works out of the box in\n * any app, with no host wiring (jit-ui#90). `cellpose-js` is a peer dependency\n * and is **lazy-imported** on first use, so apps that never run Cellpose pay\n * nothing for it. A host can still override the {@link CELL_SEGMENTER} token to\n * supply a different implementation.\n *\n * Owns a single shared {@link Cellpose} instance (one model load, one WebGPU\n * session, one worker). {@link getModel} exposes that instance so a host's\n * processing pipeline can reuse it instead of loading the ~588 MB model twice.\n */\n@Injectable({ providedIn: 'root' })\nexport class CellposeSegmenterService implements ICellSegmenter {\n  private instance: Cellpose | null = null;\n  private loading: Promise<Cellpose> | null = null;\n  private modelUrl = DEFAULT_MODEL_URL;\n\n  /** Point the segmenter at a different hosted CPSAM ONNX (before first use). */\n  setModelUrl(url: string): void {\n    this.modelUrl = url;\n  }\n\n  async segmentCells(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    progress?: CellSegmentProgress,\n  ): Promise<CellSegmentation> {\n    let announcedDownload = false;\n    const cp = await this.getModel(\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.('Downloading Cellpose-SAM model…');\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n    progress?.onStatus?.('Preprocessing image…');\n    const out = await cp.segment(\n      { data: image.data, width: image.width, height: image.height, channels: 4 },\n      {\n        // cellpose-js runs inference in its worker (these fire between tiles) and\n        // averaging/dynamics on the main thread; surface both so the toast shows\n        // real progress instead of looking stuck.\n        onTileProgress: (done, total) => progress?.onStatus?.(\n          done < total ? `Running inference (tile ${done}/${total})…` : 'Computing flow dynamics…',\n        ),\n      },\n    );\n    return { labels: out.masks, width: out.width, height: out.height, count: out.count };\n  }\n\n  /**\n   * The shared Cellpose instance, lazily created on first use and reused\n   * thereafter (deduped across concurrent callers). Exposed so a host pipeline\n   * engine can run richer `segment()` options on the same instance. `onProgress`\n   * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`\n   * reports worker-init phase strings.\n   */\n  getModel(\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<Cellpose> {\n    if (this.instance) return Promise.resolve(this.instance);\n    if (!this.loading) {\n      this.loading = (async () => {\n        // Lazy: keep cellpose-js + its ORT runtime out of the initial bundle.\n        const { Cellpose, configureOrt } = await import('cellpose-js');\n        configureOrt({ wasmPaths: getOrtWasmBase() });\n        const cp = await Cellpose.fromPretrained(this.modelUrl, {\n          preload: true,\n          onProgress: ({ loaded, total }) => onProgress?.(loaded, total),\n          onStatus: (s) => onStatus?.(s),\n        });\n        this.instance = cp;\n        return cp;\n      })();\n    }\n    return this.loading;\n  }\n\n  /** Whether the shared model is already loaded (warm). */\n  isLoaded(): boolean {\n    return this.instance !== null;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/onnx-sam-session.mjs

@@ -0,0 +1,133 @@
+import * as ort from 'onnxruntime-web';
+import { fetchModel, runEncoder, runDecoder } from './sam-onnx-core';
+import { getOrtWasmBase } from './ort-runtime-config';
+export class OnnxSamSession {
+    constructor() {
+        this.mode = null;
+        this.loaded = false;
+        this.model = null;
+        this.inputSize = 1024;
+        // ── worker mode ──
+        this.worker = null;
+        this.seq = 0;
+        this.pending = new Map();
+        // ── in-process mode ──
+        this.encoder = null;
+        this.decoder = null;
+        this.nextToken = 1;
+        this.embeddings = new Map();
+    }
+    async loadModel(model, onProgress) {
+        if (!model.encoderUrl || !model.decoderUrl) {
+            throw new Error(`SAM model "${model.id}" has no ONNX URLs configured.`);
+        }
+        this.model = model;
+        this.inputSize = model.inputSize;
+        const hasGpu = typeof navigator !== 'undefined' && 'gpu' in navigator;
+        const eps = model.encoderProviders ?? (hasGpu ? ['webgpu', 'wasm'] : ['wasm']);
+        const usesWebGpu = eps.includes('webgpu');
+        // WebGPU must run in the worker (else it freezes the main thread); small
+        // WASM models opt into the faster in-process path via `inProcess`.
+        this.mode = !usesWebGpu && model.inProcess ? 'inproc' : 'worker';
+        if (this.mode === 'inproc') {
+            ort.env.wasm.wasmPaths = getOrtWasmBase();
+            const encBuf = await fetchModel(model.encoderUrl, onProgress);
+            const decBuf = await fetchModel(model.decoderUrl);
+            this.encoder = await ort.InferenceSession.create(encBuf, { executionProviders: eps });
+            this.decoder = await ort.InferenceSession.create(decBuf, { executionProviders: ['wasm'] });
+        }
+        else {
+            await this.call({
+                type: 'load',
+                encoderUrl: model.encoderUrl,
+                decoderUrl: model.decoderUrl,
+                wasmPaths: getOrtWasmBase(),
+                inputSize: model.inputSize,
+                encoderProviders: model.encoderProviders,
+            }, [], onProgress);
+        }
+        this.loaded = true;
+    }
+    isLoaded() {
+        return this.loaded;
+    }
+    async embed(image) {
+        if (this.mode === 'inproc') {
+            const e = await runEncoder(this.encoder, image.data, image.width, image.height, this.inputSize);
+            const token = this.nextToken++;
+            this.embeddings.set(token, e);
+            if (this.embeddings.size > 3)
+                this.embeddings.delete(this.embeddings.keys().next().value);
+            return {
+                data: new Float32Array(0), dims: e.dims, scale: e.scale,
+                imageWidth: e.imageWidth, imageHeight: e.imageHeight, token,
+            };
+        }
+        // worker: transfer the RGBA buffer (callers pass a fresh frame buffer).
+        const buffer = image.data.buffer;
+        const res = await this.call({ type: 'embed', width: image.width, height: image.height, buffer }, [buffer]);
+        return {
+            data: new Float32Array(0), dims: res.dims, scale: res.scale,
+            imageWidth: res.imageWidth, imageHeight: res.imageHeight, token: res.token,
+        };
+    }
+    async decode(embedding, prompt) {
+        if (this.mode === 'inproc') {
+            const e = this.embeddings.get(embedding.token);
+            if (!e)
+                throw new Error('SAM embedding expired; re-encode the image.');
+            return runDecoder(this.decoder, e, prompt);
+        }
+        const res = await this.call({ type: 'decode', token: embedding.token, prompt });
+        return { mask: new Uint8Array(res.buffer), width: res.width, height: res.height, iou: res.iou };
+    }
+    dispose() {
+        this.worker?.terminate();
+        this.worker = null;
+        this.pending.clear();
+        this.encoder?.release?.();
+        this.decoder?.release?.();
+        this.encoder = this.decoder = null;
+        this.embeddings.clear();
+        this.loaded = false;
+        this.mode = null;
+    }
+    // ── worker plumbing ──────────────────────────────────────────────────────
+    ensureWorker() {
+        if (this.worker)
+            return this.worker;
+        const worker = new Worker(new URL('./onnx-sam.worker', import.meta.url), { type: 'module' });
+        worker.onmessage = (ev) => {
+            const m = ev.data;
+            const p = this.pending.get(m.id);
+            if (!p)
+                return;
+            if (m.type === 'progress') {
+                p.onProgress?.(m.fraction);
+                return;
+            }
+            this.pending.delete(m.id);
+            if (m.type === 'error')
+                p.reject(new Error(m.error));
+            else
+                p.resolve(m);
+        };
+        worker.onerror = (ev) => {
+            const err = new Error(ev.message || 'SAM worker crashed.');
+            for (const p of this.pending.values())
+                p.reject(err);
+            this.pending.clear();
+        };
+        this.worker = worker;
+        return worker;
+    }
+    call(msg, transfer = [], onProgress) {
+        const id = ++this.seq;
+        const worker = this.ensureWorker();
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject, onProgress });
+            worker.postMessage({ ...msg, id }, transfer);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"onnx-sam-session.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/onnx-sam-session.ts"],"names":[],"mappings":"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","sourcesContent":["import * as ort from 'onnxruntime-web';\n\nimport {\n  ISamSession, SamEmbedding, SamMaskResult, SamModelDef, SamPrompt,\n} from '../../contracts/sam.contract';\nimport { fetchModel, runEncoder, runDecoder, type CoreEmbedding } from './sam-onnx-core';\nimport { getOrtWasmBase } from './ort-runtime-config';\n\n/**\n * onnxruntime-web implementation of {@link ISamSession} (jit-ui#90), with two\n * execution modes chosen per model:\n *\n *  - **in-process** (main thread) — for small WASM models flagged `inProcess`\n *    (e.g. micro-sam ViT-T). Fast load + inference with no Web Worker spawn /\n *    second ORT runtime / message round-trips; the brief encode runs on the main\n *    thread (fine for a tiny model).\n *  - **worker** — for WebGPU models (e.g. ViT-B, patho-sam fp16) whose heavy\n *    encode would otherwise freeze the tab. Runs in {@link ./onnx-sam.worker} so\n *    the UI stays responsive (the spinner animates).\n *\n * Both modes share their inference math via {@link ./sam-onnx-core}. Lazy-imported\n * by the SAM tools so onnxruntime-web / the worker never load in unit tests or\n * the initial bundle.\n */\ntype Pending = {\n  resolve: (msg: any) => void;\n  reject: (err: Error) => void;\n  onProgress?: (fraction: number) => void;\n};\n\nexport class OnnxSamSession implements ISamSession {\n  private mode: 'inproc' | 'worker' | null = null;\n  private loaded = false;\n  private model: SamModelDef | null = null;\n  private inputSize = 1024;\n\n  // ── worker mode ──\n  private worker: Worker | null = null;\n  private seq = 0;\n  private readonly pending = new Map<number, Pending>();\n\n  // ── in-process mode ──\n  private encoder: ort.InferenceSession | null = null;\n  private decoder: ort.InferenceSession | null = null;\n  private nextToken = 1;\n  private readonly embeddings = new Map<number, CoreEmbedding>();\n\n  async loadModel(model: SamModelDef, onProgress?: (fraction: number) => void): Promise<void> {\n    if (!model.encoderUrl || !model.decoderUrl) {\n      throw new Error(`SAM model \"${model.id}\" has no ONNX URLs configured.`);\n    }\n    this.model = model;\n    this.inputSize = model.inputSize;\n    const hasGpu = typeof navigator !== 'undefined' && 'gpu' in navigator;\n    const eps: string[] = model.encoderProviders ?? (hasGpu ? ['webgpu', 'wasm'] : ['wasm']);\n    const usesWebGpu = eps.includes('webgpu');\n    // WebGPU must run in the worker (else it freezes the main thread); small\n    // WASM models opt into the faster in-process path via `inProcess`.\n    this.mode = !usesWebGpu && model.inProcess ? 'inproc' : 'worker';\n\n    if (this.mode === 'inproc') {\n      ort.env.wasm.wasmPaths = getOrtWasmBase();\n      const encBuf = await fetchModel(model.encoderUrl, onProgress);\n      const decBuf = await fetchModel(model.decoderUrl);\n      this.encoder = await ort.InferenceSession.create(encBuf, { executionProviders: eps });\n      this.decoder = await ort.InferenceSession.create(decBuf, { executionProviders: ['wasm'] });\n    } else {\n      await this.call({\n        type: 'load',\n        encoderUrl: model.encoderUrl,\n        decoderUrl: model.decoderUrl,\n        wasmPaths: getOrtWasmBase(),\n        inputSize: model.inputSize,\n        encoderProviders: model.encoderProviders,\n      }, [], onProgress);\n    }\n    this.loaded = true;\n  }\n\n  isLoaded(): boolean {\n    return this.loaded;\n  }\n\n  async embed(image: { data: Uint8ClampedArray; width: number; height: number }): Promise<SamEmbedding> {\n    if (this.mode === 'inproc') {\n      const e = await runEncoder(this.encoder!, image.data, image.width, image.height, this.inputSize);\n      const token = this.nextToken++;\n      this.embeddings.set(token, e);\n      if (this.embeddings.size > 3) this.embeddings.delete(this.embeddings.keys().next().value as number);\n      return {\n        data: new Float32Array(0), dims: e.dims, scale: e.scale,\n        imageWidth: e.imageWidth, imageHeight: e.imageHeight, token,\n      };\n    }\n    // worker: transfer the RGBA buffer (callers pass a fresh frame buffer).\n    const buffer = image.data.buffer;\n    const res = await this.call({ type: 'embed', width: image.width, height: image.height, buffer }, [buffer]);\n    return {\n      data: new Float32Array(0), dims: res.dims, scale: res.scale,\n      imageWidth: res.imageWidth, imageHeight: res.imageHeight, token: res.token,\n    };\n  }\n\n  async decode(embedding: SamEmbedding, prompt: SamPrompt): Promise<SamMaskResult> {\n    if (this.mode === 'inproc') {\n      const e = this.embeddings.get(embedding.token as number);\n      if (!e) throw new Error('SAM embedding expired; re-encode the image.');\n      return runDecoder(this.decoder!, e, prompt);\n    }\n    const res = await this.call({ type: 'decode', token: embedding.token, prompt });\n    return { mask: new Uint8Array(res.buffer), width: res.width, height: res.height, iou: res.iou };\n  }\n\n  dispose(): void {\n    this.worker?.terminate();\n    this.worker = null;\n    this.pending.clear();\n    this.encoder?.release?.();\n    this.decoder?.release?.();\n    this.encoder = this.decoder = null;\n    this.embeddings.clear();\n    this.loaded = false;\n    this.mode = null;\n  }\n\n  // ── worker plumbing ──────────────────────────────────────────────────────\n  private ensureWorker(): Worker {\n    if (this.worker) return this.worker;\n    const worker = new Worker(new URL('./onnx-sam.worker', import.meta.url), { type: 'module' });\n    worker.onmessage = (ev: MessageEvent) => {\n      const m = ev.data;\n      const p = this.pending.get(m.id);\n      if (!p) return;\n      if (m.type === 'progress') { p.onProgress?.(m.fraction); return; }\n      this.pending.delete(m.id);\n      if (m.type === 'error') p.reject(new Error(m.error));\n      else p.resolve(m);\n    };\n    worker.onerror = (ev: ErrorEvent) => {\n      const err = new Error(ev.message || 'SAM worker crashed.');\n      for (const p of this.pending.values()) p.reject(err);\n      this.pending.clear();\n    };\n    this.worker = worker;\n    return worker;\n  }\n\n  private call(msg: any, transfer: Transferable[] = [], onProgress?: (f: number) => void): Promise<any> {\n    const id = ++this.seq;\n    const worker = this.ensureWorker();\n    return new Promise((resolve, reject) => {\n      this.pending.set(id, { resolve, reject, onProgress });\n      worker.postMessage({ ...msg, id }, transfer);\n    });\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/ort-runtime-config.mjs

@@ -0,0 +1,31 @@
+/**
+ * Shared base URL/path for onnxruntime-web's WASM sidecar files
+ * (`ort-wasm-simd-threaded.wasm` / `.jsep.mjs`), used by every ONNX-model tool
+ * in the library: SAM (in-process and worker) and Cellpose-SAM.
+ *
+ * Defaults to `'/assets/ort/'` — a host that serves onnxruntime-web's `dist`
+ * WASM files there (as jit-ui does via its `project.json` asset glob) needs no
+ * configuration and behaves exactly as before this knob existed. A host that
+ * cannot serve them at that path — e.g. a static deployment behind an auth
+ * proxy, or one that prefers a CDN — calls {@link setOrtWasmBase} ONCE at app
+ * init to point the runtime elsewhere:
+ *
+ * ```ts
+ * // version MUST match the onnxruntime-web the library was built against
+ * setOrtWasmBase('https://cdn.jsdelivr.net/npm/onnxruntime-web@1.26.0/dist/');
+ * ```
+ *
+ * Must be set before the first segmentation runs; the value is read at use time
+ * by each tool (and passed into the SAM worker via its load message), so a
+ * single call at bootstrap covers SAM and Cellpose alike.
+ */
+let ortWasmBase = '/assets/ort/';
+/** Override where onnxruntime-web loads its WASM sidecars from. See module docs. */
+export function setOrtWasmBase(base) {
+    ortWasmBase = base;
+}
+/** The configured onnxruntime-web WASM base (default `'/assets/ort/'`). */
+export function getOrtWasmBase() {
+    return ortWasmBase;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3J0LXJ1bnRpbWUtY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpYi90b29sYmFyL3NlZ21lbnRhdGlvbi9vcnQtcnVudGltZS1jb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBb0JHO0FBQ0gsSUFBSSxXQUFXLEdBQUcsY0FBYyxDQUFDO0FBRWpDLG9GQUFvRjtBQUNwRixNQUFNLFVBQVUsY0FBYyxDQUFDLElBQVk7SUFDekMsV0FBVyxHQUFHLElBQUksQ0FBQztBQUNyQixDQUFDO0FBRUQsMkVBQTJFO0FBQzNFLE1BQU0sVUFBVSxjQUFjO0lBQzVCLE9BQU8sV0FBVyxDQUFDO0FBQ3JCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFNoYXJlZCBiYXNlIFVSTC9wYXRoIGZvciBvbm54cnVudGltZS13ZWIncyBXQVNNIHNpZGVjYXIgZmlsZXNcbiAqIChgb3J0LXdhc20tc2ltZC10aHJlYWRlZC53YXNtYCAvIGAuanNlcC5tanNgKSwgdXNlZCBieSBldmVyeSBPTk5YLW1vZGVsIHRvb2xcbiAqIGluIHRoZSBsaWJyYXJ5OiBTQU0gKGluLXByb2Nlc3MgYW5kIHdvcmtlcikgYW5kIENlbGxwb3NlLVNBTS5cbiAqXG4gKiBEZWZhdWx0cyB0byBgJy9hc3NldHMvb3J0LydgIOKAlCBhIGhvc3QgdGhhdCBzZXJ2ZXMgb25ueHJ1bnRpbWUtd2ViJ3MgYGRpc3RgXG4gKiBXQVNNIGZpbGVzIHRoZXJlIChhcyBqaXQtdWkgZG9lcyB2aWEgaXRzIGBwcm9qZWN0Lmpzb25gIGFzc2V0IGdsb2IpIG5lZWRzIG5vXG4gKiBjb25maWd1cmF0aW9uIGFuZCBiZWhhdmVzIGV4YWN0bHkgYXMgYmVmb3JlIHRoaXMga25vYiBleGlzdGVkLiBBIGhvc3QgdGhhdFxuICogY2Fubm90IHNlcnZlIHRoZW0gYXQgdGhhdCBwYXRoIOKAlCBlLmcuIGEgc3RhdGljIGRlcGxveW1lbnQgYmVoaW5kIGFuIGF1dGhcbiAqIHByb3h5LCBvciBvbmUgdGhhdCBwcmVmZXJzIGEgQ0ROIOKAlCBjYWxscyB7QGxpbmsgc2V0T3J0V2FzbUJhc2V9IE9OQ0UgYXQgYXBwXG4gKiBpbml0IHRvIHBvaW50IHRoZSBydW50aW1lIGVsc2V3aGVyZTpcbiAqXG4gKiBgYGB0c1xuICogLy8gdmVyc2lvbiBNVVNUIG1hdGNoIHRoZSBvbm54cnVudGltZS13ZWIgdGhlIGxpYnJhcnkgd2FzIGJ1aWx0IGFnYWluc3RcbiAqIHNldE9ydFdhc21CYXNlKCdodHRwczovL2Nkbi5qc2RlbGl2ci5uZXQvbnBtL29ubnhydW50aW1lLXdlYkAxLjI2LjAvZGlzdC8nKTtcbiAqIGBgYFxuICpcbiAqIE11c3QgYmUgc2V0IGJlZm9yZSB0aGUgZmlyc3Qgc2VnbWVudGF0aW9uIHJ1bnM7IHRoZSB2YWx1ZSBpcyByZWFkIGF0IHVzZSB0aW1lXG4gKiBieSBlYWNoIHRvb2wgKGFuZCBwYXNzZWQgaW50byB0aGUgU0FNIHdvcmtlciB2aWEgaXRzIGxvYWQgbWVzc2FnZSksIHNvIGFcbiAqIHNpbmdsZSBjYWxsIGF0IGJvb3RzdHJhcCBjb3ZlcnMgU0FNIGFuZCBDZWxscG9zZSBhbGlrZS5cbiAqL1xubGV0IG9ydFdhc21CYXNlID0gJy9hc3NldHMvb3J0Lyc7XG5cbi8qKiBPdmVycmlkZSB3aGVyZSBvbm54cnVudGltZS13ZWIgbG9hZHMgaXRzIFdBU00gc2lkZWNhcnMgZnJvbS4gU2VlIG1vZHVsZSBkb2NzLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHNldE9ydFdhc21CYXNlKGJhc2U6IHN0cmluZyk6IHZvaWQge1xuICBvcnRXYXNtQmFzZSA9IGJhc2U7XG59XG5cbi8qKiBUaGUgY29uZmlndXJlZCBvbm54cnVudGltZS13ZWIgV0FTTSBiYXNlIChkZWZhdWx0IGAnL2Fzc2V0cy9vcnQvJ2ApLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldE9ydFdhc21CYXNlKCk6IHN0cmluZyB7XG4gIHJldHVybiBvcnRXYXNtQmFzZTtcbn1cbiJdfQ==