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

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

@@ -1,11 +1,49 @@
 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 } from '../../models/region';
+import { isSamModelReady } from './sam-model-registry';
+import { SamSessionService } from './sam-session.service';
+import { Region } from '../../models/region';
+import { makePolygon, replaceBounds } 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 { ToolOverlayCanvas } from '../tool-kit/tool-overlay';
 import * as i0 from "@angular/core";
-import * as i1 from "../wand/wand.service";
+import * as i1 from "./sam-session.service";
+/**
+ * The SAM point prompts of one viewer chain: the status feeds the toolbar shows
+ * and the model session. Every backend's `CanvasToolManager` gets its own
+ * {@link SamPointTool} from {@link createTool}, so in-progress points never
+ * cross backends, while all of them report through these feeds and share one
+ * busy guard and one {@link SamSessionService}.
+ */
+export class SamPointToolService {
+    constructor(sessions = new SamSessionService()) {
+        this.sessions = sessions;
+        this.state = new AsyncToolStatus();
+        this.status$ = this.state.status$;
+        this.busy$ = this.state.busy$;
+        /** Encoder-download progress (0..1) on the first click; -1 when not downloading. */
+        this.progress$ = this.state.progress$;
+    }
+    /** Choose the registered model to use (shared with the box tool). */
+    setModel(id) {
+        this.sessions.setModel(id);
+    }
+    /** Test seam: inject a fake/alternate session. */
+    useSession(session) {
+        this.sessions.useSession(session);
+    }
+    /** A point tool for one backend, reporting through this service. */
+    createTool() {
+        return new SamPointTool(this.state, this.sessions);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, deps: [{ token: i1.SamSessionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.SamSessionService }] });
 /** Interactive SAM point-prompt tool (jit-ui#90, P1).
  *
  * Each plain (positive) click segments the clicked object as its OWN new region
@@ -14,64 +52,50 @@ import * as i1 from "../wand/wand.service";
  * the decoder against the (cached) image embedding and updating its live region.
  * `commit()` (Enter) finalises early; `clear()` (Esc) discards the current
  * prompt + its preview region. Mirrors the wand/brush on-canvas tool pattern and
- * reuses WandService.maskToPolygons + the shared region store.
+ * reuses the contour tracer + the shared region store.
  *
- * Inference is behind {@link ISamSession} (lazy onnxruntime-web in production,
- * a fake in tests).
+ * Inference goes through the shared {@link SamSessionService} (one session and
+ * embedding for both SAM tools; lazy onnxruntime-web in production, a fake in
+ * tests). Created by {@link SamPointToolService.createTool}.
  */
-export class SamPointToolService {
-    constructor(wandService) {
-        this.wandService = wandService;
-        this.overlay = null;
-        this.session = null;
-        /** In-flight session load — dedupes a warm-up preload against the first click. */
-        this.sessionLoad = null;
-        this.model = getSamModel();
-        this.embedding = null;
-        this.embeddingKey = null;
+export class SamPointTool {
+    constructor(state, sessions) {
+        this.state = state;
+        this.sessions = sessions;
+        this.id = 'samPoint';
+        this.host = null;
+        this.overlay = new ToolOverlayCanvas();
         /** Accumulated point prompts, in image (matrix) coords. */
         this.points = [];
         /** Id of the in-progress (preview) region being refined, if committed to store. */
         this.regionId = null;
-        this.status$ = new BehaviorSubject('');
-        this.busy$ = new BehaviorSubject(false);
-        /** Encoder-download progress (0..1) on the first click; -1 when not downloading. */
-        this.progress$ = new BehaviorSubject(-1);
-        this.boundMouseDown = (e) => { void this.onMouseDown(e); };
     }
-    bindHost(host) { this.host = host; }
-    setModel(id) {
-        const next = getSamModel(id);
-        if (next.id === this.model.id)
-            return;
-        this.model = next;
-        this.embedding = null;
-        this.embeddingKey = null;
-        // Drop the loaded session so the next run reloads the newly-picked model
-        // (ensureSession() returns the cached session as-is otherwise).
-        this.session?.dispose();
-        this.session = null;
-        this.sessionLoad = null;
+    get status$() {
+        return this.state.status$;
     }
-    /** Test seam: inject a fake/alternate session. */
-    useSession(session) { this.session = session; }
-    setMode(active) {
-        if (active) {
-            this.createOverlay();
-            // Warm up the model in the background as soon as the tool is armed, so the
-            // first click doesn't pay the (download +) session-build cost on its path.
-            this.preload();
-        }
-        else {
-            this.destroyOverlay();
-        }
+    // ── ICanvasTool ─────────────────────────────────────────────────────────
+    activate(host) {
+        this.host = host;
+        this.createOverlay();
+        // Warm up the model in the background as soon as the tool is armed, so the
+        // first click doesn't pay the (download +) session-build cost on its path.
+        this.preload();
+    }
+    deactivate() {
+        this.overlay.detach();
+        this.reset();
+    }
+    /** Forget the current prompt (its preview region stays). */
+    reset() {
+        this.points = [];
+        this.regionId = null;
     }
     /** Eagerly load the model in the background (fire-and-forget). Safe to call
      *  repeatedly — it dedupes against an in-flight load and an existing session. */
     preload() {
-        if (this.session || !isSamModelReady(this.model))
+        if (this.sessions.hasSession() || !isSamModelReady(this.sessions.getModel()))
             return;
-        void this.ensureSession().catch(() => undefined);
+        void this.sessions.ensureSession().catch(() => undefined);
     }
     /** Finalise the current object: keep its region, start fresh next click. */
     commit() {
@@ -81,7 +105,7 @@ export class SamPointToolService {
     }
     /** Discard the in-progress prompt + its preview region. */
     clear() {
-        if (this.regionId != null) {
+        if (this.regionId != null && this.host) {
             const regions = this.host.getRegions().filter((r) => r.id !== this.regionId);
             this.host.setRegions(regions);
         }
@@ -89,34 +113,21 @@ export class SamPointToolService {
         this.regionId = null;
         this.status$.next('');
     }
-    // ── overlay lifecycle (mirrors the wand/brush tools) ────────────────────
+    // ── overlay lifecycle (shared with the wand/brush tools) ────────────────
     createOverlay() {
-        const plotEl = this.host?.getOverlayContainer();
-        if (!plotEl || this.overlay)
+        const container = this.host?.getOverlayContainer();
+        if (!container)
             return;
-        const canvas = document.createElement('canvas');
-        Object.assign(canvas.style, {
-            position: 'absolute', top: '0', left: '0', width: '100%', height: '100%',
-            cursor: 'crosshair', zIndex: '100',
+        this.overlay.attach(container, {
+            down: (e) => {
+                void this.onPointerDown(e);
+            },
         });
-        canvas.width = plotEl.offsetWidth;
-        canvas.height = plotEl.offsetHeight;
-        plotEl.appendChild(canvas);
-        this.overlay = canvas;
-        canvas.addEventListener('mousedown', this.boundMouseDown);
-    }
-    destroyOverlay() {
-        if (!this.overlay)
-            return;
-        this.overlay.removeEventListener('mousedown', this.boundMouseDown);
-        this.overlay.remove();
-        this.overlay = null;
-        this.points = [];
-        this.regionId = null;
     }
     // ── per-click refinement ────────────────────────────────────────────────
-    async onMouseDown(e) {
-        if (e.button !== 0 || !this.overlay)
+    /** Primary button only (the overlay filters the others). */
+    async onPointerDown(e) {
+        if (!this.overlay.attached)
             return;
         // Re-entrancy guard: ignore clicks while a previous prompt is still
         // downloading the model / encoding / decoding. Without it, clicking again
@@ -124,21 +135,22 @@ export class SamPointToolService {
         // concurrent downloads + GPU encodes that can overwhelm the GPU and freeze
         // the tab. Each click is fast once the embedding is cached, so this only
         // drops clicks made while genuinely busy.
-        if (this.busy$.value)
+        if (this.state.busy)
+            return;
+        const host = this.host;
+        if (!host)
             return;
-        const cached = this.host.getCachedImageData();
+        const cached = host.getCachedImageData();
         if (!cached || cached.frames.length === 0)
             return;
-        const transform = this.host.getCoordinateTransform();
+        const transform = host.getCoordinateTransform();
         if (!transform.isReady())
             return;
         const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);
         if (!Number.isFinite(dataX) || !Number.isFinite(dataY))
             return;
-        const rx = cached.ratios[0] || 1;
-        const ry = cached.ratios[0] || 1;
-        const ox = cached.originX ?? 0;
-        const oy = cached.originY ?? 0;
+        const frame = MatrixFrame.from(cached);
+        const frameIdx = host.getActiveFrameIndex();
         // Shift or Alt = negative (exclude) point.
         const label = e.shiftKey || e.altKey ? 0 : 1;
         // A plain positive click starts a NEW object: clicking another fiber must
@@ -152,104 +164,55 @@ export class SamPointToolService {
             this.points = [];
             this.regionId = null;
         }
-        this.points.push({ x: (dataX - ox) / rx, y: (dataY - oy) / ry, label });
-        // Mark busy BEFORE ensureSession: the first click downloads the encoder
-        // (~14–172 MB) and builds the session, which is the longest wait — without
-        // this the UI showed nothing running until that finished.
-        this.busy$.next(true);
-        try {
-            this.status$.next('Loading SAM model…');
-            const session = await this.ensureSession();
-            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;
+        this.points.push({ x: frame.toMatrixX(dataX), y: frame.toMatrixY(dataY), label });
+        // Busy from here on — including the model download (~14–172 MB on the
+        // first click), the longest wait — so the UI shows the run at once.
+        await this.state.run(async () => {
+            try {
+                this.status$.next('Loading SAM model…');
+                const session = await this.sessions.ensureSession((f) => this.state.progress$.next(f));
+                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…'));
+                this.status$.next('Segmenting…');
+                const prompt = { points: this.points.slice() };
+                const res = await session.decode(embedding, prompt);
+                const poly = maskToPolygons(res.mask, res.width, res.height, 0, 0)[0];
+                if (!poly) {
+                    this.status$.next('No mask for these points.');
+                    return;
+                }
+                this.upsertPreview(host, poly, frame);
+                this.status$.next('Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.');
             }
-            this.status$.next('Segmenting…');
-            const prompt = { points: this.points.slice() };
-            const res = await session.decode(this.embedding, prompt);
-            const polys = this.wandService.maskToPolygons(res.mask, res.width, res.height, cached.width, cached.height, 0, 0);
-            if (polys.length === 0) {
-                this.status$.next('No mask for these points.');
-                return;
+            catch (err) {
+                this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
             }
-            const poly = polys[0];
-            this.upsertPreview(poly.xpoints.map((x) => ox + x * rx), poly.ypoints.map((y) => oy + y * ry));
-            this.status$.next('Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.');
-        }
-        catch (err) {
-            this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');
-        }
-        finally {
-            this.busy$.next(false);
-            this.progress$.next(-1);
-        }
+        });
     }
-    /** Replace (or insert) the in-progress preview region in the shared store. */
-    upsertPreview(xData, yData) {
-        if (xData.length < 3)
+    /** Replace (or insert) the in-progress preview region in the shared store,
+     *  against the regions as they are now (the run may have taken a while). */
+    upsertPreview(host, poly, frame) {
+        if (poly.xpoints.length < 3)
             return;
-        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 regions = this.host.getRegions();
-        const existing = this.regionId != null ? regions.find((r) => r.id === this.regionId) : null;
-        const region = new Region();
-        region.bounds = poly;
-        region.color = this.host.getShapeColor();
-        region.label = 'sam';
-        if (existing) {
-            region.id = existing.id;
-            region.name = existing.name;
-            const idx = regions.findIndex((r) => r.id === this.regionId);
-            if (idx >= 0)
-                regions[idx] = region;
-            else
-                regions.push(region);
+        const ring = frame.ringToData(poly.xpoints, poly.ypoints);
+        const regions = host.getRegions();
+        const bounds = makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(poly.holes) });
+        const idx = this.regionId != null ? regions.findIndex((r) => r.id === this.regionId) : -1;
+        let region;
+        if (idx >= 0) {
+            // Refining: keep the preview's identity and anything the user changed on it.
+            region = replaceBounds(regions[idx], bounds);
+            regions[idx] = region;
         }
         else {
+            region = new Region();
+            region.bounds = bounds;
+            region.color = host.getShapeColor();
+            region.label = 'sam';
             regions.push(region);
         }
-        this.host.setRegions(regions);
+        host.setRegions(regions);
         this.regionId = region.id ?? this.regionId;
     }
-    ensureSession() {
-        if (this.session)
-            return Promise.resolve(this.session);
-        if (this.sessionLoad)
-            return this.sessionLoad;
-        if (!isSamModelReady(this.model)) {
-            return Promise.reject(new Error(`SAM model "${this.model.id}" is not configured yet (no ONNX URLs). ` +
-                'Host it and call setSamModelUrls(), then retry.'));
-        }
-        this.sessionLoad = (async () => {
-            try {
-                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;
-            }
-            finally {
-                this.sessionLoad = null;
-            }
-        })();
-        return this.sessionLoad;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, deps: [{ token: i1.WandService }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: SamPointToolService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1.WandService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-point-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-point-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, SamPrompt } from '../../contracts/sam.contract';\nimport { Region, Polygon } from '../../models/region';\n\n/** Interactive SAM point-prompt tool (jit-ui#90, P1).\n *\n * Each plain (positive) click segments the clicked object as its OWN new region\n * — clicking a second fiber doesn't extend the first into it. Shift/Alt-click\n * adds a negative (exclude) point that refines the CURRENT object, re-running\n * the decoder against the (cached) image embedding and updating its live region.\n * `commit()` (Enter) finalises early; `clear()` (Esc) discards the current\n * prompt + its preview region. Mirrors the wand/brush on-canvas tool pattern and\n * reuses WandService.maskToPolygons + the shared region store.\n *\n * Inference is behind {@link ISamSession} (lazy onnxruntime-web in production,\n * a fake in tests).\n */\n@Injectable({ providedIn: 'root' })\nexport class SamPointToolService {\n  private host!: WandToolHost;\n  private overlay: HTMLCanvasElement | null = null;\n  private session: ISamSession | null = null;\n  /** In-flight session load — dedupes a warm-up preload against the first click. */\n  private sessionLoad: Promise<ISamSession> | null = null;\n  private model: SamModelDef = getSamModel();\n\n  private embedding: SamEmbedding | null = null;\n  private embeddingKey: string | null = null;\n\n  /** Accumulated point prompts, in image (matrix) coords. */\n  private points: { x: number; y: number; label: 0 | 1 }[] = [];\n  /** Id of the in-progress (preview) region being refined, if committed to store. */\n  private regionId: number | null = null;\n\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  /** Encoder-download progress (0..1) on the first click; -1 when not downloading. */\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  private readonly boundMouseDown: (e: MouseEvent) => void;\n\n  constructor(private wandService: WandService) {\n    this.boundMouseDown = (e) => { void this.onMouseDown(e); };\n  }\n\n  bindHost(host: WandToolHost): void { this.host = host; }\n\n  setModel(id: string): void {\n    const next = getSamModel(id);\n    if (next.id === this.model.id) return;\n    this.model = next;\n    this.embedding = null;\n    this.embeddingKey = null;\n    // Drop the loaded session so the next run reloads the newly-picked model\n    // (ensureSession() returns the cached session as-is otherwise).\n    this.session?.dispose();\n    this.session = null;\n    this.sessionLoad = null;\n  }\n\n  /** Test seam: inject a fake/alternate session. */\n  useSession(session: ISamSession): void { this.session = session; }\n\n  setMode(active: boolean): void {\n    if (active) {\n      this.createOverlay();\n      // Warm up the model in the background as soon as the tool is armed, so the\n      // first click doesn't pay the (download +) session-build cost on its path.\n      this.preload();\n    } else {\n      this.destroyOverlay();\n    }\n  }\n\n  /** Eagerly load the model in the background (fire-and-forget). Safe to call\n   *  repeatedly — it dedupes against an in-flight load and an existing session. */\n  preload(): void {\n    if (this.session || !isSamModelReady(this.model)) return;\n    void this.ensureSession().catch(() => undefined);\n  }\n\n  /** Finalise the current object: keep its region, start fresh next click. */\n  commit(): void {\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  /** Discard the in-progress prompt + its preview region. */\n  clear(): void {\n    if (this.regionId != null) {\n      const regions = this.host.getRegions().filter((r) => r.id !== this.regionId);\n      this.host.setRegions(regions);\n    }\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  // ── overlay lifecycle (mirrors the wand/brush tools) ────────────────────\n\n  private createOverlay(): void {\n    const plotEl = this.host?.getOverlayContainer();\n    if (!plotEl || this.overlay) return;\n    const canvas = document.createElement('canvas');\n    Object.assign(canvas.style, {\n      position: 'absolute', top: '0', left: '0', width: '100%', height: '100%',\n      cursor: 'crosshair', zIndex: '100',\n    });\n    canvas.width = plotEl.offsetWidth;\n    canvas.height = plotEl.offsetHeight;\n    plotEl.appendChild(canvas);\n    this.overlay = canvas;\n    canvas.addEventListener('mousedown', this.boundMouseDown);\n  }\n\n  private destroyOverlay(): void {\n    if (!this.overlay) return;\n    this.overlay.removeEventListener('mousedown', this.boundMouseDown);\n    this.overlay.remove();\n    this.overlay = null;\n    this.points = [];\n    this.regionId = null;\n  }\n\n  // ── per-click refinement ────────────────────────────────────────────────\n\n  private async onMouseDown(e: MouseEvent): Promise<void> {\n    if (e.button !== 0 || !this.overlay) return;\n    // Re-entrancy guard: ignore clicks while a previous prompt is still\n    // downloading the model / encoding / decoding. Without it, clicking again\n    // during the slow first run (e.g. a ~172 MB ViT-B encode on WebGPU) launches\n    // concurrent downloads + GPU encodes that can overwhelm the GPU and freeze\n    // the tab. Each click is fast once the embedding is cached, so this only\n    // drops clicks made while genuinely busy.\n    if (this.busy$.value) return;\n    const cached = this.host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) return;\n    const transform = this.host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return;\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    // Shift or Alt = negative (exclude) point.\n    const label: 0 | 1 = e.shiftKey || e.altKey ? 0 : 1;\n    // A plain positive click starts a NEW object: clicking another fiber must\n    // segment that fiber on its own, not accumulate with earlier points and\n    // grow the in-progress mask into the adjacent object (which would also\n    // overwrite a previously-segmented region). Only Shift/Alt (exclude) points\n    // refine the current object. This also clears any stale prompt left after a\n    // region was deleted, so the next click segments fresh instead of redrawing\n    // the old merged mask.\n    if (label === 1) {\n      this.points = [];\n      this.regionId = null;\n    }\n    this.points.push({ x: (dataX - ox) / rx, y: (dataY - oy) / ry, label });\n\n    // Mark busy BEFORE ensureSession: the first click downloads the encoder\n    // (~14–172 MB) and builds the session, which is the longest wait — without\n    // this the UI showed nothing running until that finished.\n    this.busy$.next(true);\n    try {\n      this.status$.next('Loading SAM model…');\n      const session = await this.ensureSession();\n      const key = [\n        this.host.getFileName() ?? '', this.host.getActiveFrameIndex(),\n        `${cached.width}x${cached.height}`, `${ox},${oy},${rx}`, 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      this.status$.next('Segmenting…');\n      const prompt: SamPrompt = { points: this.points.slice() };\n      const res = await session.decode(this.embedding, prompt);\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) { this.status$.next('No mask for these points.'); return; }\n      const poly = polys[0];\n      this.upsertPreview(\n        poly.xpoints.map((x) => ox + x * rx),\n        poly.ypoints.map((y) => oy + y * ry),\n      );\n      this.status$.next(\n        'Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.',\n      );\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  /** Replace (or insert) the in-progress preview region in the shared store. */\n  private upsertPreview(xData: number[], yData: number[]): void {\n    if (xData.length < 3) return;\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 regions = this.host.getRegions();\n    const existing = this.regionId != null ? regions.find((r) => r.id === this.regionId) : null;\n    const region = new Region();\n    region.bounds = poly;\n    region.color = this.host.getShapeColor();\n    region.label = 'sam';\n    if (existing) {\n      region.id = existing.id;\n      region.name = existing.name;\n      const idx = regions.findIndex((r) => r.id === this.regionId);\n      if (idx >= 0) regions[idx] = region; else regions.push(region);\n    } else {\n      regions.push(region);\n    }\n    this.host.setRegions(regions);\n    this.regionId = region.id ?? this.regionId;\n  }\n\n  private ensureSession(): Promise<ISamSession> {\n    if (this.session) return Promise.resolve(this.session);\n    if (this.sessionLoad) return this.sessionLoad;\n    if (!isSamModelReady(this.model)) {\n      return Promise.reject(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    this.sessionLoad = (async () => {\n      try {\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      } finally {\n        this.sessionLoad = null;\n      }\n    })();\n    return this.sessionLoad;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-point-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-point-tool.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAW,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC1E,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,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;;;AAG7D;;;;;;GAMG;AAEH,MAAM,OAAO,mBAAmB;IAQ9B,YAA6B,WAA8B,IAAI,iBAAiB,EAAE;QAArD,aAAQ,GAAR,QAAQ,CAA6C;QAPjE,UAAK,GAAG,IAAI,eAAe,EAAE,CAAC;QAEtC,YAAO,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;QAC7B,UAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;QAClC,oFAAoF;QAC3E,cAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC;IAE2C,CAAC;IAEtF,qEAAqE;IACrE,QAAQ,CAAC,EAAU;QACjB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,kDAAkD;IAClD,UAAU,CAAC,OAAoB;QAC7B,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAED,oEAAoE;IACpE,UAAU;QACR,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrD,CAAC;8GAvBU,mBAAmB;kHAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE;;AA2BlC;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,YAAY;IAUvB,YACmB,KAAsB,EACtB,QAA2B;QAD3B,UAAK,GAAL,KAAK,CAAiB;QACtB,aAAQ,GAAR,QAAQ,CAAmB;QAXrC,OAAE,GAAG,UAAU,CAAC;QACjB,SAAI,GAA0B,IAAI,CAAC;QAC1B,YAAO,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAEnD,2DAA2D;QACnD,WAAM,GAA6C,EAAE,CAAC;QAC9D,mFAAmF;QAC3E,aAAQ,GAAkB,IAAI,CAAC;IAKpC,CAAC;IAEJ,IAAY,OAAO;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;IAC5B,CAAC;IAED,2EAA2E;IAE3E,QAAQ,CAAC,IAAoB;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,2EAA2E;QAC3E,2EAA2E;QAC3E,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED,UAAU;QACR,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAED,4DAA4D;IAC5D,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;IACvB,CAAC;IAED;qFACiF;IACjF,OAAO;QACL,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAAE,OAAO;QACrF,KAAK,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;IAC5D,CAAC;IAED,4EAA4E;IAC5E,MAAM;QACJ,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,2DAA2D;IAC3D,KAAK;QACH,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YACvC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC7E,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAChC,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACxB,CAAC;IAED,2EAA2E;IAEnE,aAAa;QACnB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC;QACnD,IAAI,CAAC,SAAS;YAAE,OAAO;QACvB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE;YAC7B,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;gBACV,KAAK,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;YAC7B,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED,2EAA2E;IAE3E,4DAA4D;IACpD,KAAK,CAAC,aAAa,CAAC,CAAe;QACzC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ;YAAE,OAAO;QACnC,oEAAoE;QACpE,0EAA0E;QAC1E,6EAA6E;QAC7E,2EAA2E;QAC3E,yEAAyE;QACzE,0CAA0C;QAC1C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI;YAAE,OAAO;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QACzC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAClD,MAAM,SAAS,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAChD,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;YAAE,OAAO;QACjC,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC;QAC5E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO;QAE/D,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC5C,2CAA2C;QAC3C,MAAM,KAAK,GAAU,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpD,0EAA0E;QAC1E,wEAAwE;QACxE,uEAAuE;QACvE,4EAA4E;QAC5E,4EAA4E;QAC5E,4EAA4E;QAC5E,uBAAuB;QACvB,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;YAChB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;YACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACvB,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAElF,sEAAsE;QACtE,oEAAoE;QACpE,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YAC9B,IAAI,CAAC;gBACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;gBACxC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvF,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;gBACF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACjC,MAAM,MAAM,GAAc,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC;gBAC1D,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;gBACpD,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;gBACtE,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;oBAC/C,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;gBACtC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,uFAAuF,CAAC,CAAC;YAC7G,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;YACnF,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;gFAC4E;IACpE,aAAa,CAAC,IAAoB,EAAE,IAAa,EAAE,KAAkB;QAC3E,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,OAAO;QACpC,MAAM,IAAI,GAAG,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1D,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,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;QACvF,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1F,IAAI,MAAc,CAAC;QACnB,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;YACb,6EAA6E;YAC7E,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC;QACxB,CAAC;aAAM,CAAC;YACN,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;YACtB,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC;YACvB,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACpC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,EAAE,IAAI,IAAI,CAAC,QAAQ,CAAC;IAC7C,CAAC;CACF","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { isSamModelReady } from './sam-model-registry';\nimport { SamSessionService } from './sam-session.service';\nimport { ISamSession, SamPrompt } from '../../contracts/sam.contract';\nimport { Region, Polygon } from '../../models/region';\nimport { makePolygon, replaceBounds } 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 { ToolOverlayCanvas } from '../tool-kit/tool-overlay';\nimport { CanvasToolHost, ICanvasTool } from '../tool-kit/canvas-tool';\n\n/**\n * The SAM point prompts of one viewer chain: the status feeds the toolbar shows\n * and the model session. Every backend's `CanvasToolManager` gets its own\n * {@link SamPointTool} from {@link createTool}, so in-progress points never\n * cross backends, while all of them report through these feeds and share one\n * busy guard and one {@link SamSessionService}.\n */\n@Injectable({ providedIn: 'root' })\nexport class SamPointToolService {\n  private readonly state = new AsyncToolStatus();\n\n  readonly status$ = this.state.status$;\n  readonly busy$ = this.state.busy$;\n  /** Encoder-download progress (0..1) on the first click; -1 when not 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 box tool). */\n  setModel(id: string): void {\n    this.sessions.setModel(id);\n  }\n\n  /** Test seam: inject a fake/alternate session. */\n  useSession(session: ISamSession): void {\n    this.sessions.useSession(session);\n  }\n\n  /** A point tool for one backend, reporting through this service. */\n  createTool(): SamPointTool {\n    return new SamPointTool(this.state, this.sessions);\n  }\n}\n\n/** Interactive SAM point-prompt tool (jit-ui#90, P1).\n *\n * Each plain (positive) click segments the clicked object as its OWN new region\n * — clicking a second fiber doesn't extend the first into it. Shift/Alt-click\n * adds a negative (exclude) point that refines the CURRENT object, re-running\n * the decoder against the (cached) image embedding and updating its live region.\n * `commit()` (Enter) finalises early; `clear()` (Esc) discards the current\n * prompt + its preview region. Mirrors the wand/brush on-canvas tool pattern and\n * reuses the contour tracer + the shared region store.\n *\n * Inference goes through the shared {@link SamSessionService} (one session and\n * embedding for both SAM tools; lazy onnxruntime-web in production, a fake in\n * tests). Created by {@link SamPointToolService.createTool}.\n */\nexport class SamPointTool implements ICanvasTool<void> {\n  readonly id = 'samPoint';\n  private host: CanvasToolHost | null = null;\n  private readonly overlay = new ToolOverlayCanvas();\n\n  /** Accumulated point prompts, in image (matrix) coords. */\n  private points: { x: number; y: number; label: 0 | 1 }[] = [];\n  /** Id of the in-progress (preview) region being refined, if committed to store. */\n  private regionId: number | null = null;\n\n  constructor(\n    private readonly state: AsyncToolStatus,\n    private readonly sessions: SamSessionService,\n  ) {}\n\n  private get status$() {\n    return this.state.status$;\n  }\n\n  // ── ICanvasTool ─────────────────────────────────────────────────────────\n\n  activate(host: CanvasToolHost): void {\n    this.host = host;\n    this.createOverlay();\n    // Warm up the model in the background as soon as the tool is armed, so the\n    // first click doesn't pay the (download +) session-build cost on its path.\n    this.preload();\n  }\n\n  deactivate(): void {\n    this.overlay.detach();\n    this.reset();\n  }\n\n  /** Forget the current prompt (its preview region stays). */\n  reset(): void {\n    this.points = [];\n    this.regionId = null;\n  }\n\n  /** Eagerly load the model in the background (fire-and-forget). Safe to call\n   *  repeatedly — it dedupes against an in-flight load and an existing session. */\n  preload(): void {\n    if (this.sessions.hasSession() || !isSamModelReady(this.sessions.getModel())) return;\n    void this.sessions.ensureSession().catch(() => undefined);\n  }\n\n  /** Finalise the current object: keep its region, start fresh next click. */\n  commit(): void {\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  /** Discard the in-progress prompt + its preview region. */\n  clear(): void {\n    if (this.regionId != null && this.host) {\n      const regions = this.host.getRegions().filter((r) => r.id !== this.regionId);\n      this.host.setRegions(regions);\n    }\n    this.points = [];\n    this.regionId = null;\n    this.status$.next('');\n  }\n\n  // ── overlay lifecycle (shared with the wand/brush tools) ────────────────\n\n  private createOverlay(): void {\n    const container = this.host?.getOverlayContainer();\n    if (!container) return;\n    this.overlay.attach(container, {\n      down: (e) => {\n        void this.onPointerDown(e);\n      },\n    });\n  }\n\n  // ── per-click refinement ────────────────────────────────────────────────\n\n  /** Primary button only (the overlay filters the others). */\n  private async onPointerDown(e: PointerEvent): Promise<void> {\n    if (!this.overlay.attached) return;\n    // Re-entrancy guard: ignore clicks while a previous prompt is still\n    // downloading the model / encoding / decoding. Without it, clicking again\n    // during the slow first run (e.g. a ~172 MB ViT-B encode on WebGPU) launches\n    // concurrent downloads + GPU encodes that can overwhelm the GPU and freeze\n    // the tab. Each click is fast once the embedding is cached, so this only\n    // drops clicks made while genuinely busy.\n    if (this.state.busy) return;\n    const host = this.host;\n    if (!host) return;\n    const cached = host.getCachedImageData();\n    if (!cached || cached.frames.length === 0) return;\n    const transform = host.getCoordinateTransform();\n    if (!transform.isReady()) return;\n    const { x: dataX, y: dataY } = transform.clientToData(e.clientX, e.clientY);\n    if (!Number.isFinite(dataX) || !Number.isFinite(dataY)) return;\n\n    const frame = MatrixFrame.from(cached);\n    const frameIdx = host.getActiveFrameIndex();\n    // Shift or Alt = negative (exclude) point.\n    const label: 0 | 1 = e.shiftKey || e.altKey ? 0 : 1;\n    // A plain positive click starts a NEW object: clicking another fiber must\n    // segment that fiber on its own, not accumulate with earlier points and\n    // grow the in-progress mask into the adjacent object (which would also\n    // overwrite a previously-segmented region). Only Shift/Alt (exclude) points\n    // refine the current object. This also clears any stale prompt left after a\n    // region was deleted, so the next click segments fresh instead of redrawing\n    // the old merged mask.\n    if (label === 1) {\n      this.points = [];\n      this.regionId = null;\n    }\n    this.points.push({ x: frame.toMatrixX(dataX), y: frame.toMatrixY(dataY), label });\n\n    // Busy from here on — including the model download (~14–172 MB on the\n    // first click), the longest wait — so the UI shows the run at once.\n    await this.state.run(async () => {\n      try {\n        this.status$.next('Loading SAM model…');\n        const session = await this.sessions.ensureSession((f) => this.state.progress$.next(f));\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        this.status$.next('Segmenting…');\n        const prompt: SamPrompt = { points: this.points.slice() };\n        const res = await session.decode(embedding, prompt);\n        const poly = maskToPolygons(res.mask, res.width, res.height, 0, 0)[0];\n        if (!poly) {\n          this.status$.next('No mask for these points.');\n          return;\n        }\n        this.upsertPreview(host, poly, frame);\n        this.status$.next('Segmented — click another fiber for a new region, Shift-click to refine, Esc to undo.');\n      } catch (err) {\n        this.status$.next(err instanceof Error ? err.message : 'SAM model unavailable.');\n      }\n    });\n  }\n\n  /** Replace (or insert) the in-progress preview region in the shared store,\n   *  against the regions as they are now (the run may have taken a while). */\n  private upsertPreview(host: CanvasToolHost, poly: Polygon, frame: MatrixFrame): void {\n    if (poly.xpoints.length < 3) return;\n    const ring = frame.ringToData(poly.xpoints, poly.ypoints);\n    const regions = host.getRegions();\n    const bounds = makePolygon(ring.xs, ring.ys, { holes: frame.holesToData(poly.holes) });\n    const idx = this.regionId != null ? regions.findIndex((r) => r.id === this.regionId) : -1;\n    let region: Region;\n    if (idx >= 0) {\n      // Refining: keep the preview's identity and anything the user changed on it.\n      region = replaceBounds(regions[idx], bounds);\n      regions[idx] = region;\n    } else {\n      region = new Region();\n      region.bounds = bounds;\n      region.color = host.getShapeColor();\n      region.label = 'sam';\n      regions.push(region);\n    }\n    host.setRegions(regions);\n    this.regionId = region.id ?? this.regionId;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/sam-prompt.mjs

@@ -1,94 +1,13 @@
+import { frameRegionToRgba } from '../crop/slide-crop';
 /**
- * Pure helpers for SAM inference — no DOM, no ORT, no `this` — so they're unit
- * testable. The session uses these to assemble decoder inputs and to convert
- * the cached image frame into the RGBA buffer the encoder preprocesses.
- */
-/**
- * Build an RGBA buffer (the encoder's input image) from a cached image frame.
- * Grayscale frames are replicated across R/G/B; RGB tuples are copied through.
- * Out-of-range/missing pixels become opaque black.
- */
-export function frameToRgba(cached, frameIndex) {
-    const { width, height } = cached;
-    const frame = cached.frames[frameIndex] ?? cached.frames[0];
-    const rgba = new Uint8ClampedArray(width * height * 4);
-    for (let y = 0; y < height; y++) {
-        const row = frame?.[y];
-        for (let x = 0; x < width; x++) {
-            const o = (y * width + x) * 4;
-            const px = row?.[x];
-            if (px == null) {
-                rgba[o + 3] = 255;
-                continue;
-            }
-            if (cached.isGrayscale) {
-                const v = px;
-                rgba[o] = v;
-                rgba[o + 1] = v;
-                rgba[o + 2] = v;
-            }
-            else {
-                const t = px;
-                rgba[o] = t[0];
-                rgba[o + 1] = t[1];
-                rgba[o + 2] = t[2];
-            }
-            rgba[o + 3] = 255;
-        }
-    }
-    return rgba;
-}
-/**
- * Assemble the SAM decoder's `point_coords` / `point_labels` from a prompt.
+ * Build an RGBA buffer (the SAM encoder's input image) from a cached image
+ * frame: the full-frame case of {@link frameRegionToRgba}. Grayscale frames are
+ * replicated across R/G/B; missing pixels become opaque black.
  *
- * Coordinates are scaled into the encoder's resized space (`scale =
- * inputSize / max(imageW, imageH)`). A box is encoded as two points labelled
- * `2` (top-left) and `3` (bottom-right); positive/negative points use `1`/`0`.
- * When there are points but no box, a padding point `[0,0]` labelled `-1` is
- * appended (the decoder expects the box slots padded when absent).
+ * The decoder-prompt helpers (`buildDecoderPrompt`, `binarizeMask`,
+ * `bestMaskIndex`) live in `sam-onnx-core`, which both inference paths use.
  */
-export function buildDecoderPrompt(prompt, scale) {
-    const coords = [];
-    const labels = [];
-    for (const p of prompt.points ?? []) {
-        coords.push(p.x * scale, p.y * scale);
-        labels.push(p.label);
-    }
-    if (prompt.box) {
-        const b = prompt.box;
-        coords.push(b.x0 * scale, b.y0 * scale);
-        labels.push(2);
-        coords.push(b.x1 * scale, b.y1 * scale);
-        labels.push(3);
-    }
-    else if (labels.length > 0) {
-        // Points-only: pad the (absent) box slot.
-        coords.push(0, 0);
-        labels.push(-1);
-    }
-    return {
-        pointCoords: Float32Array.from(coords),
-        pointLabels: Float32Array.from(labels),
-        numPoints: labels.length,
-    };
-}
-/**
- * Binarize SAM mask logits (`> threshold`, default 0 per SAM's mask_threshold)
- * into a 0/1 mask the contour tracer (WandService.maskToPolygons) consumes.
- */
-export function binarizeMask(logits, threshold = 0) {
-    const out = new Uint8Array(logits.length);
-    for (let i = 0; i < logits.length; i++)
-        out[i] = logits[i] > threshold ? 1 : 0;
-    return out;
-}
-/** Index of the highest-scoring mask in a multimask decoder output. */
-export function bestMaskIndex(iouPredictions) {
-    let best = 0;
-    for (let i = 1; i < iouPredictions.length; i++) {
-        if (iouPredictions[i] > iouPredictions[best])
-            best = i;
-    }
-    return best;
+export function frameToRgba(cached, frameIndex) {
+    return frameRegionToRgba(cached, frameIndex, 0, 0, cached.width, cached.height);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sam-prompt.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/sam-prompt.ts"],"names":[],"mappings":"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","sourcesContent":["import { CachedImageData } from '../wand/wand-tool.service';\nimport { SamPrompt } from '../../contracts/sam.contract';\n\n/**\n * Pure helpers for SAM inference — no DOM, no ORT, no `this` — so they're unit\n * testable. The session uses these to assemble decoder inputs and to convert\n * the cached image frame into the RGBA buffer the encoder preprocesses.\n */\n\n/**\n * Build an RGBA buffer (the encoder's input image) from a cached image frame.\n * Grayscale frames are replicated across R/G/B; RGB tuples are copied through.\n * Out-of-range/missing pixels become opaque black.\n */\nexport function frameToRgba(cached: CachedImageData, frameIndex: number): Uint8ClampedArray {\n  const { width, height } = cached;\n  const frame = cached.frames[frameIndex] ?? cached.frames[0];\n  const rgba = new Uint8ClampedArray(width * height * 4);\n  for (let y = 0; y < height; y++) {\n    const row = frame?.[y];\n    for (let x = 0; x < width; x++) {\n      const o = (y * width + x) * 4;\n      const px = row?.[x];\n      if (px == null) {\n        rgba[o + 3] = 255;\n        continue;\n      }\n      if (cached.isGrayscale) {\n        const v = px as number;\n        rgba[o] = v; rgba[o + 1] = v; rgba[o + 2] = v;\n      } else {\n        const t = px as number[];\n        rgba[o] = t[0]; rgba[o + 1] = t[1]; rgba[o + 2] = t[2];\n      }\n      rgba[o + 3] = 255;\n    }\n  }\n  return rgba;\n}\n\n/**\n * Assemble the SAM decoder's `point_coords` / `point_labels` from a prompt.\n *\n * Coordinates are scaled into the encoder's resized space (`scale =\n * inputSize / max(imageW, imageH)`). A box is encoded as two points labelled\n * `2` (top-left) and `3` (bottom-right); positive/negative points use `1`/`0`.\n * When there are points but no box, a padding point `[0,0]` labelled `-1` is\n * appended (the decoder expects the box slots padded when absent).\n */\nexport function buildDecoderPrompt(\n  prompt: SamPrompt,\n  scale: number,\n): { pointCoords: Float32Array; pointLabels: Float32Array; numPoints: number } {\n  const coords: number[] = [];\n  const labels: number[] = [];\n\n  for (const p of prompt.points ?? []) {\n    coords.push(p.x * scale, p.y * scale);\n    labels.push(p.label);\n  }\n\n  if (prompt.box) {\n    const b = prompt.box;\n    coords.push(b.x0 * scale, b.y0 * scale);\n    labels.push(2);\n    coords.push(b.x1 * scale, b.y1 * scale);\n    labels.push(3);\n  } else if (labels.length > 0) {\n    // Points-only: pad the (absent) box slot.\n    coords.push(0, 0);\n    labels.push(-1);\n  }\n\n  return {\n    pointCoords: Float32Array.from(coords),\n    pointLabels: Float32Array.from(labels),\n    numPoints: labels.length,\n  };\n}\n\n/**\n * Binarize SAM mask logits (`> threshold`, default 0 per SAM's mask_threshold)\n * into a 0/1 mask the contour tracer (WandService.maskToPolygons) consumes.\n */\nexport function binarizeMask(logits: Float32Array | number[], threshold = 0): Uint8Array {\n  const out = new Uint8Array(logits.length);\n  for (let i = 0; i < logits.length; i++) out[i] = logits[i] > threshold ? 1 : 0;\n  return out;\n}\n\n/** Index of the highest-scoring mask in a multimask decoder output. */\nexport function bestMaskIndex(iouPredictions: Float32Array | number[]): number {\n  let best = 0;\n  for (let i = 1; i < iouPredictions.length; i++) {\n    if (iouPredictions[i] > iouPredictions[best]) best = i;\n  }\n  return best;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FtLXByb21wdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvdG9vbGJhci9zZWdtZW50YXRpb24vc2FtLXByb21wdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV2RDs7Ozs7OztHQU9HO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBQyxNQUF1QixFQUFFLFVBQWtCO0lBQ3JFLE9BQU8saUJBQWlCLENBQUMsTUFBTSxFQUFFLFVBQVUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ2xGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IENhY2hlZEltYWdlRGF0YSB9IGZyb20gJy4uL3dhbmQvd2FuZC10b29sLnNlcnZpY2UnO1xuaW1wb3J0IHsgZnJhbWVSZWdpb25Ub1JnYmEgfSBmcm9tICcuLi9jcm9wL3NsaWRlLWNyb3AnO1xuXG4vKipcbiAqIEJ1aWxkIGFuIFJHQkEgYnVmZmVyICh0aGUgU0FNIGVuY29kZXIncyBpbnB1dCBpbWFnZSkgZnJvbSBhIGNhY2hlZCBpbWFnZVxuICogZnJhbWU6IHRoZSBmdWxsLWZyYW1lIGNhc2Ugb2Yge0BsaW5rIGZyYW1lUmVnaW9uVG9SZ2JhfS4gR3JheXNjYWxlIGZyYW1lcyBhcmVcbiAqIHJlcGxpY2F0ZWQgYWNyb3NzIFIvRy9COyBtaXNzaW5nIHBpeGVscyBiZWNvbWUgb3BhcXVlIGJsYWNrLlxuICpcbiAqIFRoZSBkZWNvZGVyLXByb21wdCBoZWxwZXJzIChgYnVpbGREZWNvZGVyUHJvbXB0YCwgYGJpbmFyaXplTWFza2AsXG4gKiBgYmVzdE1hc2tJbmRleGApIGxpdmUgaW4gYHNhbS1vbm54LWNvcmVgLCB3aGljaCBib3RoIGluZmVyZW5jZSBwYXRocyB1c2UuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmcmFtZVRvUmdiYShjYWNoZWQ6IENhY2hlZEltYWdlRGF0YSwgZnJhbWVJbmRleDogbnVtYmVyKTogVWludDhDbGFtcGVkQXJyYXkge1xuICByZXR1cm4gZnJhbWVSZWdpb25Ub1JnYmEoY2FjaGVkLCBmcmFtZUluZGV4LCAwLCAwLCBjYWNoZWQud2lkdGgsIGNhY2hlZC5oZWlnaHQpO1xufVxuIl19