@jax-data-science/sci-image-visualizer 0.2.15 → 0.2.17

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

@@ -0,0 +1,157 @@
+import { Injectable } from '@angular/core';
+import { getOrtWasmBase } from './ort-runtime-config';
+import { getDefaultRetinalModelId, getRetinalModel, } from './retinal-model-registry';
+import * as i0 from "@angular/core";
+/**
+ * Default in-library {@link ISemanticSegmenter}, backed by jax-ai-js.
+ *
+ * `jax-ai-js` is a regular dependency but is **lazy-imported** on first use, so
+ * apps that never segment retinal layers pay nothing for it — or for
+ * onnxruntime-web — in their initial bundle. Mirrors
+ * {@link YoloSegmenterService}, including its per-model-id cache.
+ *
+ * WEBGPU ONLY, AND A HOST MUST BE READY FOR THAT
+ * Unlike the YOLO and Cellpose services, there is no WASM fallback to degrade
+ * to: ORT-Web's WASM EP dies with `std::bad_alloc` on these graphs at 512², at
+ * every precision. jax-ai-js throws `WebGpuRequiredError` rather than trying,
+ * and it is re-thrown here unchanged so a host can show a real
+ * unsupported-browser message instead of a generic failure.
+ */
+export class RetinalSegmenterService {
+    constructor() {
+        this.instances = new Map();
+        this.loading = new Map();
+    }
+    async segmentSemantic(image, opts = {}, progress) {
+        const modelId = opts.modelId ?? getDefaultRetinalModelId();
+        const def = this.requireModel(modelId);
+        let announcedDownload = false;
+        const seg = await this.getModel(modelId, (loaded, total) => {
+            if (total)
+                progress?.onProgress?.(loaded / total);
+            progress?.onBytes?.(loaded, total);
+            if (loaded > 0 && !announcedDownload) {
+                announcedDownload = true;
+                // The size is in the message because it is ~590 MB — a user who
+                // clicked a button deserves to know that before it finishes.
+                progress?.onStatus?.(`Downloading ${def.label} model (~${def.sizeMb} MB)…`);
+            }
+        }, (status) => progress?.onStatus?.(status));
+        progress?.onStatus?.('Running inference…');
+        const result = await seg.segment({ data: image.data, width: image.width, height: image.height }, {
+            ...(opts.classThreshold !== undefined ? { classThreshold: opts.classThreshold } : {}),
+            ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),
+            ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),
+            ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),
+            ...(opts.signal ? { signal: opts.signal } : {}),
+            // The library narrates its own phases (per patch, then tracing) because
+            // only it knows which one it is in.
+            onStatus: (s) => progress?.onStatus?.(s),
+        });
+        const regions = result.regions.map((r) => ({
+            exterior: r.exterior.map(([x, y]) => [x, y]),
+            holes: r.holes.map((h) => h.map(([x, y]) => [x, y])),
+            classId: r.classId,
+            className: r.className,
+            area: r.area,
+        }));
+        return {
+            regions,
+            classAreas: result.classAreas,
+            classNames: [...result.classNames],
+            width: result.width,
+            height: result.height,
+            unassignedFraction: result.unassignedFraction,
+        };
+    }
+    /**
+     * The shared segmenter for a model id, created on first use and reused
+     * thereafter (deduped across concurrent callers). Exposed so a host's
+     * processing pipeline can run on the same loaded session rather than paying
+     * the ~590 MB load twice.
+     */
+    getModel(modelId = getDefaultRetinalModelId(), onProgress, onStatus) {
+        const existing = this.instances.get(modelId);
+        if (existing)
+            return Promise.resolve(existing);
+        const inFlight = this.loading.get(modelId);
+        if (inFlight)
+            return inFlight;
+        const def = this.requireModel(modelId);
+        const load = (async () => {
+            // Lazy: keep jax-ai-js + its ORT runtime out of the initial bundle.
+            const { RetinalSegmenter, configureOrt } = await import('jax-ai-js');
+            configureOrt({ wasmPaths: getOrtWasmBase() });
+            const seg = await RetinalSegmenter.fromPretrained({
+                modelUrl: def.modelUrl,
+                ...(def.metaUrl ? { metaUrl: def.metaUrl } : {}),
+                onProgress: (loaded, total) => onProgress?.(loaded, total),
+                onStatus: (s) => onStatus?.(s),
+            });
+            this.instances.set(modelId, seg);
+            return seg;
+        })();
+        this.loading.set(modelId, load);
+        // A failed load must not poison the cache — the next caller should retry
+        // rather than inherit the rejected promise forever.
+        load.catch(() => this.loading.delete(modelId));
+        return load;
+    }
+    /** Whether a model is already loaded (warm). */
+    isLoaded(modelId = getDefaultRetinalModelId()) {
+        return this.instances.has(modelId);
+    }
+    /**
+     * Release one model, or all of them. Safe to call on a model never loaded.
+     *
+     * In-flight loads are torn down too: dropping a pending promise and returning
+     * would let the load finish afterwards, re-populate {@link instances}, and
+     * strand a live ORT session that nothing owns — disposal would report success
+     * while leaking. At 590 MB that leak is not survivable.
+     */
+    async dispose(modelId) {
+        const ids = modelId
+            ? [modelId]
+            : [...new Set([...this.instances.keys(), ...this.loading.keys()])];
+        await Promise.all(ids.map((id) => this.disposeOne(id)));
+    }
+    async disposeOne(id) {
+        const pending = this.loading.get(id);
+        const loaded = this.instances.get(id);
+        this.instances.delete(id);
+        this.loading.delete(id);
+        if (loaded)
+            await loaded.dispose();
+        if (!pending)
+            return;
+        // A pending load assigns instances[id] before its promise resolves, so by
+        // the time this await returns the entry is back. Clear it only if it still
+        // points at what *this* load produced — a newer load started meanwhile owns
+        // its own entry and must not be evicted.
+        const seg = await pending.catch(() => null);
+        if (!seg || seg === loaded)
+            return;
+        if (this.instances.get(id) === seg)
+            this.instances.delete(id);
+        await seg.dispose();
+    }
+    requireModel(modelId) {
+        const def = getRetinalModel(modelId);
+        if (!def)
+            throw new Error(`Unknown retinal model id "${modelId}".`);
+        if (!def.modelUrl.trim()) {
+            // Prefer the registry's specific explanation over "not configured" — the
+            // ResUNet-a entries are disabled for a documented accuracy reason, and a
+            // user who picked one deserves to be told which.
+            throw new Error(def.unavailableReason ?? `Retinal model "${modelId}" has no modelUrl configured.`);
+        }
+        return def;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalSegmenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalSegmenterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalSegmenterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retinal-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/retinal-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { getOrtWasmBase } from './ort-runtime-config';\nimport {\n  getDefaultRetinalModelId,\n  getRetinalModel,\n  type RetinalModelDef,\n} from './retinal-model-registry';\n\nimport type {\n  ISemanticSegmenter,\n  SemanticRegion,\n  SemanticSegmentation,\n  SemanticSegmentOptions,\n  SemanticSegmentProgress,\n} from '../../contracts/semantic-segmenter.contract';\nimport type { RetinalSegmenter } from 'jax-ai-js';\n\n/**\n * Default in-library {@link ISemanticSegmenter}, backed by jax-ai-js.\n *\n * `jax-ai-js` is a regular dependency but is **lazy-imported** on first use, so\n * apps that never segment retinal layers pay nothing for it — or for\n * onnxruntime-web — in their initial bundle. Mirrors\n * {@link YoloSegmenterService}, including its per-model-id cache.\n *\n * WEBGPU ONLY, AND A HOST MUST BE READY FOR THAT\n * Unlike the YOLO and Cellpose services, there is no WASM fallback to degrade\n * to: ORT-Web's WASM EP dies with `std::bad_alloc` on these graphs at 512², at\n * every precision. jax-ai-js throws `WebGpuRequiredError` rather than trying,\n * and it is re-thrown here unchanged so a host can show a real\n * unsupported-browser message instead of a generic failure.\n */\n@Injectable({ providedIn: 'root' })\nexport class RetinalSegmenterService implements ISemanticSegmenter {\n  private readonly instances = new Map<string, RetinalSegmenter>();\n  private readonly loading = new Map<string, Promise<RetinalSegmenter>>();\n\n  async segmentSemantic(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    opts: SemanticSegmentOptions = {},\n    progress?: SemanticSegmentProgress,\n  ): Promise<SemanticSegmentation> {\n    const modelId = opts.modelId ?? getDefaultRetinalModelId();\n    const def = this.requireModel(modelId);\n\n    let announcedDownload = false;\n    const seg = await this.getModel(\n      modelId,\n      (loaded, total) => {\n        if (total) progress?.onProgress?.(loaded / total);\n        progress?.onBytes?.(loaded, total);\n        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          // The size is in the message because it is ~590 MB — a user who\n          // clicked a button deserves to know that before it finishes.\n          progress?.onStatus?.(`Downloading ${def.label} model (~${def.sizeMb} MB)…`);\n        }\n      },\n      (status) => progress?.onStatus?.(status),\n    );\n\n    progress?.onStatus?.('Running inference…');\n    const result = await seg.segment(\n      { data: image.data, width: image.width, height: image.height },\n      {\n        ...(opts.classThreshold !== undefined ? { classThreshold: opts.classThreshold } : {}),\n        ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),\n        ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),\n        ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),\n        ...(opts.signal ? { signal: opts.signal } : {}),\n        // The library narrates its own phases (per patch, then tracing) because\n        // only it knows which one it is in.\n        onStatus: (s) => progress?.onStatus?.(s),\n      },\n    );\n\n    const regions: SemanticRegion[] = result.regions.map((r) => ({\n      exterior: r.exterior.map(([x, y]): [number, number] => [x, y]),\n      holes: r.holes.map((h) => h.map(([x, y]): [number, number] => [x, y])),\n      classId: r.classId,\n      className: r.className,\n      area: r.area,\n    }));\n\n    return {\n      regions,\n      classAreas: result.classAreas,\n      classNames: [...result.classNames],\n      width: result.width,\n      height: result.height,\n      unassignedFraction: result.unassignedFraction,\n    };\n  }\n\n  /**\n   * The shared segmenter for a model id, created on first use and reused\n   * thereafter (deduped across concurrent callers). Exposed so a host's\n   * processing pipeline can run on the same loaded session rather than paying\n   * the ~590 MB load twice.\n   */\n  getModel(\n    modelId: string = getDefaultRetinalModelId(),\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<RetinalSegmenter> {\n    const existing = this.instances.get(modelId);\n    if (existing) return Promise.resolve(existing);\n\n    const inFlight = this.loading.get(modelId);\n    if (inFlight) return inFlight;\n\n    const def = this.requireModel(modelId);\n    const load = (async () => {\n      // Lazy: keep jax-ai-js + its ORT runtime out of the initial bundle.\n      const { RetinalSegmenter, configureOrt } = await import('jax-ai-js');\n      configureOrt({ wasmPaths: getOrtWasmBase() });\n      const seg = await RetinalSegmenter.fromPretrained({\n        modelUrl: def.modelUrl,\n        ...(def.metaUrl ? { metaUrl: def.metaUrl } : {}),\n        onProgress: (loaded, total) => onProgress?.(loaded, total),\n        onStatus: (s) => onStatus?.(s),\n      });\n      this.instances.set(modelId, seg);\n      return seg;\n    })();\n\n    this.loading.set(modelId, load);\n    // A failed load must not poison the cache — the next caller should retry\n    // rather than inherit the rejected promise forever.\n    load.catch(() => this.loading.delete(modelId));\n    return load;\n  }\n\n  /** Whether a model is already loaded (warm). */\n  isLoaded(modelId: string = getDefaultRetinalModelId()): boolean {\n    return this.instances.has(modelId);\n  }\n\n  /**\n   * Release one model, or all of them. Safe to call on a model never loaded.\n   *\n   * In-flight loads are torn down too: dropping a pending promise and returning\n   * would let the load finish afterwards, re-populate {@link instances}, and\n   * strand a live ORT session that nothing owns — disposal would report success\n   * while leaking. At 590 MB that leak is not survivable.\n   */\n  async dispose(modelId?: string): Promise<void> {\n    const ids = modelId\n      ? [modelId]\n      : [...new Set([...this.instances.keys(), ...this.loading.keys()])];\n    await Promise.all(ids.map((id) => this.disposeOne(id)));\n  }\n\n  private async disposeOne(id: string): Promise<void> {\n    const pending = this.loading.get(id);\n    const loaded = this.instances.get(id);\n    this.instances.delete(id);\n    this.loading.delete(id);\n\n    if (loaded) await loaded.dispose();\n    if (!pending) return;\n\n    // A pending load assigns instances[id] before its promise resolves, so by\n    // the time this await returns the entry is back. Clear it only if it still\n    // points at what *this* load produced — a newer load started meanwhile owns\n    // its own entry and must not be evicted.\n    const seg = await pending.catch(() => null);\n    if (!seg || seg === loaded) return;\n    if (this.instances.get(id) === seg) this.instances.delete(id);\n    await seg.dispose();\n  }\n\n  private requireModel(modelId: string): RetinalModelDef {\n    const def = getRetinalModel(modelId);\n    if (!def) throw new Error(`Unknown retinal model id \"${modelId}\".`);\n    if (!def.modelUrl.trim()) {\n      // Prefer the registry's specific explanation over \"not configured\" — the\n      // ResUNet-a entries are disabled for a documented accuracy reason, and a\n      // user who picked one deserves to be told which.\n      throw new Error(def.unavailableReason ?? `Retinal model \"${modelId}\" has no modelUrl configured.`);\n    }\n    return def;\n  }\n}\n"]}

package/esm2022/lib/toolbar/segmentation/yolo-detect-tool.service.mjs

@@ -18,6 +18,8 @@ import * as i0 from "@angular/core";
  * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose
  * tool so the host's shared segmentation toast drives it unchanged.
  */
+/** Marks regions this tool produced, so a re-run can replace only its own. */
+export const YOLO_REGION_SOURCE = 'yolo';
 export class YoloDetectToolService {
     constructor(
     /** Server-side crop, so detection can run at the model's scale rather than
@@ -89,9 +91,13 @@ export class YoloDetectToolService {
                 this.status$.next('No objects detected.');
                 return 0;
             }
-            // Append. A detection run must not discard annotations drawn by hand or
-            // produced by another tool.
-            viz.setRegions([...(viz.getRegions() ?? []), ...added]);
+            // Replace this tool's own previous output, keep everything else. Appending
+            // unconditionally made every tuning run stack onto the last, so the
+            // viewer accumulated overlapping results from parameters no longer in
+            // effect. Hand-drawn regions and other tools' output carry no `source`
+            // and are untouched.
+            const kept = (viz.getRegions() ?? []).filter((r) => r.source !== YOLO_REGION_SOURCE);
+            viz.setRegions([...kept, ...added]);
             this.status$.next(`Added ${added.length} region(s).`);
             return added.length;
         }
@@ -165,6 +171,7 @@ export class YoloDetectToolService {
         poly.closed = true;
         const region = new Region();
         region.bounds = poly;
+        region.source = YOLO_REGION_SOURCE;
         // The class name drives preset colour resolution; leaving `color` unset lets
         // an existing preset for this class win.
         region.label = className;
@@ -182,4 +189,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
                     type: Inject,
                     args: [TILE_ACCESS_PORT]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-detect-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-detect-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\n\nimport { Region, Polygon, Rectangle } from '../../models/region';\nimport { TILE_ACCESS_PORT, type TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport type { IVisualizer } from '../../contracts/visualizer.contract';\nimport type { IInstanceSegmenter, InstanceSegmentOptions } from '../../contracts/instance-segmenter.contract';\n\n/**\n * YOLO object detection over the current view.\n *\n * The complement to {@link CellSegmentToolService}: cellpose auto-segments cells\n * inside a box you draw, whereas a detector is meant to find objects across a\n * field. So this takes no prompt — it runs on whatever is on screen and turns\n * every detection into a region.\n *\n * Detections come back in the displayed image's pixels; they are mapped onto\n * the full-resolution image through the viewer's own source rect, so the regions\n * land where the objects actually are rather than at view-local coordinates.\n *\n * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose\n * tool so the host's shared segmentation toast drives it unchanged.\n */\n@Injectable({ providedIn: 'root' })\nexport class YoloDetectToolService {\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(\n    /** Server-side crop, so detection can run at the model's scale rather than\n     *  the viewer's. Optional: without it the tool falls back to the displayed\n     *  pixels, which is correct but scale-dependent. */\n    @Optional() @Inject(TILE_ACCESS_PORT) private tileAccess: TileAccessPort | null = null,\n  ) {}\n\n  /**\n   * Detect in the current view and append the results as regions.\n   *\n   * @returns the number of regions added.\n   */\n  async detectInView(\n    viz: IVisualizer,\n    segmenter: IInstanceSegmenter,\n    opts: InstanceSegmentOptions = {},\n  ): Promise<number> {\n    const pixels = viz.getDisplayedPixelData?.();\n    if (!pixels || pixels.width === 0 || pixels.height === 0) {\n      this.status$.next('No image on screen to detect in.');\n      return 0;\n    }\n\n    this.busy$.next(true);\n    this.progress$.next(-1);\n    try {\n      const rect = viz.getDisplayedSourceRect?.() ?? null;\n      const target = Number(opts.downsamplingFactor ?? 0) || 0;\n      const viewFactor = rect && pixels.width > 0 ? rect.width / pixels.width : 1;\n\n      // Re-crop at the model's scale when the view is coarser than it wants.\n      // The image is tile-backed, so that detail exists server-side even though\n      // the displayed pixels have discarded it.\n      let source = { data: pixels.data, width: pixels.width, height: pixels.height };\n      if (rect && target > 0 && target < viewFactor * 0.98) {\n        this.status$.next('Fetching image at model resolution…');\n        const hi = await this.fetchCropAtScale(rect, target);\n        if (hi) source = hi;\n      }\n\n      const result = await segmenter.segmentInstances(source, opts, {\n        onProgress: (f) => this.progress$.next(f),\n        onStatus: (s) => this.status$.next(s),\n      });\n\n      // View pixels -> full-resolution image pixels. Without this every region\n      // would sit at view-local coordinates, i.e. the wrong place on the slide\n      // for any zoomed or panned view.\n      const offsetX = rect ? rect.x : 0;\n      const offsetY = rect ? rect.y : 0;\n      // Against the pixels actually inferred on, which may be the re-crop.\n      const ratioX = rect && source.width > 0 ? rect.width / source.width : 1;\n      const ratioY = rect && source.height > 0 ? rect.height / source.height : 1;\n\n      const added: Region[] = [];\n      for (const det of result.detections) {\n        if (det.polygons.length > 0) {\n          for (const poly of det.polygons) {\n            if (poly.exterior.length < 3) continue;\n            added.push(\n              this.makeRegion(\n                poly.exterior.map(([x]) => Math.round(offsetX + x * ratioX)),\n                poly.exterior.map(([, y]) => Math.round(offsetY + y * ratioY)),\n                det.className,\n              ),\n            );\n          }\n          continue;\n        }\n        // Detection mode yields no outline; the box is still the result, and\n        // matches what the server writes as a \"detection\" feature.\n        const [x1, y1, x2, y2] = det.box;\n        if (x2 - x1 <= 0 || y2 - y1 <= 0) continue;\n        added.push(\n          this.makeRegion(\n            [x1, x2, x2, x1].map((x) => Math.round(offsetX + x * ratioX)),\n            [y1, y1, y2, y2].map((y) => Math.round(offsetY + y * ratioY)),\n            det.className,\n          ),\n        );\n      }\n\n      if (added.length === 0) {\n        this.status$.next('No objects detected.');\n        return 0;\n      }\n\n      // Append. A detection run must not discard annotations drawn by hand or\n      // produced by another tool.\n      viz.setRegions([...(viz.getRegions() ?? []), ...added]);\n      this.status$.next(`Added ${added.length} region(s).`);\n      return added.length;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'YOLO detection failed.');\n      return 0;\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  /**\n   * Re-crop `rect` at `1/target` of full resolution. Returns null on any\n   * failure, so the caller falls back to the displayed pixels — a coarser crop\n   * beats a failed run.\n   */\n  private async fetchCropAtScale(\n    rect: { x: number; y: number; width: number; height: number },\n    target: number,\n  ): Promise<{ data: Uint8ClampedArray; width: number; height: number } | null> {\n    if (!this.tileAccess) return null;\n    let w = Math.round(rect.width / target);\n    let h = Math.round(rect.height / target);\n\n    // A factor of 1 over a whole-slide ROI would ask for hundreds of megapixels.\n    const MAX_PIXELS = 16_777_216; // 4096²\n    const pixels = w * h;\n    if (pixels > MAX_PIXELS) {\n      const k = Math.sqrt(MAX_PIXELS / pixels);\n      w = Math.round(w * k);\n      h = Math.round(h * k);\n    }\n    if (w < 64 || h < 64) return null;\n\n    try {\n      const roi = {\n        x: Math.round(rect.x),\n        y: Math.round(rect.y),\n        width: Math.round(rect.width),\n        height: Math.round(rect.height),\n      } as Rectangle;\n      const screen = { x: 0, y: 0, width: w, height: h } as Rectangle;\n      const bytes = await firstValueFrom(this.tileAccess.zoomOnRegion(roi, screen, 0));\n      if (!bytes || bytes.byteLength === 0) return null;\n\n      const bitmap = await createImageBitmap(new Blob([bytes]));\n      const canvas = document.createElement('canvas');\n      canvas.width = bitmap.width;\n      canvas.height = bitmap.height;\n      const ctx = canvas.getContext('2d');\n      if (!ctx) return null;\n      ctx.drawImage(bitmap, 0, 0);\n      // Read the dimensions BEFORE close(): closing an ImageBitmap zeroes its\n      // width/height, so returning them afterwards yields a 0x0 image with a\n      // full pixel buffer — inference then runs on nothing and finds nothing.\n      const width = bitmap.width;\n      const height = bitmap.height;\n      const out = ctx.getImageData(0, 0, width, height);\n      bitmap.close?.();\n      return { data: out.data, width, height };\n    } catch {\n      return null;\n    }\n  }\n\n  private makeRegion(xs: number[], ys: number[], className: string): Region {\n    const poly = new Polygon();\n    poly.npoints = xs.length;\n    poly.xpoints = xs;\n    poly.ypoints = ys;\n    poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n    poly.closed = true;\n\n    const region = new Region();\n    region.bounds = poly;\n    // The class name drives preset colour resolution; leaving `color` unset lets\n    // an existing preset for this class win.\n    region.label = className;\n    return region;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-detect-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-detect-tool.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\n\nimport { Region, Polygon, Rectangle } from '../../models/region';\nimport { TILE_ACCESS_PORT, type TileAccessPort } from '../../contracts/ports/tile-access.port';\nimport type { IVisualizer } from '../../contracts/visualizer.contract';\nimport type { IInstanceSegmenter, InstanceSegmentOptions } from '../../contracts/instance-segmenter.contract';\n\n/**\n * YOLO object detection over the current view.\n *\n * The complement to {@link CellSegmentToolService}: cellpose auto-segments cells\n * inside a box you draw, whereas a detector is meant to find objects across a\n * field. So this takes no prompt — it runs on whatever is on screen and turns\n * every detection into a region.\n *\n * Detections come back in the displayed image's pixels; they are mapped onto\n * the full-resolution image through the viewer's own source rect, so the regions\n * land where the objects actually are rather than at view-local coordinates.\n *\n * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose\n * tool so the host's shared segmentation toast drives it unchanged.\n */\n/** Marks regions this tool produced, so a re-run can replace only its own. */\nexport const YOLO_REGION_SOURCE = 'yolo';\n\n@Injectable({ providedIn: 'root' })\nexport class YoloDetectToolService {\n  readonly status$ = new BehaviorSubject<string>('');\n  readonly busy$ = new BehaviorSubject<boolean>(false);\n  readonly progress$ = new BehaviorSubject<number>(-1);\n\n  constructor(\n    /** Server-side crop, so detection can run at the model's scale rather than\n     *  the viewer's. Optional: without it the tool falls back to the displayed\n     *  pixels, which is correct but scale-dependent. */\n    @Optional() @Inject(TILE_ACCESS_PORT) private tileAccess: TileAccessPort | null = null,\n  ) {}\n\n  /**\n   * Detect in the current view and append the results as regions.\n   *\n   * @returns the number of regions added.\n   */\n  async detectInView(\n    viz: IVisualizer,\n    segmenter: IInstanceSegmenter,\n    opts: InstanceSegmentOptions = {},\n  ): Promise<number> {\n    const pixels = viz.getDisplayedPixelData?.();\n    if (!pixels || pixels.width === 0 || pixels.height === 0) {\n      this.status$.next('No image on screen to detect in.');\n      return 0;\n    }\n\n    this.busy$.next(true);\n    this.progress$.next(-1);\n    try {\n      const rect = viz.getDisplayedSourceRect?.() ?? null;\n      const target = Number(opts.downsamplingFactor ?? 0) || 0;\n      const viewFactor = rect && pixels.width > 0 ? rect.width / pixels.width : 1;\n\n      // Re-crop at the model's scale when the view is coarser than it wants.\n      // The image is tile-backed, so that detail exists server-side even though\n      // the displayed pixels have discarded it.\n      let source = { data: pixels.data, width: pixels.width, height: pixels.height };\n      if (rect && target > 0 && target < viewFactor * 0.98) {\n        this.status$.next('Fetching image at model resolution…');\n        const hi = await this.fetchCropAtScale(rect, target);\n        if (hi) source = hi;\n      }\n\n      const result = await segmenter.segmentInstances(source, opts, {\n        onProgress: (f) => this.progress$.next(f),\n        onStatus: (s) => this.status$.next(s),\n      });\n\n      // View pixels -> full-resolution image pixels. Without this every region\n      // would sit at view-local coordinates, i.e. the wrong place on the slide\n      // for any zoomed or panned view.\n      const offsetX = rect ? rect.x : 0;\n      const offsetY = rect ? rect.y : 0;\n      // Against the pixels actually inferred on, which may be the re-crop.\n      const ratioX = rect && source.width > 0 ? rect.width / source.width : 1;\n      const ratioY = rect && source.height > 0 ? rect.height / source.height : 1;\n\n      const added: Region[] = [];\n      for (const det of result.detections) {\n        if (det.polygons.length > 0) {\n          for (const poly of det.polygons) {\n            if (poly.exterior.length < 3) continue;\n            added.push(\n              this.makeRegion(\n                poly.exterior.map(([x]) => Math.round(offsetX + x * ratioX)),\n                poly.exterior.map(([, y]) => Math.round(offsetY + y * ratioY)),\n                det.className,\n              ),\n            );\n          }\n          continue;\n        }\n        // Detection mode yields no outline; the box is still the result, and\n        // matches what the server writes as a \"detection\" feature.\n        const [x1, y1, x2, y2] = det.box;\n        if (x2 - x1 <= 0 || y2 - y1 <= 0) continue;\n        added.push(\n          this.makeRegion(\n            [x1, x2, x2, x1].map((x) => Math.round(offsetX + x * ratioX)),\n            [y1, y1, y2, y2].map((y) => Math.round(offsetY + y * ratioY)),\n            det.className,\n          ),\n        );\n      }\n\n      if (added.length === 0) {\n        this.status$.next('No objects detected.');\n        return 0;\n      }\n\n      // Replace this tool's own previous output, keep everything else. Appending\n      // unconditionally made every tuning run stack onto the last, so the\n      // viewer accumulated overlapping results from parameters no longer in\n      // effect. Hand-drawn regions and other tools' output carry no `source`\n      // and are untouched.\n      const kept = (viz.getRegions() ?? []).filter((r) => r.source !== YOLO_REGION_SOURCE);\n      viz.setRegions([...kept, ...added]);\n      this.status$.next(`Added ${added.length} region(s).`);\n      return added.length;\n    } catch (err) {\n      this.status$.next(err instanceof Error ? err.message : 'YOLO detection failed.');\n      return 0;\n    } finally {\n      this.busy$.next(false);\n      this.progress$.next(-1);\n    }\n  }\n\n  /**\n   * Re-crop `rect` at `1/target` of full resolution. Returns null on any\n   * failure, so the caller falls back to the displayed pixels — a coarser crop\n   * beats a failed run.\n   */\n  private async fetchCropAtScale(\n    rect: { x: number; y: number; width: number; height: number },\n    target: number,\n  ): Promise<{ data: Uint8ClampedArray; width: number; height: number } | null> {\n    if (!this.tileAccess) return null;\n    let w = Math.round(rect.width / target);\n    let h = Math.round(rect.height / target);\n\n    // A factor of 1 over a whole-slide ROI would ask for hundreds of megapixels.\n    const MAX_PIXELS = 16_777_216; // 4096²\n    const pixels = w * h;\n    if (pixels > MAX_PIXELS) {\n      const k = Math.sqrt(MAX_PIXELS / pixels);\n      w = Math.round(w * k);\n      h = Math.round(h * k);\n    }\n    if (w < 64 || h < 64) return null;\n\n    try {\n      const roi = {\n        x: Math.round(rect.x),\n        y: Math.round(rect.y),\n        width: Math.round(rect.width),\n        height: Math.round(rect.height),\n      } as Rectangle;\n      const screen = { x: 0, y: 0, width: w, height: h } as Rectangle;\n      const bytes = await firstValueFrom(this.tileAccess.zoomOnRegion(roi, screen, 0));\n      if (!bytes || bytes.byteLength === 0) return null;\n\n      const bitmap = await createImageBitmap(new Blob([bytes]));\n      const canvas = document.createElement('canvas');\n      canvas.width = bitmap.width;\n      canvas.height = bitmap.height;\n      const ctx = canvas.getContext('2d');\n      if (!ctx) return null;\n      ctx.drawImage(bitmap, 0, 0);\n      // Read the dimensions BEFORE close(): closing an ImageBitmap zeroes its\n      // width/height, so returning them afterwards yields a 0x0 image with a\n      // full pixel buffer — inference then runs on nothing and finds nothing.\n      const width = bitmap.width;\n      const height = bitmap.height;\n      const out = ctx.getImageData(0, 0, width, height);\n      bitmap.close?.();\n      return { data: out.data, width, height };\n    } catch {\n      return null;\n    }\n  }\n\n  private makeRegion(xs: number[], ys: number[], className: string): Region {\n    const poly = new Polygon();\n    poly.npoints = xs.length;\n    poly.xpoints = xs;\n    poly.ypoints = ys;\n    poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n    poly.closed = true;\n\n    const region = new Region();\n    region.bounds = poly;\n    region.source = YOLO_REGION_SOURCE;\n    // The class name drives preset colour resolution; leaving `color` unset lets\n    // an existing preset for this class win.\n    region.label = className;\n    return region;\n  }\n}\n"]}