@jax-data-science/sci-image-visualizer 0.8.3 → 0.9.0

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

@@ -0,0 +1,183 @@
+import { Injectable } from '@angular/core';
+import { frameToRgba } from './sam-prompt';
+import { getSamModel, isSamModelReady } from './sam-model-registry';
+import * as i0 from "@angular/core";
+/** Lazy-import so onnxruntime-web is never pulled into unit tests or the
+ *  initial bundle — only when segmentation actually runs. */
+const onnxSessionFactory = async () => {
+    const { OnnxSamSession } = await import('./onnx-sam-session');
+    return new OnnxSamSession();
+};
+/** Thrown inside a load that a model switch superseded. */
+class SupersededLoad extends Error {
+}
+/**
+ * The one SAM inference session for the active model, shared by the box- and
+ * point-prompt tools (RT-10): one download, one Worker/GPU session and one
+ * cached image embedding instead of one per tool.
+ *
+ * - Concurrent {@link ensureSession} calls share a single load, and each caller
+ *   receives its download progress.
+ * - A load that fails disposes its half-built session (and Worker) and is not
+ *   cached; the next call retries (RT-7).
+ * - {@link setModel} during a load discards that load's session, and the
+ *   waiting callers get the newly picked model instead (RT-9).
+ *
+ * Scope: root, on purpose, and deliberately NOT in `provideVisualization()`. The
+ * chain-scoped SAM tools of a second viewer (jit-ui's pipeline preview) resolve
+ * this root instance, so the model (14–172 MB) is downloaded and its Worker/GPU
+ * session built once per app, not once per viewer, and the embedding cache is
+ * keyed by image + model so viewers don't confuse each other's images. The cost
+ * is that a model picked in one viewer is the model of all of them. A host that
+ * wants a session per viewer can provide this service at the viewer's component:
+ * {@link ngOnDestroy} then disposes that viewer's session (and Worker) with it.
+ */
+export class SamSessionService {
+    constructor() {
+        this.model = getSamModel();
+        this.session = null;
+        this.loading = null;
+        /** Bumped on every model switch; a load started under an older value is stale. */
+        this.generation = 0;
+        this.progressListeners = new Set();
+        this.createSession = onnxSessionFactory;
+        /** Set by {@link ngOnDestroy}: no session is loaded any more. */
+        this.destroyed = false;
+        /** Cached encoder embedding + the key (image identity + model) it was computed for. */
+        this.embedding = null;
+        this.embeddingKey = null;
+    }
+    /** The model the next run uses. */
+    getModel() {
+        return this.model;
+    }
+    /** True when a session is loaded (or injected) for the current model. */
+    hasSession() {
+        return this.session !== null;
+    }
+    /** Choose the registered model; drops the loaded session and cached embedding. */
+    setModel(id) {
+        const next = getSamModel(id);
+        if (next.id === this.model.id)
+            return;
+        this.model = next;
+        this.generation++;
+        this.loading = null;
+        this.invalidateEmbedding();
+        this.session?.dispose();
+        this.session = null;
+    }
+    /** Drop the cached embedding (e.g. after the image/slice changes). */
+    invalidateEmbedding() {
+        this.embedding = null;
+        this.embeddingKey = null;
+    }
+    /** Test seam: use this session (already loaded) for the current model. */
+    useSession(session) {
+        this.session = session;
+    }
+    /** Test seam: how sessions are created (default: lazy onnxruntime-web). */
+    useSessionFactory(factory) {
+        this.createSession = factory;
+    }
+    /**
+     * The loaded session for the current model, loading it if needed.
+     * `onProgress` receives the download fraction while this call waits.
+     */
+    async ensureSession(onProgress) {
+        if (this.destroyed)
+            throw new Error('The SAM session was disposed with its viewer.');
+        if (this.session)
+            return this.session;
+        if (!isSamModelReady(this.model)) {
+            throw new Error(`SAM model "${this.model.id}" is not configured yet (no ONNX URLs). ` +
+                'Host it and call setSamModelUrls(), then retry.');
+        }
+        if (onProgress) {
+            this.progressListeners.add(onProgress);
+            onProgress(0);
+        }
+        try {
+            return await (this.loading ??= this.load());
+        }
+        catch (err) {
+            if (err instanceof SupersededLoad)
+                return this.ensureSession(onProgress);
+            throw err;
+        }
+        finally {
+            if (onProgress)
+                this.progressListeners.delete(onProgress);
+        }
+    }
+    /**
+     * The encoder embedding of a cached frame, reused while `key` (the image's
+     * identity: file, frame, readback frame) and the model are unchanged.
+     * `onEncode` is called only when the encoder actually runs.
+     */
+    async embed(session, cached, frameIndex, key, onEncode) {
+        const fullKey = `${key}|${this.model.id}`;
+        if (this.embedding && this.embeddingKey === fullKey)
+            return this.embedding;
+        onEncode?.();
+        const generation = this.generation;
+        const embedding = await session.embed({
+            data: frameToRgba(cached, frameIndex),
+            width: cached.width,
+            height: cached.height,
+        });
+        if (generation === this.generation) {
+            this.embedding = embedding;
+            this.embeddingKey = fullKey;
+        }
+        return embedding;
+    }
+    /**
+     * Dispose the session (and its Worker), drop the embedding and discard an
+     * in-flight load. Angular calls this when the injector providing the service
+     * is destroyed: the app for the root instance, or a viewer component that
+     * provides its own.
+     */
+    ngOnDestroy() {
+        this.destroyed = true;
+        this.generation++; // an in-flight load disposes its session when it lands
+        this.loading = null;
+        this.invalidateEmbedding();
+        this.session?.dispose();
+        this.session = null;
+    }
+    load() {
+        const generation = this.generation;
+        const model = this.model;
+        const load = (async () => {
+            const session = await this.createSession();
+            try {
+                await session.loadModel(model, (f) => this.progressListeners.forEach((l) => l(f)));
+            }
+            catch (err) {
+                session.dispose(); // don't leak the half-built session / Worker
+                throw err;
+            }
+            if (generation !== this.generation) {
+                session.dispose(); // the user picked another model meanwhile
+                throw new SupersededLoad();
+            }
+            this.session = session;
+            return session;
+        })();
+        load
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.loading === load)
+                this.loading = null;
+        });
+        return load;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamSessionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamSessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamSessionService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-session.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-session.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\n\nimport type { CachedImageData } from '../wand/wand-tool.service';\nimport { frameToRgba } from './sam-prompt';\nimport { getSamModel, isSamModelReady } from './sam-model-registry';\nimport { ISamSession, SamEmbedding, SamModelDef } from '../../contracts/sam.contract';\n\n/** Creates an unloaded inference session. */\nexport type SamSessionFactory = () => Promise<ISamSession>;\n\n/** Lazy-import so onnxruntime-web is never pulled into unit tests or the\n *  initial bundle — only when segmentation actually runs. */\nconst onnxSessionFactory: SamSessionFactory = async () => {\n  const { OnnxSamSession } = await import('./onnx-sam-session');\n  return new OnnxSamSession();\n};\n\n/** Thrown inside a load that a model switch superseded. */\nclass SupersededLoad extends Error {}\n\n/**\n * The one SAM inference session for the active model, shared by the box- and\n * point-prompt tools (RT-10): one download, one Worker/GPU session and one\n * cached image embedding instead of one per tool.\n *\n * - Concurrent {@link ensureSession} calls share a single load, and each caller\n *   receives its download progress.\n * - A load that fails disposes its half-built session (and Worker) and is not\n *   cached; the next call retries (RT-7).\n * - {@link setModel} during a load discards that load's session, and the\n *   waiting callers get the newly picked model instead (RT-9).\n *\n * Scope: root, on purpose, and deliberately NOT in `provideVisualization()`. The\n * chain-scoped SAM tools of a second viewer (jit-ui's pipeline preview) resolve\n * this root instance, so the model (14–172 MB) is downloaded and its Worker/GPU\n * session built once per app, not once per viewer, and the embedding cache is\n * keyed by image + model so viewers don't confuse each other's images. The cost\n * is that a model picked in one viewer is the model of all of them. A host that\n * wants a session per viewer can provide this service at the viewer's component:\n * {@link ngOnDestroy} then disposes that viewer's session (and Worker) with it.\n */\n@Injectable({ providedIn: 'root' })\nexport class SamSessionService implements OnDestroy {\n  private model: SamModelDef = getSamModel();\n  private session: ISamSession | null = null;\n  private loading: Promise<ISamSession> | null = null;\n  /** Bumped on every model switch; a load started under an older value is stale. */\n  private generation = 0;\n  private readonly progressListeners = new Set<(fraction: number) => void>();\n  private createSession: SamSessionFactory = onnxSessionFactory;\n\n  /** Set by {@link ngOnDestroy}: no session is loaded any more. */\n  private destroyed = false;\n\n  /** Cached encoder embedding + the key (image identity + model) it was computed for. */\n  private embedding: SamEmbedding | null = null;\n  private embeddingKey: string | null = null;\n\n  /** The model the next run uses. */\n  getModel(): SamModelDef {\n    return this.model;\n  }\n\n  /** True when a session is loaded (or injected) for the current model. */\n  hasSession(): boolean {\n    return this.session !== null;\n  }\n\n  /** Choose the registered model; drops the loaded session and cached embedding. */\n  setModel(id: string): void {\n    const next = getSamModel(id);\n    if (next.id === this.model.id) return;\n    this.model = next;\n    this.generation++;\n    this.loading = null;\n    this.invalidateEmbedding();\n    this.session?.dispose();\n    this.session = null;\n  }\n\n  /** Drop the cached embedding (e.g. after the image/slice changes). */\n  invalidateEmbedding(): void {\n    this.embedding = null;\n    this.embeddingKey = null;\n  }\n\n  /** Test seam: use this session (already loaded) for the current model. */\n  useSession(session: ISamSession): void {\n    this.session = session;\n  }\n\n  /** Test seam: how sessions are created (default: lazy onnxruntime-web). */\n  useSessionFactory(factory: SamSessionFactory): void {\n    this.createSession = factory;\n  }\n\n  /**\n   * The loaded session for the current model, loading it if needed.\n   * `onProgress` receives the download fraction while this call waits.\n   */\n  async ensureSession(onProgress?: (fraction: number) => void): Promise<ISamSession> {\n    if (this.destroyed) throw new Error('The SAM session was disposed with its viewer.');\n    if (this.session) return this.session;\n    if (!isSamModelReady(this.model)) {\n      throw new Error(\n        `SAM model \"${this.model.id}\" is not configured yet (no ONNX URLs). ` +\n          'Host it and call setSamModelUrls(), then retry.',\n      );\n    }\n    if (onProgress) {\n      this.progressListeners.add(onProgress);\n      onProgress(0);\n    }\n    try {\n      return await (this.loading ??= this.load());\n    } catch (err) {\n      if (err instanceof SupersededLoad) return this.ensureSession(onProgress);\n      throw err;\n    } finally {\n      if (onProgress) this.progressListeners.delete(onProgress);\n    }\n  }\n\n  /**\n   * The encoder embedding of a cached frame, reused while `key` (the image's\n   * identity: file, frame, readback frame) and the model are unchanged.\n   * `onEncode` is called only when the encoder actually runs.\n   */\n  async embed(\n    session: ISamSession,\n    cached: CachedImageData,\n    frameIndex: number,\n    key: string,\n    onEncode?: () => void,\n  ): Promise<SamEmbedding> {\n    const fullKey = `${key}|${this.model.id}`;\n    if (this.embedding && this.embeddingKey === fullKey) return this.embedding;\n    onEncode?.();\n    const generation = this.generation;\n    const embedding = await session.embed({\n      data: frameToRgba(cached, frameIndex),\n      width: cached.width,\n      height: cached.height,\n    });\n    if (generation === this.generation) {\n      this.embedding = embedding;\n      this.embeddingKey = fullKey;\n    }\n    return embedding;\n  }\n\n  /**\n   * Dispose the session (and its Worker), drop the embedding and discard an\n   * in-flight load. Angular calls this when the injector providing the service\n   * is destroyed: the app for the root instance, or a viewer component that\n   * provides its own.\n   */\n  ngOnDestroy(): void {\n    this.destroyed = true;\n    this.generation++; // an in-flight load disposes its session when it lands\n    this.loading = null;\n    this.invalidateEmbedding();\n    this.session?.dispose();\n    this.session = null;\n  }\n\n  private load(): Promise<ISamSession> {\n    const generation = this.generation;\n    const model = this.model;\n    const load = (async () => {\n      const session = await this.createSession();\n      try {\n        await session.loadModel(model, (f) => this.progressListeners.forEach((l) => l(f)));\n      } catch (err) {\n        session.dispose(); // don't leak the half-built session / Worker\n        throw err;\n      }\n      if (generation !== this.generation) {\n        session.dispose(); // the user picked another model meanwhile\n        throw new SupersededLoad();\n      }\n      this.session = session;\n      return session;\n    })();\n    load\n      .catch(() => undefined)\n      .finally(() => {\n        if (this.loading === load) this.loading = null;\n      });\n    return load;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/sam-tool.service.mjs

@@ -1,188 +1,133 @@
 import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-import { WandService } from '../wand/wand.service';
-import { frameToRgba } from './sam-prompt';
-import { getSamModel, isSamModelReady } from './sam-model-registry';
-import { Region, Polygon, Rectangle } from '../../models/region';
+import { SamSessionService } from './sam-session.service';
+import { Region, Rectangle } from '../../models/region';
+import { makePolygon } from '../../models/polygon-factory';
+import { maskToPolygons } from '../../geometry/contour';
+import { MatrixFrame } from '../tool-kit/matrix-frame';
+import { AsyncToolStatus } from '../tool-kit/async-tool-status';
+import { withoutRegions } from './segmentation-commit';
 import * as i0 from "@angular/core";
-import * as i1 from "../wand/wand.service";
+import * as i1 from "./sam-session.service";
 /**
  * Box-prompted SAM segmentation tool (jit-ui#90, P0). On `segmentBoxes()` it
  * reads every rectangle region, runs the (cached) encoder once for the image,
- * then runs the decoder per box, traces each mask to a polygon (reusing
- * WandService.maskToPolygons) and commits them as regions.
+ * then runs the decoder per box, traces each mask to a polygon and replaces
+ * the prompt rectangles with the masks.
  *
- * Inference is abstracted behind {@link ISamSession}: production uses the
- * onnxruntime-web session (lazy-imported so ORT never loads in unit tests);
- * tests inject a fake via {@link useSession}.
+ * Inference goes through the shared {@link SamSessionService} (one session and
+ * embedding for both SAM tools); tests inject a fake session via
+ * {@link useSession}.
  */
 export class SamToolService {
-    constructor(wandService) {
-        this.wandService = wandService;
-        this.session = null;
-        this.model = getSamModel();
-        /** Cached encoder embedding + the key (image identity) it was computed for. */
-        this.embedding = null;
-        this.embeddingKey = null;
+    constructor(sessions = new SamSessionService()) {
+        this.sessions = sessions;
+        this.state = new AsyncToolStatus();
         /** Status text + busy flag for a spinner / toast in the host. */
-        this.status$ = new BehaviorSubject('');
-        this.busy$ = new BehaviorSubject(false);
+        this.status$ = this.state.status$;
+        this.busy$ = this.state.busy$;
         /** Encoder-download progress: -1 = not downloading, 0..1 = downloading. */
-        this.progress$ = new BehaviorSubject(-1);
+        this.progress$ = this.state.progress$;
     }
-    /** Bind to the active backend's host (called by the backend, like the wand). */
-    bindHost(host) {
-        this.host = host;
-    }
-    /** Choose the registered model to use; invalidates any cached embedding. */
+    /** Choose the registered model to use (shared with the point tool). */
     setModel(id) {
-        const next = getSamModel(id);
-        if (next.id === this.model.id)
-            return;
-        this.model = next;
-        this.invalidateEmbedding();
-        // Drop the loaded session so the next run reloads the newly-picked model's
-        // ONNX pair — ensureSession() returns the cached session as-is, so without
-        // this a model switch would keep running the previous model.
-        this.session?.dispose();
-        this.session = null;
+        this.sessions.setModel(id);
     }
     /** Drop the cached embedding (e.g. after the image/slice changes). */
     invalidateEmbedding() {
-        this.embedding = null;
-        this.embeddingKey = null;
+        this.sessions.invalidateEmbedding();
     }
     /** Test seam: inject a fake/alternate inference session. */
     useSession(session) {
-        this.session = session;
+        this.sessions.useSession(session);
     }
     /**
-     * Segment every rectangle region with a box prompt and append the resulting
-     * masks as new polygon regions. Returns how many regions were added.
+     * Segment every rectangle region of the backend behind `host` with a box
+     * prompt and replace each prompt that produced a mask with the mask's polygon
+     * region. Returns how many regions were added; 0 (ignored) while a previous
+     * run is still going. The host is passed per run, so no backend's host
+     * outlives its call.
      */
-    async segmentBoxes() {
-        if (!this.host)
-            return 0;
-        // Re-entrancy guard: a second Segment press while the first run is still
-        // downloading/encoding would launch a concurrent model download + GPU
-        // encode (and can freeze the tab on a heavy WebGPU ViT-B). Ignore it.
-        if (this.busy$.value)
+    async segmentBoxes(host) {
+        if (this.state.busy)
             return 0;
-        const cached = this.host.getCachedImageData();
+        const cached = 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);
+        const rects = host.getRegions().filter((r) => r.bounds instanceof Rectangle);
         if (rects.length === 0) {
             this.status$.next('Draw one or more rectangles, then press Segment.');
             return 0;
         }
-        const rx = cached.ratios[0] || 1;
-        const ry = cached.ratios[0] || 1;
-        const ox = cached.originX ?? 0;
-        const oy = cached.originY ?? 0;
-        let session;
-        try {
-            session = await this.ensureSession();
-        }
-        catch (err) {
-            this.busy$.next(false);
-            this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
-            return 0;
-        }
-        this.busy$.next(true);
-        try {
-            // Encode once per image; reuse the embedding across all boxes.
-            const key = [
-                this.host.getFileName() ?? '',
-                this.host.getActiveFrameIndex(),
-                `${cached.width}x${cached.height}`,
-                `${ox},${oy},${rx}`,
-                this.model.id,
-            ].join('|');
-            if (!this.embedding || this.embeddingKey !== key) {
-                this.status$.next('Encoding image…');
-                const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());
-                this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });
-                this.embeddingKey = key;
+        const frame = MatrixFrame.from(cached);
+        const frameIdx = host.getActiveFrameIndex();
+        // Busy from here on — including the model download, so a second press
+        // can't start a second download/encode (which can freeze the tab on a heavy
+        // WebGPU ViT-B).
+        const added = await this.state.run(async () => {
+            let session;
+            try {
+                session = await this.sessions.ensureSession((f) => this.progress$.next(f));
             }
-            const masks = [];
-            const consumed = new Set(); // prompt rectangles that produced a mask
-            let added = 0;
-            for (let i = 0; i < rects.length; i++) {
-                this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);
-                const b = rects[i].bounds;
-                // Rectangle is in data coords → convert to image (matrix) coords.
-                const box = {
-                    x0: (b.x - ox) / rx,
-                    y0: (b.y - oy) / ry,
-                    x1: (b.x + b.width - ox) / rx,
-                    y1: (b.y + b.height - oy) / ry,
-                };
-                const res = await session.decode(this.embedding, { box });
-                const polys = this.wandService.maskToPolygons(res.mask, res.width, res.height, cached.width, cached.height, 0, 0);
-                if (polys.length === 0)
-                    continue;
-                // Keep the largest connected piece (maskToPolygons returns largest-first).
-                const poly = polys[0];
-                masks.push(this.makeRegion(poly.xpoints.map((x) => ox + x * rx), poly.ypoints.map((y) => oy + y * ry), rects[i].color));
-                consumed.add(rects[i]); // this rectangle is now represented by its mask
-                added++;
+            catch (err) {
+                this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
+                return 0;
             }
-            // Replace each segmented prompt rectangle with its mask region; keep any
-            // rectangle that produced no mask (so it can be retried) + other regions.
-            const out = regions.filter((r) => !consumed.has(r)).concat(masks);
-            this.host.setRegions(out);
-            this.status$.next(added > 0 ? `Added ${added} region(s).` : 'No masks found.');
-            return added;
-        }
-        catch (err) {
-            this.status$.next(err instanceof Error ? err.message : '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 prompt rectangle's color; fall back to the host default.
-        region.color = color || this.host.getShapeColor();
-        // Default class/annotation name, matching the wand/brush + overlay-drawn regions.
-        region.label = 'sam';
-        return region;
-    }
-    async ensureSession() {
-        if (this.session)
-            return this.session;
-        if (!isSamModelReady(this.model)) {
-            throw new Error(`SAM model "${this.model.id}" is not configured yet (no ONNX URLs). ` +
-                'Host it and call setSamModelUrls(), then retry.');
-        }
-        // Lazy-import so onnxruntime-web is never pulled into unit tests / the
-        // initial bundle — only when segmentation actually runs.
-        const { OnnxSamSession } = await import('./onnx-sam-session');
-        const session = new OnnxSamSession();
-        this.progress$.next(0);
-        await session.loadModel(this.model, (f) => this.progress$.next(f));
-        this.session = session;
-        return session;
+            try {
+                // Encode once per image; reuse the embedding across all boxes.
+                const key = [host.getFileName() ?? '', frameIdx, `${cached.width}x${cached.height}`, frame.sig].join('|');
+                const embedding = await this.sessions.embed(session, cached, frameIdx, key, () => this.status$.next('Encoding image…'));
+                const masks = [];
+                const consumed = []; // prompt rectangles that produced a mask
+                for (let i = 0; i < rects.length; i++) {
+                    this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);
+                    const b = rects[i].bounds;
+                    // Rectangle is in data coords → convert to image (matrix) coords.
+                    const box = {
+                        x0: frame.toMatrixX(b.x),
+                        y0: frame.toMatrixY(b.y),
+                        x1: frame.toMatrixX(b.x + b.width),
+                        y1: frame.toMatrixY(b.y + b.height),
+                    };
+                    const res = await session.decode(embedding, { box });
+                    // Keep the largest connected piece (maskToPolygons returns largest-first).
+                    const poly = maskToPolygons(res.mask, res.width, res.height, 0, 0)[0];
+                    if (!poly)
+                        continue;
+                    // Inherit the prompt rectangle's colour.
+                    masks.push(makeSamRegion(poly, frame, rects[i].color || host.getShapeColor()));
+                    consumed.push(rects[i]);
+                }
+                // Commit against the regions as they are NOW: the user may have drawn,
+                // edited or deleted regions during the (possibly minutes-long) run.
+                // Prompts that produced a mask are replaced; the rest stay for a retry.
+                host.setRegions(withoutRegions(host.getRegions(), consumed).concat(masks));
+                this.status$.next(masks.length > 0 ? `Added ${masks.length} region(s).` : 'No masks found.');
+                return masks.length;
+            }
+            catch (err) {
+                this.status$.next(err instanceof Error ? err.message : 'Segmentation failed.');
+                return 0;
+            }
+        });
+        return added ?? 0;
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, deps: [{ token: i1.SamSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamToolService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1.WandService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-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 { frameToRgba } from './sam-prompt';\nimport { getSamModel, isSamModelReady } from './sam-model-registry';\nimport { ISamSession, SamEmbedding, SamModelDef } from '../../contracts/sam.contract';\nimport { Region, Polygon, Rectangle } from '../../models/region';\n\n/** The SAM tool binds to the same host the wand/brush use, so each backend\n *  reuses its existing pixel readback + coordinate transform + region store. */\nexport type SamToolHost = WandToolHost;\n\n/**\n * Box-prompted SAM segmentation tool (jit-ui#90, P0). On `segmentBoxes()` it\n * reads every rectangle region, runs the (cached) encoder once for the image,\n * then runs the decoder per box, traces each mask to a polygon (reusing\n * WandService.maskToPolygons) and commits them as regions.\n *\n * Inference is abstracted behind {@link ISamSession}: production uses the\n * onnxruntime-web session (lazy-imported so ORT never loads in unit tests);\n * tests inject a fake via {@link useSession}.\n */\n@Injectable({ providedIn: 'root' })\nexport class SamToolService {\n  private host!: SamToolHost;\n  private session: ISamSession | null = null;\n  private model: SamModelDef = getSamModel();\n\n  /** Cached encoder embedding + the key (image identity) it was computed for. */\n  private embedding: SamEmbedding | null = null;\n  private embeddingKey: string | null = null;\n\n  /** Status text + busy flag for a spinner / toast in the host. */\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  /** Encoder-download progress: -1 = not downloading, 0..1 = downloading. */\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(private wandService: WandService) {}\n\n  /** Bind to the active backend's host (called by the backend, like the wand). */\n  bindHost(host: SamToolHost): void {\n    this.host = host;\n  }\n\n  /** Choose the registered model to use; invalidates any cached embedding. */\n  setModel(id: string): void {\n    const next = getSamModel(id);\n    if (next.id === this.model.id) return;\n    this.model = next;\n    this.invalidateEmbedding();\n    // Drop the loaded session so the next run reloads the newly-picked model's\n    // ONNX pair — ensureSession() returns the cached session as-is, so without\n    // this a model switch would keep running the previous model.\n    this.session?.dispose();\n    this.session = null;\n  }\n\n  /** Drop the cached embedding (e.g. after the image/slice changes). */\n  invalidateEmbedding(): void {\n    this.embedding = null;\n    this.embeddingKey = null;\n  }\n\n  /** Test seam: inject a fake/alternate inference session. */\n  useSession(session: ISamSession): void {\n    this.session = session;\n  }\n\n  /**\n   * Segment every rectangle region with a box prompt and append the resulting\n   * masks as new polygon regions. Returns how many regions were added.\n   */\n  async segmentBoxes(): Promise<number> {\n    if (!this.host) return 0;\n    // Re-entrancy guard: a second Segment press while the first run is still\n    // downloading/encoding would launch a concurrent model download + GPU\n    // encode (and can freeze the tab on a heavy WebGPU ViT-B). Ignore it.\n    if (this.busy$.value) return 0;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) {\n      this.status$.next('No image loaded.');\n      return 0;\n    }\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 press Segment.');\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\n    let session: ISamSession;\n    try {\n      session = await this.ensureSession();\n    } catch (err) {\n      this.busy$.next(false);\n      this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n      return 0;\n    }\n\n    this.busy$.next(true);\n    try {\n      // Encode once per image; reuse the embedding across all boxes.\n      const key = [\n        this.host.getFileName() ?? '',\n        this.host.getActiveFrameIndex(),\n        `${cached.width}x${cached.height}`,\n        `${ox},${oy},${rx}`,\n        this.model.id,\n      ].join('|');\n      if (!this.embedding || this.embeddingKey !== key) {\n        this.status$.next('Encoding image…');\n        const rgba = frameToRgba(cached, this.host.getActiveFrameIndex());\n        this.embedding = await session.embed({ data: rgba, width: cached.width, height: cached.height });\n        this.embeddingKey = key;\n      }\n\n      const masks: Region[] = [];\n      const consumed = new Set<Region>(); // prompt rectangles that produced a mask\n      let added = 0;\n      for (let i = 0; i < rects.length; i++) {\n        this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);\n        const b = rects[i].bounds as Rectangle;\n        // Rectangle is in data coords → convert to image (matrix) coords.\n        const box = {\n          x0: (b.x - ox) / rx,\n          y0: (b.y - oy) / ry,\n          x1: (b.x + b.width - ox) / rx,\n          y1: (b.y + b.height - oy) / ry,\n        };\n        const res = await session.decode(this.embedding, { box });\n        const polys = this.wandService.maskToPolygons(\n          res.mask, res.width, res.height, cached.width, cached.height, 0, 0,\n        );\n        if (polys.length === 0) continue;\n        // Keep the largest connected piece (maskToPolygons returns largest-first).\n        const poly = polys[0];\n        masks.push(this.makeRegion(\n          poly.xpoints.map((x) => ox + x * rx),\n          poly.ypoints.map((y) => oy + y * ry),\n          rects[i].color, // inherit the prompt rectangle's color\n        ));\n        consumed.add(rects[i]); // this rectangle is now represented by its mask\n        added++;\n      }\n\n      // Replace each segmented prompt rectangle with its mask region; keep any\n      // rectangle that produced no mask (so it can be retried) + other regions.\n      const out = regions.filter((r) => !consumed.has(r)).concat(masks);\n      this.host.setRegions(out);\n      this.status$.next(added > 0 ? `Added ${added} region(s).` : 'No masks found.');\n      return added;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : '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\n    const region = new Region();\n    region.bounds = poly;\n    // Inherit the source prompt rectangle's color; fall back to the host default.\n    region.color = color || this.host.getShapeColor();\n    // Default class/annotation name, matching the wand/brush + overlay-drawn regions.\n    region.label = 'sam';\n    return region;\n  }\n\n  private async ensureSession(): Promise<ISamSession> {\n    if (this.session) return this.session;\n    if (!isSamModelReady(this.model)) {\n      throw new Error(\n        `SAM model \"${this.model.id}\" is not configured yet (no ONNX URLs). ` +\n        'Host it and call setSamModelUrls(), then retry.',\n      );\n    }\n    // Lazy-import so onnxruntime-web is never pulled into unit tests / the\n    // initial bundle — only when segmentation actually runs.\n    const { OnnxSamSession } = await import('./onnx-sam-session');\n    const session = new OnnxSamSession();\n    this.progress$.next(0);\n    await session.loadModel(this.model, (f) => this.progress$.next(f));\n    this.session = session;\n    return session;\n  }\n}\n"]}
+        }], ctorParameters: () => [{ type: i1.SamSessionService }] });
+function makeSamRegion(poly, frame, color) {
+    const ring = frame.ringToData(poly.xpoints, poly.ypoints);
+    const region = new Region();
+    region.bounds = makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(poly.holes) });
+    // The source prompt rectangle's color, else the host default.
+    region.color = color;
+    // Default class/annotation name, matching the wand/brush + overlay-drawn regions.
+    region.label = 'sam';
+    return region;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-tool.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAW,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;;;AAMvD;;;;;;;;;GASG;AAEH,MAAM,OAAO,cAAc;IASzB,YAA6B,WAA8B,IAAI,iBAAiB,EAAE;QAArD,aAAQ,GAAR,QAAQ,CAA6C;QARjE,UAAK,GAAG,IAAI,eAAe,EAAE,CAAC;QAE/C,iEAAiE;QACxD,YAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;QAC7B,UAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;QAClC,2EAA2E;QAClE,cAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;IAE2C,CAAC;IAEtF,uEAAuE;IACvE,QAAQ,CAAC,EAAU;QACjB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,sEAAsE;IACtE,mBAAmB;QACjB,IAAI,CAAC,QAAQ,CAAC,mBAAmB,EAAE,CAAC;IACtC,CAAC;IAED,4DAA4D;IAC5D,UAAU,CAAC,OAAoB;QAC7B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,YAAY,CAAC,IAAoB;QACrC,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI;YAAE,OAAO,CAAC,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACtC,OAAO,CAAC,CAAC;QACX,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,YAAY,SAAS,CAAC,CAAC;QAC7E,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;YACtE,OAAO,CAAC,CAAC;QACX,CAAC;QACD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE5C,sEAAsE;QACtE,4EAA4E;QAC5E,iBAAiB;QACjB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YAC5C,IAAI,OAAoB,CAAC;YACzB,IAAI,CAAC;gBACH,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC7E,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC;gBACjF,OAAO,CAAC,CAAC;YACX,CAAC;YACD,IAAI,CAAC;gBACH,+DAA+D;gBAC/D,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC1G,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,CAC/E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,iBAAiB,CAAC,CACrC,CAAC;gBAEF,MAAM,KAAK,GAAa,EAAE,CAAC;gBAC3B,MAAM,QAAQ,GAAa,EAAE,CAAC,CAAC,yCAAyC;gBACxE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBACtC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;oBAC1D,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAmB,CAAC;oBACvC,kEAAkE;oBAClE,MAAM,GAAG,GAAG;wBACV,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;wBACxB,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;wBACxB,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC;wBAClC,EAAE,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;qBACpC,CAAC;oBACF,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;oBACrD,2EAA2E;oBAC3E,MAAM,IAAI,GAAG,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBACtE,IAAI,CAAC,IAAI;wBAAE,SAAS;oBACpB,yCAAyC;oBACzC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;oBAC/E,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1B,CAAC;gBAED,uEAAuE;gBACvE,oEAAoE;gBACpE,wEAAwE;gBACxE,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC3E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,aAAa,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC;gBAC7F,OAAO,KAAK,CAAC,MAAM,CAAC;YACtB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC;gBAC/E,OAAO,CAAC,CAAC;YACX,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,KAAK,IAAI,CAAC,CAAC;IACpB,CAAC;8GAnGU,cAAc;kHAAd,cAAc,cADD,MAAM;;2FACnB,cAAc;kBAD1B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;AAuGlC,SAAS,aAAa,CAAC,IAAa,EAAE,KAAkB,EAAE,KAAa;IACrE,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1D,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;IAC5B,MAAM,CAAC,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACxF,8DAA8D;IAC9D,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,kFAAkF;IAClF,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,OAAO,MAAM,CAAC;AAChB,CAAC","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { CanvasToolHost } from '../tool-kit/canvas-tool';\nimport { SamSessionService } from './sam-session.service';\nimport { ISamSession } from '../../contracts/sam.contract';\nimport { Region, Polygon, Rectangle } from '../../models/region';\nimport { makePolygon } from '../../models/polygon-factory';\nimport { maskToPolygons } from '../../geometry/contour';\nimport { MatrixFrame } from '../tool-kit/matrix-frame';\nimport { AsyncToolStatus } from '../tool-kit/async-tool-status';\nimport { withoutRegions } from './segmentation-commit';\n\n/** @deprecated The SAM tool runs against the backend's canvas-tool host:\n *  use {@link CanvasToolHost}. */\nexport type SamToolHost = CanvasToolHost;\n\n/**\n * Box-prompted SAM segmentation tool (jit-ui#90, P0). On `segmentBoxes()` it\n * reads every rectangle region, runs the (cached) encoder once for the image,\n * then runs the decoder per box, traces each mask to a polygon and replaces\n * the prompt rectangles with the masks.\n *\n * Inference goes through the shared {@link SamSessionService} (one session and\n * embedding for both SAM tools); tests inject a fake session via\n * {@link useSession}.\n */\n@Injectable({ providedIn: 'root' })\nexport class SamToolService {\n  private readonly state = new AsyncToolStatus();\n\n  /** Status text + busy flag for a spinner / toast in the host. */\n  readonly status$ = this.state.status$;\n  readonly busy$ = this.state.busy$;\n  /** Encoder-download progress: -1 = not downloading, 0..1 = downloading. */\n  readonly progress$ = this.state.progress$;\n\n  constructor(private readonly sessions: SamSessionService = new SamSessionService()) {}\n\n  /** Choose the registered model to use (shared with the point tool). */\n  setModel(id: string): void {\n    this.sessions.setModel(id);\n  }\n\n  /** Drop the cached embedding (e.g. after the image/slice changes). */\n  invalidateEmbedding(): void {\n    this.sessions.invalidateEmbedding();\n  }\n\n  /** Test seam: inject a fake/alternate inference session. */\n  useSession(session: ISamSession): void {\n    this.sessions.useSession(session);\n  }\n\n  /**\n   * Segment every rectangle region of the backend behind `host` with a box\n   * prompt and replace each prompt that produced a mask with the mask's polygon\n   * region. Returns how many regions were added; 0 (ignored) while a previous\n   * run is still going. The host is passed per run, so no backend's host\n   * outlives its call.\n   */\n  async segmentBoxes(host: CanvasToolHost): Promise<number> {\n    if (this.state.busy) return 0;\n    const cached = host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) {\n      this.status$.next('No image loaded.');\n      return 0;\n    }\n    const rects = host.getRegions().filter((r) => r.bounds instanceof Rectangle);\n    if (rects.length === 0) {\n      this.status$.next('Draw one or more rectangles, then press Segment.');\n      return 0;\n    }\n    const frame = MatrixFrame.from(cached);\n    const frameIdx = host.getActiveFrameIndex();\n\n    // Busy from here on — including the model download, so a second press\n    // can't start a second download/encode (which can freeze the tab on a heavy\n    // WebGPU ViT-B).\n    const added = await this.state.run(async () => {\n      let session: ISamSession;\n      try {\n        session = await this.sessions.ensureSession((f) => this.progress$.next(f));\n      } catch (err) {\n        this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n        return 0;\n      }\n      try {\n        // Encode once per image; reuse the embedding across all boxes.\n        const key = [host.getFileName() ?? '', frameIdx, `${cached.width}x${cached.height}`, frame.sig].join('|');\n        const embedding = await this.sessions.embed(session, cached, frameIdx, key, () =>\n          this.status$.next('Encoding image…'),\n        );\n\n        const masks: Region[] = [];\n        const consumed: Region[] = []; // prompt rectangles that produced a mask\n        for (let i = 0; i < rects.length; i++) {\n          this.status$.next(`Segmenting ${i + 1}/${rects.length}…`);\n          const b = rects[i].bounds as Rectangle;\n          // Rectangle is in data coords → convert to image (matrix) coords.\n          const box = {\n            x0: frame.toMatrixX(b.x),\n            y0: frame.toMatrixY(b.y),\n            x1: frame.toMatrixX(b.x + b.width),\n            y1: frame.toMatrixY(b.y + b.height),\n          };\n          const res = await session.decode(embedding, { box });\n          // Keep the largest connected piece (maskToPolygons returns largest-first).\n          const poly = maskToPolygons(res.mask, res.width, res.height, 0, 0)[0];\n          if (!poly) continue;\n          // Inherit the prompt rectangle's colour.\n          masks.push(makeSamRegion(poly, frame, rects[i].color || host.getShapeColor()));\n          consumed.push(rects[i]);\n        }\n\n        // Commit against the regions as they are NOW: the user may have drawn,\n        // edited or deleted regions during the (possibly minutes-long) run.\n        // Prompts that produced a mask are replaced; the rest stay for a retry.\n        host.setRegions(withoutRegions(host.getRegions(), consumed).concat(masks));\n        this.status$.next(masks.length > 0 ? `Added ${masks.length} region(s).` : 'No masks found.');\n        return masks.length;\n      } catch (err) {\n        this.status$.next(err instanceof Error ? err.message : 'Segmentation failed.');\n        return 0;\n      }\n    });\n    return added ?? 0;\n  }\n}\n\nfunction makeSamRegion(poly: Polygon, frame: MatrixFrame, color: string): Region {\n  const ring = frame.ringToData(poly.xpoints, poly.ypoints);\n  const region = new Region();\n  region.bounds = makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(poly.holes) });\n  // The source prompt rectangle's color, else the host default.\n  region.color = color;\n  // Default class/annotation name, matching the wand/brush + overlay-drawn regions.\n  region.label = 'sam';\n  return region;\n}\n"]}

package/esm2022/lib/toolbar/segmentation/segmentation-commit.mjs

@@ -0,0 +1,12 @@
+/**
+ * `regions` minus `remove`, matched by id (identity for a region without one).
+ * Async tools use it to drop their consumed prompts from the *current* region
+ * list at commit time, instead of overwriting the list they read before a long
+ * download or inference (RT-6).
+ */
+export function withoutRegions(regions, remove) {
+    const ids = new Set(remove.map((r) => r.id).filter((id) => id != null));
+    const objs = new Set(remove);
+    return regions.filter((r) => !objs.has(r) && !(r.id != null && ids.has(r.id)));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VnbWVudGF0aW9uLWNvbW1pdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdG9vbGJhci9zZWdtZW50YXRpb24vc2VnbWVudGF0aW9uLWNvbW1pdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQUMsT0FBaUIsRUFBRSxNQUFnQjtJQUNoRSxNQUFNLEdBQUcsR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxFQUFFLEVBQUUsQ0FBQyxFQUFFLElBQUksSUFBSSxDQUFDLENBQUMsQ0FBQztJQUN4RSxNQUFNLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM3QixPQUFPLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsSUFBSSxJQUFJLElBQUksR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDO0FBQ2pGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBSZWdpb24gfSBmcm9tICcuLi8uLi9tb2RlbHMvcmVnaW9uJztcblxuLyoqXG4gKiBgcmVnaW9uc2AgbWludXMgYHJlbW92ZWAsIG1hdGNoZWQgYnkgaWQgKGlkZW50aXR5IGZvciBhIHJlZ2lvbiB3aXRob3V0IG9uZSkuXG4gKiBBc3luYyB0b29scyB1c2UgaXQgdG8gZHJvcCB0aGVpciBjb25zdW1lZCBwcm9tcHRzIGZyb20gdGhlICpjdXJyZW50KiByZWdpb25cbiAqIGxpc3QgYXQgY29tbWl0IHRpbWUsIGluc3RlYWQgb2Ygb3ZlcndyaXRpbmcgdGhlIGxpc3QgdGhleSByZWFkIGJlZm9yZSBhIGxvbmdcbiAqIGRvd25sb2FkIG9yIGluZmVyZW5jZSAoUlQtNikuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB3aXRob3V0UmVnaW9ucyhyZWdpb25zOiBSZWdpb25bXSwgcmVtb3ZlOiBSZWdpb25bXSk6IFJlZ2lvbltdIHtcbiAgY29uc3QgaWRzID0gbmV3IFNldChyZW1vdmUubWFwKChyKSA9PiByLmlkKS5maWx0ZXIoKGlkKSA9PiBpZCAhPSBudWxsKSk7XG4gIGNvbnN0IG9ianMgPSBuZXcgU2V0KHJlbW92ZSk7XG4gIHJldHVybiByZWdpb25zLmZpbHRlcigocikgPT4gIW9ianMuaGFzKHIpICYmICEoci5pZCAhPSBudWxsICYmIGlkcy5oYXMoci5pZCkpKTtcbn1cbiJdfQ==