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

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

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

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

@@ -20,11 +20,27 @@ export class CellposeSegmenterService {
     constructor() {
         this.instance = null;
         this.loading = null;
+        /** Bumped by {@link setModelUrl}, so a load of the previous URL is discarded. */
+        this.generation = 0;
         this.modelUrl = DEFAULT_MODEL_URL;
+        /** Every in-flight caller's callbacks: one shared load reports to all of them. */
+        this.progressListeners = new Set();
+        this.statusListeners = new Set();
     }
-    /** Point the segmenter at a different hosted CPSAM ONNX (before first use). */
+    /**
+     * Point the segmenter at a different hosted CPSAM ONNX. Changing the URL after
+     * the model loaded (or while it loads) disposes it, so the next run loads the
+     * new model instead of silently keeping the old one.
+     */
     setModelUrl(url) {
+        if (url === this.modelUrl)
+            return;
         this.modelUrl = url;
+        this.generation++;
+        this.loading = null;
+        const old = this.instance;
+        this.instance = null;
+        old?.dispose().catch((err) => console.warn('Cellpose: disposing the previous model failed', err));
     }
     async segmentCells(image, progress) {
         let announcedDownload = false;
@@ -47,7 +63,8 @@ export class CellposeSegmenterService {
     }
     /**
      * The shared Cellpose instance, lazily created on first use and reused
-     * thereafter (deduped across concurrent callers). Exposed so a host pipeline
+     * thereafter (deduped across concurrent callers, each of which receives the
+     * load's progress). A failed load is retried on the next call. Exposed so a host pipeline
      * engine can run richer `segment()` options on the same instance. `onProgress`
      * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`
      * reports worker-init phase strings.
@@ -55,21 +72,46 @@ export class CellposeSegmenterService {
     getModel(onProgress, onStatus) {
         if (this.instance)
             return Promise.resolve(this.instance);
+        if (onProgress)
+            this.progressListeners.add(onProgress);
+        if (onStatus)
+            this.statusListeners.add(onStatus);
         if (!this.loading) {
-            this.loading = (async () => {
+            const generation = this.generation;
+            const url = this.modelUrl;
+            const load = (async () => {
                 // Lazy: keep cellpose-js + its ORT runtime out of the initial bundle.
                 const { Cellpose, configureOrt } = await import('cellpose-js');
                 configureOrt({ wasmPaths: getOrtWasmBase() });
-                const cp = await Cellpose.fromPretrained(this.modelUrl, {
+                const cp = await Cellpose.fromPretrained(url, {
                     preload: true,
-                    onProgress: ({ loaded, total }) => onProgress?.(loaded, total),
-                    onStatus: (s) => onStatus?.(s),
+                    onProgress: ({ loaded, total }) => this.progressListeners.forEach((l) => l(loaded, total)),
+                    onStatus: (s) => this.statusListeners.forEach((l) => l(s)),
                 });
+                if (generation !== this.generation) {
+                    // The URL changed while this loaded: drop it and load the current one.
+                    cp.dispose().catch(() => undefined);
+                    return this.getModel();
+                }
                 this.instance = cp;
                 return cp;
             })();
+            this.loading = load;
+            // A failed load is not cached: the next call retries (a network blip or a
+            // WebGPU init failure must not need a page reload).
+            load
+                .catch(() => undefined)
+                .finally(() => {
+                if (this.loading === load)
+                    this.loading = null;
+            });
         }
-        return this.loading;
+        return this.loading.finally(() => {
+            if (onProgress)
+                this.progressListeners.delete(onProgress);
+            if (onStatus)
+                this.statusListeners.delete(onStatus);
+        });
     }
     /** Whether the shared model is already loaded (warm). */
     isLoaded() {
@@ -82,4 +124,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cellpose-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/cellpose-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\n\nimport type { ICellSegmenter, CellSegmentation, CellSegmentProgress } from '../../contracts/cell-segmenter.contract';\nimport type { Cellpose } from 'cellpose-js';\n\n/** Hosted cellpose-SAM ONNX (CPSAM, fp16). Override via {@link setModelUrl}. */\nconst DEFAULT_MODEL_URL =\n  'https://huggingface.co/jax-image-tools/cellpose-sam-onnx/resolve/main/cpsam_fp16.onnx';\n\n/**\n * Default in-library {@link ICellSegmenter} backed by cellpose-js (WebGPU/WASM\n * ONNX) — so the toolbar's automatic **Cellpose** tool works out of the box in\n * any app, with no host wiring (jit-ui#90). `cellpose-js` is a regular\n * dependency — installed automatically, like `napari-js` — but it is\n * **lazy-imported** on first use, so apps that never run Cellpose pay nothing\n * for it in the bundle. A host can still override the {@link CELL_SEGMENTER}\n * token to supply a different implementation.\n *\n * Owns a single shared {@link Cellpose} instance (one model load, one WebGPU\n * session, one worker). {@link getModel} exposes that instance so a host's\n * processing pipeline can reuse it instead of loading the ~588 MB model twice.\n */\n@Injectable({ providedIn: 'root' })\nexport class CellposeSegmenterService implements ICellSegmenter {\n  private instance: Cellpose | null = null;\n  private loading: Promise<Cellpose> | null = null;\n  private modelUrl = DEFAULT_MODEL_URL;\n\n  /** Point the segmenter at a different hosted CPSAM ONNX (before first use). */\n  setModelUrl(url: string): void {\n    this.modelUrl = url;\n  }\n\n  async segmentCells(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    progress?: CellSegmentProgress,\n  ): Promise<CellSegmentation> {\n    let announcedDownload = false;\n    const cp = await this.getModel(\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.('Downloading Cellpose-SAM model…');\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n    progress?.onStatus?.('Preprocessing image…');\n    const out = await cp.segment(\n      { data: image.data, width: image.width, height: image.height, channels: 4 },\n      {\n        // cellpose-js runs inference in its worker (these fire between tiles) and\n        // averaging/dynamics on the main thread; surface both so the toast shows\n        // real progress instead of looking stuck.\n        onTileProgress: (done, total) => progress?.onStatus?.(\n          done < total ? `Running inference (tile ${done}/${total})…` : 'Computing flow dynamics…',\n        ),\n      },\n    );\n    return { labels: out.masks, width: out.width, height: out.height, count: out.count };\n  }\n\n  /**\n   * The shared Cellpose instance, lazily created on first use and reused\n   * thereafter (deduped across concurrent callers). Exposed so a host pipeline\n   * engine can run richer `segment()` options on the same instance. `onProgress`\n   * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`\n   * reports worker-init phase strings.\n   */\n  getModel(\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<Cellpose> {\n    if (this.instance) return Promise.resolve(this.instance);\n    if (!this.loading) {\n      this.loading = (async () => {\n        // Lazy: keep cellpose-js + its ORT runtime out of the initial bundle.\n        const { Cellpose, configureOrt } = await import('cellpose-js');\n        configureOrt({ wasmPaths: getOrtWasmBase() });\n        const cp = await Cellpose.fromPretrained(this.modelUrl, {\n          preload: true,\n          onProgress: ({ loaded, total }) => onProgress?.(loaded, total),\n          onStatus: (s) => onStatus?.(s),\n        });\n        this.instance = cp;\n        return cp;\n      })();\n    }\n    return this.loading;\n  }\n\n  /** Whether the shared model is already loaded (warm). */\n  isLoaded(): boolean {\n    return this.instance !== null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cellpose-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/cellpose-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\n\nimport type {\n  ICellSegmenter,\n  CellSegmentation,\n  CellSegmentProgress,\n} from '../../contracts/cell-segmenter.contract';\nimport type { Cellpose } from 'cellpose-js';\n\n/** Hosted cellpose-SAM ONNX (CPSAM, fp16). Override via {@link setModelUrl}. */\nconst DEFAULT_MODEL_URL = 'https://huggingface.co/jax-image-tools/cellpose-sam-onnx/resolve/main/cpsam_fp16.onnx';\n\n/**\n * Default in-library {@link ICellSegmenter} backed by cellpose-js (WebGPU/WASM\n * ONNX) — so the toolbar's automatic **Cellpose** tool works out of the box in\n * any app, with no host wiring (jit-ui#90). `cellpose-js` is a regular\n * dependency — installed automatically, like `napari-js` — but it is\n * **lazy-imported** on first use, so apps that never run Cellpose pay nothing\n * for it in the bundle. A host can still override the {@link CELL_SEGMENTER}\n * token to supply a different implementation.\n *\n * Owns a single shared {@link Cellpose} instance (one model load, one WebGPU\n * session, one worker). {@link getModel} exposes that instance so a host's\n * processing pipeline can reuse it instead of loading the ~588 MB model twice.\n */\n@Injectable({ providedIn: 'root' })\nexport class CellposeSegmenterService implements ICellSegmenter {\n  private instance: Cellpose | null = null;\n  private loading: Promise<Cellpose> | null = null;\n  /** Bumped by {@link setModelUrl}, so a load of the previous URL is discarded. */\n  private generation = 0;\n  private modelUrl = DEFAULT_MODEL_URL;\n  /** Every in-flight caller's callbacks: one shared load reports to all of them. */\n  private readonly progressListeners = new Set<(loaded: number, total: number | null) => void>();\n  private readonly statusListeners = new Set<(status: string) => void>();\n\n  /**\n   * Point the segmenter at a different hosted CPSAM ONNX. Changing the URL after\n   * the model loaded (or while it loads) disposes it, so the next run loads the\n   * new model instead of silently keeping the old one.\n   */\n  setModelUrl(url: string): void {\n    if (url === this.modelUrl) return;\n    this.modelUrl = url;\n    this.generation++;\n    this.loading = null;\n    const old = this.instance;\n    this.instance = null;\n    old?.dispose().catch((err) => console.warn('Cellpose: disposing the previous model failed', err));\n  }\n\n  async segmentCells(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    progress?: CellSegmentProgress,\n  ): Promise<CellSegmentation> {\n    let announcedDownload = false;\n    const cp = await this.getModel(\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.('Downloading Cellpose-SAM model…');\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n    progress?.onStatus?.('Preprocessing image…');\n    const out = await cp.segment(\n      { data: image.data, width: image.width, height: image.height, channels: 4 },\n      {\n        // cellpose-js runs inference in its worker (these fire between tiles) and\n        // averaging/dynamics on the main thread; surface both so the toast shows\n        // real progress instead of looking stuck.\n        onTileProgress: (done, total) =>\n          progress?.onStatus?.(\n            done < total ? `Running inference (tile ${done}/${total})…` : 'Computing flow dynamics…',\n          ),\n      },\n    );\n    return { labels: out.masks, width: out.width, height: out.height, count: out.count };\n  }\n\n  /**\n   * The shared Cellpose instance, lazily created on first use and reused\n   * thereafter (deduped across concurrent callers, each of which receives the\n   * load's progress). A failed load is retried on the next call. Exposed so a host pipeline\n   * engine can run richer `segment()` options on the same instance. `onProgress`\n   * reports raw downloaded/total bytes (`total` is null when unknown); `onStatus`\n   * reports worker-init phase strings.\n   */\n  getModel(\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<Cellpose> {\n    if (this.instance) return Promise.resolve(this.instance);\n    if (onProgress) this.progressListeners.add(onProgress);\n    if (onStatus) this.statusListeners.add(onStatus);\n    if (!this.loading) {\n      const generation = this.generation;\n      const url = this.modelUrl;\n      const load = (async () => {\n        // Lazy: keep cellpose-js + its ORT runtime out of the initial bundle.\n        const { Cellpose, configureOrt } = await import('cellpose-js');\n        configureOrt({ wasmPaths: getOrtWasmBase() });\n        const cp = await Cellpose.fromPretrained(url, {\n          preload: true,\n          onProgress: ({ loaded, total }) => this.progressListeners.forEach((l) => l(loaded, total)),\n          onStatus: (s) => this.statusListeners.forEach((l) => l(s)),\n        });\n        if (generation !== this.generation) {\n          // The URL changed while this loaded: drop it and load the current one.\n          cp.dispose().catch(() => undefined);\n          return this.getModel();\n        }\n        this.instance = cp;\n        return cp;\n      })();\n      this.loading = load;\n      // A failed load is not cached: the next call retries (a network blip or a\n      // WebGPU init failure must not need a page reload).\n      load\n        .catch(() => undefined)\n        .finally(() => {\n          if (this.loading === load) this.loading = null;\n        });\n    }\n    return this.loading.finally(() => {\n      if (onProgress) this.progressListeners.delete(onProgress);\n      if (onStatus) this.statusListeners.delete(onStatus);\n    });\n  }\n\n  /** Whether the shared model is already loaded (warm). */\n  isLoaded(): boolean {\n    return this.instance !== null;\n  }\n}\n"]}