@jax-data-science/sci-image-visualizer 0.2.7 → 0.2.9

package/esm2022/lib/toolbar/segmentation/yolo-model-registry.mjs

@@ -0,0 +1,99 @@
+/**
+ * Registry of YOLOv8-seg instance-segmentation models.
+ *
+ * Mirrors {@link SAM_MODELS}: public HF-hosted ONNX by default so the tool works
+ * out of the box in any host, repointable at private hosting via
+ * {@link setYoloModelUrls}.
+ *
+ * Each entry carries the per-model *defaults* the server-side worker uses for
+ * that checkpoint. These are properties of how the model was trained (object
+ * scale, expected crowding), not UI preferences — the embryo models want heavy
+ * 60% tile overlap and loose merge thresholds because their objects are large
+ * and touch, while the eye models were trained on sparse, downsampled fields.
+ * Keeping them here means a host that just picks a model gets sane behaviour
+ * without having to know any of that.
+ *
+ * Weights point at the `model.fp16w.onnx` variant deliberately. The `.fp16`
+ * variant accumulates in half precision on WebGPU and, at the x-scale these
+ * models use, produces materially wrong boxes; `fp16w` stores weights in fp16
+ * and computes in fp32, so it is half the download at identical accuracy.
+ *
+ * Export tooling: the sibling `browser-onnx-tools` project.
+ */
+const HF = 'https://huggingface.co/Ballon999';
+const EYE_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.5,
+    mergeThreshold: 0.3,
+    overlapX: 0,
+    overlapY: 0,
+};
+// Embryos are large, touch each other, and are imaged at native scale — hence
+// the heavy overlap and the far looser merge thresholds.
+const EMBRYO_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.8,
+    mergeThreshold: 0.8,
+    overlapX: 60,
+    overlapY: 60,
+};
+export const YOLO_MODELS = [
+    {
+        id: 'yolov8x-seg-opticnerve',
+        label: 'Optic nerve',
+        modelUrl: `${HF}/yolov8x-seg-opticnerve-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-retina',
+        label: 'Retina',
+        modelUrl: `${HF}/yolov8x-seg-retina-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m2',
+        label: 'Embryo (M2)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m2-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m3',
+        label: 'Embryo (M3)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m3-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+];
+export const DEFAULT_YOLO_MODEL_ID = 'yolov8x-seg-opticnerve';
+let defaultModelId = DEFAULT_YOLO_MODEL_ID;
+/** Look up a model definition by id. Returns undefined for an unknown id. */
+export function getYoloModel(id) {
+    return YOLO_MODELS.find((m) => m.id === id);
+}
+/** Whether a model has a usable weights URL configured. */
+export function isYoloModelReady(id) {
+    const m = getYoloModel(id);
+    return !!m && m.modelUrl.trim().length > 0;
+}
+/**
+ * Repoint a model at different hosting (e.g. a GCS bucket or a same-origin
+ * proxy). Call once at app init, before the first run. An empty `modelUrl`
+ * disables the model.
+ */
+export function setYoloModelUrls(id, urls) {
+    const m = getYoloModel(id);
+    if (!m)
+        return;
+    if (urls.modelUrl !== undefined)
+        m.modelUrl = urls.modelUrl;
+    if (urls.metaUrl !== undefined)
+        m.metaUrl = urls.metaUrl;
+}
+/** Change which model runs when a caller does not name one. */
+export function setDefaultYoloModel(id) {
+    if (getYoloModel(id))
+        defaultModelId = id;
+}
+export function getDefaultYoloModelId() {
+    return defaultModelId;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-model-registry.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-model-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAsBH,MAAM,EAAE,GAAG,kCAAkC,CAAC;AAE9C,MAAM,YAAY,GAAG;IACnB,UAAU,EAAE,GAAG;IACf,YAAY,EAAE,GAAG;IACjB,cAAc,EAAE,GAAG;IACnB,QAAQ,EAAE,CAAC;IACX,QAAQ,EAAE,CAAC;CACZ,CAAC;AAEF,8EAA8E;AAC9E,yDAAyD;AACzD,MAAM,eAAe,GAAG;IACtB,UAAU,EAAE,GAAG;IACf,YAAY,EAAE,GAAG;IACjB,cAAc,EAAE,GAAG;IACnB,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,EAAE;CACb,CAAC;AAEF,MAAM,CAAC,MAAM,WAAW,GAAmB;IACzC;QACE,EAAE,EAAE,wBAAwB;QAC5B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,4DAA4D;QAC3E,QAAQ,EAAE,EAAE,GAAG,YAAY,EAAE;KAC9B;IACD;QACE,EAAE,EAAE,oBAAoB;QACxB,KAAK,EAAE,QAAQ;QACf,QAAQ,EAAE,GAAG,EAAE,wDAAwD;QACvE,QAAQ,EAAE,EAAE,GAAG,YAAY,EAAE;KAC9B;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,2DAA2D;QAC1E,QAAQ,EAAE,EAAE,GAAG,eAAe,EAAE;KACjC;IACD;QACE,EAAE,EAAE,uBAAuB;QAC3B,KAAK,EAAE,aAAa;QACpB,QAAQ,EAAE,GAAG,EAAE,2DAA2D;QAC1E,QAAQ,EAAE,EAAE,GAAG,eAAe,EAAE;KACjC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,wBAAwB,CAAC;AAE9D,IAAI,cAAc,GAAG,qBAAqB,CAAC;AAE3C,6EAA6E;AAC7E,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AAC9C,CAAC;AAED,2DAA2D;AAC3D,MAAM,UAAU,gBAAgB,CAAC,EAAU;IACzC,MAAM,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAU,EAAE,IAA6C;IACxF,MAAM,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC;IAC3B,IAAI,CAAC,CAAC;QAAE,OAAO;IACf,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;QAAE,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAC5D,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;QAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;AAC3D,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,mBAAmB,CAAC,EAAU;IAC5C,IAAI,YAAY,CAAC,EAAE,CAAC;QAAE,cAAc,GAAG,EAAE,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["/**\n * Registry of YOLOv8-seg instance-segmentation models.\n *\n * Mirrors {@link SAM_MODELS}: public HF-hosted ONNX by default so the tool works\n * out of the box in any host, repointable at private hosting via\n * {@link setYoloModelUrls}.\n *\n * Each entry carries the per-model *defaults* the server-side worker uses for\n * that checkpoint. These are properties of how the model was trained (object\n * scale, expected crowding), not UI preferences — the embryo models want heavy\n * 60% tile overlap and loose merge thresholds because their objects are large\n * and touch, while the eye models were trained on sparse, downsampled fields.\n * Keeping them here means a host that just picks a model gets sane behaviour\n * without having to know any of that.\n *\n * Weights point at the `model.fp16w.onnx` variant deliberately. The `.fp16`\n * variant accumulates in half precision on WebGPU and, at the x-scale these\n * models use, produces materially wrong boxes; `fp16w` stores weights in fp16\n * and computes in fp32, so it is half the download at identical accuracy.\n *\n * Export tooling: the sibling `browser-onnx-tools` project.\n */\n\nexport interface YoloModelDef {\n  id: string;\n  label: string;\n  /** URL of the `.onnx` weights. Empty disables the model. */\n  modelUrl: string;\n  /**\n   * URL of the `model.json` sidecar. Omit to use `model.json` alongside the\n   * weights, which is how every published repo is laid out.\n   */\n  metaUrl?: string;\n  /** Per-model defaults, from the server worker's model table. */\n  defaults: {\n    confidence: number;\n    iouThreshold: number;\n    mergeThreshold: number;\n    overlapX: number;\n    overlapY: number;\n  };\n}\n\nconst HF = 'https://huggingface.co/Ballon999';\n\nconst EYE_DEFAULTS = {\n  confidence: 0.6,\n  iouThreshold: 0.5,\n  mergeThreshold: 0.3,\n  overlapX: 0,\n  overlapY: 0,\n};\n\n// Embryos are large, touch each other, and are imaged at native scale — hence\n// the heavy overlap and the far looser merge thresholds.\nconst EMBRYO_DEFAULTS = {\n  confidence: 0.6,\n  iouThreshold: 0.8,\n  mergeThreshold: 0.8,\n  overlapX: 60,\n  overlapY: 60,\n};\n\nexport const YOLO_MODELS: YoloModelDef[] = [\n  {\n    id: 'yolov8x-seg-opticnerve',\n    label: 'Optic nerve',\n    modelUrl: `${HF}/yolov8x-seg-opticnerve-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EYE_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-retina',\n    label: 'Retina',\n    modelUrl: `${HF}/yolov8x-seg-retina-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EYE_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-embryo-m2',\n    label: 'Embryo (M2)',\n    modelUrl: `${HF}/yolov8x-seg-embryo-m2-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EMBRYO_DEFAULTS },\n  },\n  {\n    id: 'yolov8x-seg-embryo-m3',\n    label: 'Embryo (M3)',\n    modelUrl: `${HF}/yolov8x-seg-embryo-m3-onnx/resolve/main/model.fp16w.onnx`,\n    defaults: { ...EMBRYO_DEFAULTS },\n  },\n];\n\nexport const DEFAULT_YOLO_MODEL_ID = 'yolov8x-seg-opticnerve';\n\nlet defaultModelId = DEFAULT_YOLO_MODEL_ID;\n\n/** Look up a model definition by id. Returns undefined for an unknown id. */\nexport function getYoloModel(id: string): YoloModelDef | undefined {\n  return YOLO_MODELS.find((m) => m.id === id);\n}\n\n/** Whether a model has a usable weights URL configured. */\nexport function isYoloModelReady(id: string): boolean {\n  const m = getYoloModel(id);\n  return !!m && m.modelUrl.trim().length > 0;\n}\n\n/**\n * Repoint a model at different hosting (e.g. a GCS bucket or a same-origin\n * proxy). Call once at app init, before the first run. An empty `modelUrl`\n * disables the model.\n */\nexport function setYoloModelUrls(id: string, urls: { modelUrl?: string; metaUrl?: string }): void {\n  const m = getYoloModel(id);\n  if (!m) return;\n  if (urls.modelUrl !== undefined) m.modelUrl = urls.modelUrl;\n  if (urls.metaUrl !== undefined) m.metaUrl = urls.metaUrl;\n}\n\n/** Change which model runs when a caller does not name one. */\nexport function setDefaultYoloModel(id: string): void {\n  if (getYoloModel(id)) defaultModelId = id;\n}\n\nexport function getDefaultYoloModelId(): string {\n  return defaultModelId;\n}\n"]}

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

@@ -0,0 +1,165 @@
+import { Injectable } from '@angular/core';
+import { getOrtWasmBase } from './ort-runtime-config';
+import { getDefaultYoloModelId, getYoloModel } from './yolo-model-registry';
+import * as i0 from "@angular/core";
+/**
+ * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js
+ * (YOLOv8-seg on WebGPU, falling back to WASM).
+ *
+ * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first
+ * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —
+ * in their initial bundle. This mirrors {@link CellposeSegmenterService}.
+ *
+ * The one structural difference from the Cellpose service: there are four YOLO
+ * checkpoints, not one, so instances are cached **per model id** rather than as
+ * a single singleton. Each entry owns its own worker and ORT session, so a host
+ * that switches models pays a second load but keeps the first one warm. Nothing
+ * evicts automatically — these are ~144 MB each, so a host that cycles through
+ * all four should call {@link dispose} for the ones it is done with.
+ */
+export class YoloSegmenterService {
+    constructor() {
+        this.instances = new Map();
+        this.loading = new Map();
+    }
+    async segmentInstances(image, opts = {}, progress) {
+        const modelId = opts.modelId ?? getDefaultYoloModelId();
+        const def = this.requireModel(modelId);
+        let announcedDownload = false;
+        const seg = await this.getModel(modelId, (loaded, total) => {
+            if (total)
+                progress?.onProgress?.(loaded / total);
+            if (loaded > 0 && !announcedDownload) {
+                announcedDownload = true;
+                progress?.onStatus?.(`Downloading ${def.label} model…`);
+            }
+        }, (status) => progress?.onStatus?.(status));
+        progress?.onStatus?.('Running inference…');
+        const result = await seg.segment({ data: image.data, width: image.width, height: image.height }, {
+            confThreshold: opts.confidence ?? def.defaults.confidence,
+            iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,
+            threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,
+            overlapX: opts.overlapX ?? def.defaults.overlapX,
+            overlapY: opts.overlapY ?? def.defaults.overlapY,
+            ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),
+            ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),
+            ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),
+            tracePolygons: true,
+            traceOptions: {
+                ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),
+                ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),
+            },
+            onTileProgress: (done, total) => progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Tracing outlines…'),
+        });
+        // Detections without geometry are dropped rather than surfaced as empty
+        // regions — a detection whose mask vanished under thresholding has nothing
+        // meaningful to draw or edit.
+        const detections = [];
+        for (const d of result.detections) {
+            if (!d.polygons || d.polygons.length === 0)
+                continue;
+            detections.push({
+                polygons: d.polygons.map((p) => ({
+                    exterior: p.exterior.map(([x, y]) => [x, y]),
+                    holes: p.holes.map((h) => h.map(([x, y]) => [x, y])),
+                })),
+                box: [d.box[0], d.box[1], d.box[2], d.box[3]],
+                score: d.score,
+                classId: d.classId,
+                className: d.className ?? `class${d.classId}`,
+            });
+        }
+        return {
+            detections,
+            width: result.width,
+            height: result.height,
+            classNames: result.classNames,
+        };
+    }
+    /**
+     * 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 drive richer `segment()` options on the same loaded
+     * session instead of loading the model twice.
+     */
+    getModel(modelId = getDefaultYoloModelId(), 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 yolo-segdetect-js + its ORT runtime out of the initial bundle.
+            const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');
+            configureOrt({ wasmPaths: getOrtWasmBase() });
+            const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {
+                preload: true,
+                ...(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 = getDefaultYoloModelId()) {
+        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, not just warm ones. Simply dropping the
+     * pending promise and returning would let the load finish afterwards,
+     * re-populate {@link instances}, and strand a live worker and ORT session that
+     * nothing owns — disposal would have reported success while leaking. So a load
+     * that is still running is awaited and then released.
+     */
+    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 in the
+        // meantime 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 = getYoloModel(modelId);
+        if (!def)
+            throw new Error(`Unknown YOLO model id "${modelId}".`);
+        if (!def.modelUrl.trim()) {
+            throw new Error(`YOLO model "${modelId}" is not configured — its modelUrl is empty.`);
+        }
+        return def;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"yolo-segmenter.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/yolo-segmenter.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { getOrtWasmBase } from './ort-runtime-config';\nimport { getDefaultYoloModelId, getYoloModel, type YoloModelDef } from './yolo-model-registry';\n\nimport type {\n  IInstanceSegmenter,\n  InstanceDetection,\n  InstanceSegmentation,\n  InstanceSegmentOptions,\n  InstanceSegmentProgress,\n} from '../../contracts/instance-segmenter.contract';\nimport type { YoloSegmenter } from 'yolo-segdetect-js';\n\n/**\n * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js\n * (YOLOv8-seg on WebGPU, falling back to WASM).\n *\n * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first\n * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —\n * in their initial bundle. This mirrors {@link CellposeSegmenterService}.\n *\n * The one structural difference from the Cellpose service: there are four YOLO\n * checkpoints, not one, so instances are cached **per model id** rather than as\n * a single singleton. Each entry owns its own worker and ORT session, so a host\n * that switches models pays a second load but keeps the first one warm. Nothing\n * evicts automatically — these are ~144 MB each, so a host that cycles through\n * all four should call {@link dispose} for the ones it is done with.\n */\n@Injectable({ providedIn: 'root' })\nexport class YoloSegmenterService implements IInstanceSegmenter {\n  private readonly instances = new Map<string, YoloSegmenter>();\n  private readonly loading = new Map<string, Promise<YoloSegmenter>>();\n\n  async segmentInstances(\n    image: { data: Uint8ClampedArray; width: number; height: number },\n    opts: InstanceSegmentOptions = {},\n    progress?: InstanceSegmentProgress,\n  ): Promise<InstanceSegmentation> {\n    const modelId = opts.modelId ?? getDefaultYoloModelId();\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        if (loaded > 0 && !announcedDownload) {\n          announcedDownload = true;\n          progress?.onStatus?.(`Downloading ${def.label} model…`);\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        confThreshold: opts.confidence ?? def.defaults.confidence,\n        iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,\n        threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,\n        overlapX: opts.overlapX ?? def.defaults.overlapX,\n        overlapY: opts.overlapY ?? def.defaults.overlapY,\n        ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),\n        ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),\n        ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),\n        tracePolygons: true,\n        traceOptions: {\n          ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),\n          ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),\n        },\n        onTileProgress: (done, total) =>\n          progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Tracing outlines…'),\n      },\n    );\n\n    // Detections without geometry are dropped rather than surfaced as empty\n    // regions — a detection whose mask vanished under thresholding has nothing\n    // meaningful to draw or edit.\n    const detections: InstanceDetection[] = [];\n    for (const d of result.detections) {\n      if (!d.polygons || d.polygons.length === 0) continue;\n      detections.push({\n        polygons: d.polygons.map((p) => ({\n          exterior: p.exterior.map(([x, y]): [number, number] => [x, y]),\n          holes: p.holes.map((h) => h.map(([x, y]): [number, number] => [x, y])),\n        })),\n        box: [d.box[0], d.box[1], d.box[2], d.box[3]],\n        score: d.score,\n        classId: d.classId,\n        className: d.className ?? `class${d.classId}`,\n      });\n    }\n\n    return {\n      detections,\n      width: result.width,\n      height: result.height,\n      classNames: result.classNames,\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 drive richer `segment()` options on the same loaded\n   * session instead of loading the model twice.\n   */\n  getModel(\n    modelId: string = getDefaultYoloModelId(),\n    onProgress?: (loaded: number, total: number | null) => void,\n    onStatus?: (status: string) => void,\n  ): Promise<YoloSegmenter> {\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 yolo-segdetect-js + its ORT runtime out of the initial bundle.\n      const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');\n      configureOrt({ wasmPaths: getOrtWasmBase() });\n      const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {\n        preload: true,\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 = getDefaultYoloModelId()): 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, not just warm ones. Simply dropping the\n   * pending promise and returning would let the load finish afterwards,\n   * re-populate {@link instances}, and strand a live worker and ORT session that\n   * nothing owns — disposal would have reported success while leaking. So a load\n   * that is still running is awaited and then released.\n   */\n  async dispose(modelId?: string): Promise<void> {\n    const ids = modelId ? [modelId] : [...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 in the\n    // meantime owns 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): YoloModelDef {\n    const def = getYoloModel(modelId);\n    if (!def) throw new Error(`Unknown YOLO model id \"${modelId}\".`);\n    if (!def.modelUrl.trim()) {\n      throw new Error(`YOLO model \"${modelId}\" is not configured — its modelUrl is empty.`);\n    }\n    return def;\n  }\n}\n"]}

package/fesm2022/jax-data-science-sci-image-visualizer.mjs

@@ -395,6 +395,276 @@ const CELL_SEGMENTER = new InjectionToken('CELL_SEGMENTER', {
     factory: () => inject(CellposeSegmenterService),
 });
 
+/**
+ * Registry of YOLOv8-seg instance-segmentation models.
+ *
+ * Mirrors {@link SAM_MODELS}: public HF-hosted ONNX by default so the tool works
+ * out of the box in any host, repointable at private hosting via
+ * {@link setYoloModelUrls}.
+ *
+ * Each entry carries the per-model *defaults* the server-side worker uses for
+ * that checkpoint. These are properties of how the model was trained (object
+ * scale, expected crowding), not UI preferences — the embryo models want heavy
+ * 60% tile overlap and loose merge thresholds because their objects are large
+ * and touch, while the eye models were trained on sparse, downsampled fields.
+ * Keeping them here means a host that just picks a model gets sane behaviour
+ * without having to know any of that.
+ *
+ * Weights point at the `model.fp16w.onnx` variant deliberately. The `.fp16`
+ * variant accumulates in half precision on WebGPU and, at the x-scale these
+ * models use, produces materially wrong boxes; `fp16w` stores weights in fp16
+ * and computes in fp32, so it is half the download at identical accuracy.
+ *
+ * Export tooling: the sibling `browser-onnx-tools` project.
+ */
+const HF = 'https://huggingface.co/Ballon999';
+const EYE_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.5,
+    mergeThreshold: 0.3,
+    overlapX: 0,
+    overlapY: 0,
+};
+// Embryos are large, touch each other, and are imaged at native scale — hence
+// the heavy overlap and the far looser merge thresholds.
+const EMBRYO_DEFAULTS = {
+    confidence: 0.6,
+    iouThreshold: 0.8,
+    mergeThreshold: 0.8,
+    overlapX: 60,
+    overlapY: 60,
+};
+const YOLO_MODELS = [
+    {
+        id: 'yolov8x-seg-opticnerve',
+        label: 'Optic nerve',
+        modelUrl: `${HF}/yolov8x-seg-opticnerve-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-retina',
+        label: 'Retina',
+        modelUrl: `${HF}/yolov8x-seg-retina-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EYE_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m2',
+        label: 'Embryo (M2)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m2-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+    {
+        id: 'yolov8x-seg-embryo-m3',
+        label: 'Embryo (M3)',
+        modelUrl: `${HF}/yolov8x-seg-embryo-m3-onnx/resolve/main/model.fp16w.onnx`,
+        defaults: { ...EMBRYO_DEFAULTS },
+    },
+];
+const DEFAULT_YOLO_MODEL_ID = 'yolov8x-seg-opticnerve';
+let defaultModelId = DEFAULT_YOLO_MODEL_ID;
+/** Look up a model definition by id. Returns undefined for an unknown id. */
+function getYoloModel(id) {
+    return YOLO_MODELS.find((m) => m.id === id);
+}
+/** Whether a model has a usable weights URL configured. */
+function isYoloModelReady(id) {
+    const m = getYoloModel(id);
+    return !!m && m.modelUrl.trim().length > 0;
+}
+/**
+ * Repoint a model at different hosting (e.g. a GCS bucket or a same-origin
+ * proxy). Call once at app init, before the first run. An empty `modelUrl`
+ * disables the model.
+ */
+function setYoloModelUrls(id, urls) {
+    const m = getYoloModel(id);
+    if (!m)
+        return;
+    if (urls.modelUrl !== undefined)
+        m.modelUrl = urls.modelUrl;
+    if (urls.metaUrl !== undefined)
+        m.metaUrl = urls.metaUrl;
+}
+/** Change which model runs when a caller does not name one. */
+function setDefaultYoloModel(id) {
+    if (getYoloModel(id))
+        defaultModelId = id;
+}
+function getDefaultYoloModelId() {
+    return defaultModelId;
+}
+
+/**
+ * Default in-library {@link IInstanceSegmenter}, backed by yolo-segdetect-js
+ * (YOLOv8-seg on WebGPU, falling back to WASM).
+ *
+ * `yolo-segdetect-js` is a regular dependency but is **lazy-imported** on first
+ * use, so apps that never run YOLO pay nothing for it — or for onnxruntime-web —
+ * in their initial bundle. This mirrors {@link CellposeSegmenterService}.
+ *
+ * The one structural difference from the Cellpose service: there are four YOLO
+ * checkpoints, not one, so instances are cached **per model id** rather than as
+ * a single singleton. Each entry owns its own worker and ORT session, so a host
+ * that switches models pays a second load but keeps the first one warm. Nothing
+ * evicts automatically — these are ~144 MB each, so a host that cycles through
+ * all four should call {@link dispose} for the ones it is done with.
+ */
+class YoloSegmenterService {
+    constructor() {
+        this.instances = new Map();
+        this.loading = new Map();
+    }
+    async segmentInstances(image, opts = {}, progress) {
+        const modelId = opts.modelId ?? getDefaultYoloModelId();
+        const def = this.requireModel(modelId);
+        let announcedDownload = false;
+        const seg = await this.getModel(modelId, (loaded, total) => {
+            if (total)
+                progress?.onProgress?.(loaded / total);
+            if (loaded > 0 && !announcedDownload) {
+                announcedDownload = true;
+                progress?.onStatus?.(`Downloading ${def.label} model…`);
+            }
+        }, (status) => progress?.onStatus?.(status));
+        progress?.onStatus?.('Running inference…');
+        const result = await seg.segment({ data: image.data, width: image.width, height: image.height }, {
+            confThreshold: opts.confidence ?? def.defaults.confidence,
+            iouThreshold: opts.iouThreshold ?? def.defaults.iouThreshold,
+            threshold: opts.mergeThreshold ?? def.defaults.mergeThreshold,
+            overlapX: opts.overlapX ?? def.defaults.overlapX,
+            overlapY: opts.overlapY ?? def.defaults.overlapY,
+            ...(opts.maskThreshold !== undefined ? { maskThreshold: opts.maskThreshold } : {}),
+            ...(opts.maxDetections !== undefined ? { maxDetections: opts.maxDetections } : {}),
+            ...(opts.classFilter ? { classFilter: opts.classFilter } : {}),
+            tracePolygons: true,
+            traceOptions: {
+                ...(opts.simplifyTolerance !== undefined ? { simplifyTolerance: opts.simplifyTolerance } : {}),
+                ...(opts.minArea !== undefined ? { minArea: opts.minArea } : {}),
+            },
+            onTileProgress: (done, total) => progress?.onStatus?.(done < total ? `Running inference (tile ${done}/${total})…` : 'Tracing outlines…'),
+        });
+        // Detections without geometry are dropped rather than surfaced as empty
+        // regions — a detection whose mask vanished under thresholding has nothing
+        // meaningful to draw or edit.
+        const detections = [];
+        for (const d of result.detections) {
+            if (!d.polygons || d.polygons.length === 0)
+                continue;
+            detections.push({
+                polygons: d.polygons.map((p) => ({
+                    exterior: p.exterior.map(([x, y]) => [x, y]),
+                    holes: p.holes.map((h) => h.map(([x, y]) => [x, y])),
+                })),
+                box: [d.box[0], d.box[1], d.box[2], d.box[3]],
+                score: d.score,
+                classId: d.classId,
+                className: d.className ?? `class${d.classId}`,
+            });
+        }
+        return {
+            detections,
+            width: result.width,
+            height: result.height,
+            classNames: result.classNames,
+        };
+    }
+    /**
+     * 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 drive richer `segment()` options on the same loaded
+     * session instead of loading the model twice.
+     */
+    getModel(modelId = getDefaultYoloModelId(), 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 yolo-segdetect-js + its ORT runtime out of the initial bundle.
+            const { YoloSegmenter, configureOrt } = await import('yolo-segdetect-js');
+            configureOrt({ wasmPaths: getOrtWasmBase() });
+            const seg = await YoloSegmenter.fromPretrained(def.modelUrl, {
+                preload: true,
+                ...(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 = getDefaultYoloModelId()) {
+        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, not just warm ones. Simply dropping the
+     * pending promise and returning would let the load finish afterwards,
+     * re-populate {@link instances}, and strand a live worker and ORT session that
+     * nothing owns — disposal would have reported success while leaking. So a load
+     * that is still running is awaited and then released.
+     */
+    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 in the
+        // meantime 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 = getYoloModel(modelId);
+        if (!def)
+            throw new Error(`Unknown YOLO model id "${modelId}".`);
+        if (!def.modelUrl.trim()) {
+            throw new Error(`YOLO model "${modelId}" is not configured — its modelUrl is empty.`);
+        }
+        return def;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: YoloSegmenterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/**
+ * DI token for the automatic instance segmenter. Defaults to the in-library
+ * {@link YoloSegmenterService} (yolo-segdetect-js, lazy-loaded); override it in
+ * the host to swap implementations — for example to delegate to the server.
+ */
+const INSTANCE_SEGMENTER = new InjectionToken('INSTANCE_SEGMENTER', {
+    providedIn: 'root',
+    factory: () => inject(YoloSegmenterService),
+});
+
 /**
  * Unified image container used throughout the processing pipeline.
  * Decouples pipeline logic from any specific library's image format.
@@ -16392,14 +16662,29 @@ class OpenSeadragonVisualizerService extends BaseStoreVisualizer {
             // crisp nearest-neighbour blocks).
             minZoomImageRatio: 0.01,
             maxZoomPixelRatio: 20,
-            // Switch to a finer pyramid level as soon as the current one would be
-            // upscaled at all. OSD's default (0.5) tolerates displaying a level at up
-            // to 2x magnification before fetching the next, which reads as a soft
-            // image that abruptly sharpens when the threshold is crossed. At 1 the
-            // displayed level always has at least one tile pixel per screen pixel, so
-            // the only visible pixellation is past 1:1 - where the blocks are genuine
-            // source pixels (paired with imageSmoothingEnabled=false).
-            minPixelRatio: 1,
+            // OSD's stock value, restored. DO NOT RAISE IT: the name reads like
+            // "minimum sharpness" but it is the opposite. From OSD's own
+            // TiledImage._getLevelsInterval:
+            //
+            //   highestLevel = floor( log2( currentZeroRatio / minPixelRatio ) )
+            //
+            // minPixelRatio is a floor on how small a tile pixel may shrink, and it
+            // DIVIDES into the ratio - so raising it lowers the chosen level, i.e.
+            // picks a COARSER image. OSD's own comment on the default says as much:
+            // "closer to 0 draws tiles meant for a higher zoom at this zoom".
+            //
+            // Measured on a flat 22304x24528 image (levels 697/1394/2788/5576/11152/
+            // 22304), predicted level matching actual in all nine trials:
+            //
+            //            zoom 2        zoom 8        ~1:1
+            //   1.0      1.34x up      1.34x up      1.86x up
+            //   0.5      0.67x (none)  0.67x (none)  0.93x -> full res
+            //   0.25     0.33x         0.33x         0.93x
+            //
+            // 0.5 is what gives "never upscaled below native, full resolution at 1:1".
+            // 0.25 is not better - it jumps two rungs finer and fetches ~4x the tiles
+            // for no visible gain, and tiles are not cached by the ingress.
+            minPixelRatio: 0.5,
             // Wait for the view to settle before pulling new tiles (less churn).
             immediateRender: false,
             animationTime: 0.4,
@@ -21769,5 +22054,5 @@ function provideVisualization() {
  * Generated bundle index. Do not edit.
  */
 
-export { ALL_TOOLBAR_TOOLS, CELL_SEGMENTER, CHANNEL_HISTOGRAM_API, CellposeSegmenterService, ChannelHistogramComponent, DEFAULT_FALLBACK_PALETTE, DEFAULT_SAM_MODEL_ID, HexColorPickerComponent, IMAGE_STATE_PORT, ImageConverterService, LUT_COLORS, MultiPolygon, NAPARI_DECIMATE_OPTIONS, NAPARI_DEFAULT_DECIMATE, PLOT_TYPE_DESCRIPTORS, PREFERENCES_PORT, PlotType, Polygon, ProcessingImage, REGION_EDITOR_API, REGION_IO_PORT, Rectangle, Region, RegionEditorComponent, RoutingVisualizerService, SAM_MODELS, ShapeSelection, TILE_ACCESS_PORT, VISUALIZER, VIZ_CONFIG, ViewerFeature, VisualizationModule, VisualizerComponent, capabilitiesOf, cropImage, defaultPresetSet, getDefaultSamModelId, getOrtWasmBase, getPlotTypeDescriptor, getSamModel, isEmptyPresetSet, isNapari3d, isNapariIsosurface, isNapariScatter, isNapariScatter3d, isNapariSurface, isNapariVolume, isSamModelReady, isThreeDimensional, provideVisualization, setDefaultSamModel, setOrtWasmBase, setSamModelUrls };
+export { ALL_TOOLBAR_TOOLS, CELL_SEGMENTER, CHANNEL_HISTOGRAM_API, CellposeSegmenterService, ChannelHistogramComponent, DEFAULT_FALLBACK_PALETTE, DEFAULT_SAM_MODEL_ID, DEFAULT_YOLO_MODEL_ID, HexColorPickerComponent, IMAGE_STATE_PORT, INSTANCE_SEGMENTER, ImageConverterService, LUT_COLORS, MultiPolygon, NAPARI_DECIMATE_OPTIONS, NAPARI_DEFAULT_DECIMATE, PLOT_TYPE_DESCRIPTORS, PREFERENCES_PORT, PlotType, Polygon, ProcessingImage, REGION_EDITOR_API, REGION_IO_PORT, Rectangle, Region, RegionEditorComponent, RoutingVisualizerService, SAM_MODELS, ShapeSelection, TILE_ACCESS_PORT, VISUALIZER, VIZ_CONFIG, ViewerFeature, VisualizationModule, VisualizerComponent, YOLO_MODELS, YoloSegmenterService, capabilitiesOf, cropImage, defaultPresetSet, getDefaultSamModelId, getDefaultYoloModelId, getOrtWasmBase, getPlotTypeDescriptor, getSamModel, getYoloModel, isEmptyPresetSet, isNapari3d, isNapariIsosurface, isNapariScatter, isNapariScatter3d, isNapariSurface, isNapariVolume, isSamModelReady, isThreeDimensional, isYoloModelReady, provideVisualization, setDefaultSamModel, setDefaultYoloModel, setOrtWasmBase, setSamModelUrls, setYoloModelUrls };
 //# sourceMappingURL=jax-data-science-sci-image-visualizer.mjs.map