@jax-data-science/sci-image-visualizer 0.2.16 → 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"]}