@jax-data-science/sci-image-visualizer 0.2.16 → 0.2.18

package/index.d.ts

@@ -25,11 +25,15 @@ export { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-se
 export * from './lib/contracts/instance-segmenter.contract';
 export { YoloSegmenterService } from './lib/toolbar/segmentation/yolo-segmenter.service';
 export { YoloDetectToolService, YOLO_REGION_SOURCE } from './lib/toolbar/segmentation/yolo-detect-tool.service';
+export * from './lib/contracts/semantic-segmenter.contract';
+export { RetinalSegmenterService } from './lib/toolbar/segmentation/retinal-segmenter.service';
+export { RetinalLayerToolService, RETINAL_REGION_SOURCE, } from './lib/toolbar/segmentation/retinal-layer-tool.service';
 export { ProcessingImage } from './lib/processing/processing-image';
 export { cropImage, CropImageOptions } from './lib/processing/image-crop';
 export { ImageConverterService } from './lib/processing/image-converter.service';
 export { SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls, setDefaultSamModel, getDefaultSamModelId, } from './lib/toolbar/segmentation/sam-model-registry';
 export { YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls, setDefaultYoloModel, getDefaultYoloModelId, YoloModelDef, } from './lib/toolbar/segmentation/yolo-model-registry';
+export { RETINAL_MODELS, DEFAULT_RETINAL_MODEL_ID, getRetinalModel, isRetinalModelReady, readyRetinalModels, setRetinalModelUrls, setDefaultRetinalModel, getDefaultRetinalModelId, RetinalModelDef, } from './lib/toolbar/segmentation/retinal-model-registry';
 export { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';
 export * from './lib/models/region';
 export * from './lib/models/class-preset';

package/lib/contracts/semantic-segmenter.contract.d.ts

@@ -0,0 +1,105 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * Port for a **semantic** segmenter — one that assigns every pixel a class from
+ * a fixed set, with no notion of separate objects.
+ *
+ * The third sibling of {@link ICellSegmenter} and {@link IInstanceSegmenter},
+ * and genuinely a different shape from both. Cellpose separates touching
+ * instances of one class; YOLO returns overlapping classified objects; this
+ * returns *layers* — regions that tile the image, never overlap, and where two
+ * disconnected patches of the same class are the same finding rather than two
+ * objects. There is no confidence per object and no NMS, because there are no
+ * objects.
+ *
+ * Results are delivered as polygon rings in **image pixels**, so a caller can
+ * build {@link Region}s directly — the same currency the other two ports use.
+ */
+/** A closed ring; the last point is NOT a repeat of the first. */
+export type SemanticRing = Array<[number, number]>;
+/** One connected component of one class, with any interior voids. */
+export interface SemanticRegion {
+    exterior: SemanticRing;
+    holes: SemanticRing[];
+    classId: number;
+    className: string;
+    /** Area in pixels, holes already subtracted. */
+    area: number;
+}
+export interface SemanticSegmentation {
+    regions: SemanticRegion[];
+    /** Total pixels assigned to each class, indexed by class id. */
+    classAreas: number[];
+    /** Class names indexed by class id, from the model's own metadata. */
+    classNames: string[];
+    width: number;
+    height: number;
+    /**
+     * Fraction of pixels that met no class's threshold.
+     *
+     * Worth surfacing rather than discarding: these models are thresholded per
+     * class rather than argmaxed, so a high value means the model was unsure
+     * everywhere — which is the signature of wrong preprocessing (wrong input
+     * scale, wrong greyscale) long before the polygons look obviously wrong.
+     */
+    unassignedFraction: number;
+}
+export interface SemanticSegmentOptions {
+    /** Which registered model to run. Defaults to the registry's default. */
+    modelId?: string;
+    /**
+     * Scale to run at, as a divisor of full resolution — the same meaning the
+     * server gives it.
+     *
+     * Matters as much here as for a detector: these checkpoints were trained on
+     * 40x or 20x patches, and a layer imaged at the wrong scale does not look
+     * like the layer the model learned.
+     */
+    downsamplingFactor?: number;
+    /**
+     * Minimum probability for a pixel to be assigned to a class, default 0.5.
+     *
+     * Not a plain argmax. The reference worker thresholds each class channel
+     * independently at 0.5; because the model's last layer is a softmax at most
+     * one class can clear that, so this is argmax *plus a confidence floor* —
+     * pixels where the winner is weak are left unassigned rather than forced into
+     * the best of a bad set. Lowering it toward 0.25 approaches a true argmax and
+     * visibly fattens every layer.
+     */
+    classThreshold?: number;
+    /** Keep only these class ids; omit for everything except background. */
+    classFilter?: number[];
+    /** Douglas-Peucker tolerance in pixels for outline simplification; 0 disables. */
+    simplifyTolerance?: number;
+    /** Drop regions whose area is below this, in square pixels. */
+    minArea?: number;
+    /**
+     * Cooperative cancellation, checked at patch boundaries — so it takes effect
+     * within roughly one patch rather than instantly.
+     */
+    signal?: AbortSignal;
+}
+/** Progress/status callbacks (all optional). Mirrors {@link InstanceSegmentProgress}. */
+export interface SemanticSegmentProgress {
+    /** Model-download progress, 0..1 (first run only). */
+    onProgress?: (fraction: number) => void;
+    /**
+     * Raw download byte counts, for hosts that render a size rather than a bare
+     * percentage. `total` is null when the response carried no Content-Length.
+     */
+    onBytes?: (loaded: number, total: number | null) => void;
+    /** Human-readable phase, e.g. 'Segmenting patch 3/8…'. */
+    onStatus?: (status: string) => void;
+}
+export interface ISemanticSegmenter {
+    /** Assign every pixel a class and return the resulting regions. */
+    segmentSemantic(image: {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+    }, opts?: SemanticSegmentOptions, progress?: SemanticSegmentProgress): Promise<SemanticSegmentation>;
+}
+/**
+ * DI token for the semantic segmenter, defaulting to the in-library
+ * jax-ai-js-backed implementation. Hosts override it to supply their own.
+ */
+export declare const SEMANTIC_SEGMENTER: InjectionToken<ISemanticSegmenter>;

package/lib/toolbar/segmentation/retinal-layer-tool.service.d.ts

@@ -0,0 +1,49 @@
+import { BehaviorSubject } from 'rxjs';
+import { type TileAccessPort } from '../../contracts/ports/tile-access.port';
+import type { IVisualizer } from '../../contracts/visualizer.contract';
+import type { ISemanticSegmenter, SemanticSegmentOptions } from '../../contracts/semantic-segmenter.contract';
+import * as i0 from "@angular/core";
+/** Marks regions this tool produced, so a re-run can replace only its own. */
+export declare const RETINAL_REGION_SOURCE = "retinal-layer";
+/**
+ * Retinal-layer segmentation over the current view.
+ *
+ * Sibling of {@link YoloDetectToolService}, and structured the same way: run on
+ * whatever is on screen, map the results onto full-image coordinates through
+ * the viewer's source rect, and commit them as regions. The difference is what
+ * comes back — layers that tile the field rather than discrete objects, so
+ * every region is one connected component of one layer and there is no
+ * per-object confidence to filter on.
+ *
+ * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose and
+ * YOLO tools so the host's shared segmentation toast drives it unchanged.
+ */
+export declare class RetinalLayerToolService {
+    /** Server-side crop, so segmentation can run at the model's scale rather
+     *  than the viewer's. Optional: without it the tool falls back to the
+     *  displayed pixels, which is correct but scale-dependent. */
+    private tileAccess;
+    readonly status$: BehaviorSubject<string>;
+    readonly busy$: BehaviorSubject<boolean>;
+    readonly progress$: BehaviorSubject<number>;
+    constructor(
+    /** Server-side crop, so segmentation can run at the model's scale rather
+     *  than the viewer's. Optional: without it the tool falls back to the
+     *  displayed pixels, which is correct but scale-dependent. */
+    tileAccess?: TileAccessPort | null);
+    /**
+     * Segment the current view and commit the layers as regions.
+     *
+     * @returns the number of regions added.
+     */
+    segmentInView(viz: IVisualizer, segmenter: ISemanticSegmenter, opts?: SemanticSegmentOptions): Promise<number>;
+    /**
+     * Re-crop `rect` at `1/target` of full resolution. Returns null on any
+     * failure, so the caller falls back to the displayed pixels — a coarser crop
+     * beats a failed run.
+     */
+    private fetchCropAtScale;
+    private makeRegion;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RetinalLayerToolService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RetinalLayerToolService>;
+}

package/lib/toolbar/segmentation/retinal-model-registry.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Registry of retinal-layer semantic-segmentation models.
+ *
+ * Mirrors {@link YOLO_MODELS}: public HF-hosted ONNX by default, repointable at
+ * private hosting via {@link setRetinalModelUrls}.
+ *
+ * ONLY ONE CHECKPOINT IS ENABLED, AND THAT IS DELIBERATE
+ * The server offers four. Measured against the ground-truth masks shipped
+ * alongside them, only VNet reproduces them:
+ *
+ * | checkpoint | mIoU |
+ * |---|---|
+ * | **VNet 2D** | **0.9061** |
+ * | ResUNet-a 2D (base) | 0.3065 |
+ * | ResUNet-a 2D 20x | 0.2869 |
+ * | ResUNet-a 2D 40x | 0.2718 |
+ *
+ * The ResUNet-a numbers are not quantization damage — their ONNX exports match
+ * their own Keras originals exactly. They disagree with the *masks*, folding
+ * ground-truth class 1 into their class 2 and class 3 into background, and no
+ * relabelling rescues them (the best of all 24 class permutations reaches only
+ * 0.36). Either those masks belong to a different model generation or the class
+ * definitions moved — an open question for whoever trained them.
+ *
+ * So their weights stay unpublished (their Hub repos are private) and their
+ * entries here carry an empty `modelUrl`, which {@link isRetinalModelReady}
+ * reports as not-ready. They are listed rather than deleted so a host shows
+ * them as unavailable-in-browser instead of pretending the server's choice does
+ * not exist — and so enabling one later is a URL, not a code change.
+ *
+ * Export tooling: the sibling `browser-onnx-tools` project.
+ */
+export interface RetinalModelDef {
+    id: string;
+    label: string;
+    /** URL of the `.onnx` weights. **Empty disables the model.** */
+    modelUrl: string;
+    /**
+     * URL of the `model.json` sidecar. Omit to use `model.json` alongside the
+     * weights, which is how every published repo is laid out.
+     */
+    metaUrl?: string;
+    /** Patch size the checkpoint was trained at, for callers that size reads to it. */
+    patchSize: number;
+    /** Download size of the `fp16w` weights, MB — these are large enough to warn about. */
+    sizeMb: number;
+    /** Measured mIoU against the bucket's ground-truth masks. */
+    miou: number;
+    /** Set when the model is knowingly disabled; shown to the user. */
+    unavailableReason?: string;
+}
+export declare const RETINAL_MODELS: RetinalModelDef[];
+export declare const DEFAULT_RETINAL_MODEL_ID = "vnet-2d-retinal";
+/** Look up a model definition by id. Returns undefined for an unknown id. */
+export declare function getRetinalModel(id: string): RetinalModelDef | undefined;
+/** Whether a model has usable weights configured. */
+export declare function isRetinalModelReady(id: string): boolean;
+/** Only the models a browser can actually run. */
+export declare function readyRetinalModels(): RetinalModelDef[];
+/**
+ * Repoint a model at different hosting (a GCS bucket, a same-origin proxy), or
+ * enable one of the disabled entries. Call once at app init, before first use.
+ * An empty `modelUrl` disables the model.
+ */
+export declare function setRetinalModelUrls(id: string, urls: {
+    modelUrl?: string;
+    metaUrl?: string;
+}): void;
+/** Change which model runs when a caller does not name one. */
+export declare function setDefaultRetinalModel(id: string): void;
+export declare function getDefaultRetinalModelId(): string;

package/lib/toolbar/segmentation/retinal-segmenter.service.d.ts

@@ -0,0 +1,60 @@
+import type { ISemanticSegmenter, SemanticSegmentation, SemanticSegmentOptions, SemanticSegmentProgress } from '../../contracts/semantic-segmenter.contract';
+import type { RetinalSegmenter } from 'jax-ai-js';
+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 declare class RetinalSegmenterService implements ISemanticSegmenter {
+    private readonly instances;
+    private readonly loading;
+    segmentSemantic(image: {
+        data: Uint8ClampedArray;
+        width: number;
+        height: number;
+    }, opts?: SemanticSegmentOptions, progress?: SemanticSegmentProgress): Promise<SemanticSegmentation>;
+    /**
+     * 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?: string, onProgress?: (loaded: number, total: number | null) => void, onStatus?: (status: string) => void, 
+    /**
+     * Abort the load. This model is ~590 MB, so a cancel has to reach the
+     * *download* — aborting only the inference that follows leaves the transfer
+     * running and the UI stuck in "Cancelling" until it completes.
+     *
+     * Deliberately not applied to a load already in flight: that promise may be
+     * shared with another caller (the toolbar tool and the pipeline both use
+     * this service), and one caller's cancel must not tear the model out from
+     * under the other. A second caller joining an in-flight load simply waits.
+     */
+    signal?: AbortSignal): Promise<RetinalSegmenter>;
+    /** Whether a model is already loaded (warm). */
+    isLoaded(modelId?: string): boolean;
+    /**
+     * 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.
+     */
+    dispose(modelId?: string): Promise<void>;
+    private disposeOne;
+    private requireModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RetinalSegmenterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RetinalSegmenterService>;
+}

package/lib/toolbar/toolbar.component.d.ts

@@ -72,6 +72,12 @@ export declare class ToolbarComponent implements OnChanges {
         label: string;
     }[];
     yoloModelId: string;
+    /** Retinal-layer checkpoints offered by the host's registry, and the active one. */
+    retinalModels: {
+        id: string;
+        label: string;
+    }[];
+    retinalModelId: string;
     selectPlotType: EventEmitter<PlotType>;
     /** Intensity (LINE) mode: add another colored line ROI + inset trace. */
     addProfileLine: EventEmitter<void>;
@@ -117,6 +123,12 @@ export declare class ToolbarComponent implements OnChanges {
     yoloModelChange: EventEmitter<string>;
     /** Open the YOLO parameter dialog. */
     openYoloParams: EventEmitter<void>;
+    /** Run retinal-layer segmentation over the current view. */
+    segmentRetinal: EventEmitter<void>;
+    /** Pick the retinal-layer checkpoint. */
+    retinalModelChange: EventEmitter<string>;
+    /** Open the retinal-layer parameter dialog. */
+    openRetinalParams: EventEmitter<void>;
     /** SAM model picker (jit-ui#90 P1). */
     samModelChange: EventEmitter<string>;
     wandSensitivityChange: EventEmitter<number | undefined>;
@@ -147,6 +159,8 @@ export declare class ToolbarComponent implements OnChanges {
     samMenuItems: MenuItem[];
     /** Same stable-array reasoning as {@link samMenuItems}. */
     yoloMenuItems: MenuItem[];
+    /** Same stable-array reasoning as {@link samMenuItems}. */
+    retinalMenuItems: MenuItem[];
     /** Rebuild the SAM model menu when the model list or active selection
      *  changes (keeps the array reference stable across other CD ticks). */
     ngOnChanges(changes: SimpleChanges): void;
@@ -177,5 +191,5 @@ export declare class ToolbarComponent implements OnChanges {
     get isIntensityCapable(): boolean;
     showHelp(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "plotting-toolbar", never, { "imageInfo": { "alias": "imageInfo"; "required": false; }; "plotTypeOptions": { "alias": "plotTypeOptions"; "required": false; }; "selectedPlotType": { "alias": "selectedPlotType"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "activeSurface3dMode": { "alias": "activeSurface3dMode"; "required": false; }; "axesVisible": { "alias": "axesVisible"; "required": false; }; "wireframeActive": { "alias": "wireframeActive"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; "wandSensitivity": { "alias": "wandSensitivity"; "required": false; }; "brushSize": { "alias": "brushSize"; "required": false; }; "vertexEraserRadius": { "alias": "vertexEraserRadius"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; "stackOptions": { "alias": "stackOptions"; "required": false; }; "tools": { "alias": "tools"; "required": false; }; "imageSmoothingEnabled": { "alias": "imageSmoothingEnabled"; "required": false; }; "samModels": { "alias": "samModels"; "required": false; }; "samModelId": { "alias": "samModelId"; "required": false; }; "yoloModels": { "alias": "yoloModels"; "required": false; }; "yoloModelId": { "alias": "yoloModelId"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "addProfileLine": "addProfileLine"; "toggleImageSmoothing": "toggleImageSmoothing"; "isoRangeChange": "isoRangeChange"; "openChannelHistogram": "openChannelHistogram"; "openRegionEditor": "openRegionEditor"; "selectStackOption": "selectStackOption"; "zScrub": "zScrub"; "zSlide": "zSlide"; "zIndexInput": "zIndexInput"; "reloadAndPlot": "reloadAndPlot"; "downloadImage": "downloadImage"; "autoscaleImage": "autoscaleImage"; "toggleDragMode": "toggleDragMode"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "toggleSurface3dMode": "toggleSurface3dMode"; "resetSurfaceCamera": "resetSurfaceCamera"; "toggleAxes": "toggleAxes"; "toggleWireframe": "toggleWireframe"; "selectResolution": "selectResolution"; "deleteRegion": "deleteRegion"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "segmentRegions": "segmentRegions"; "segmentCellpose": "segmentCellpose"; "detectYolo": "detectYolo"; "yoloModelChange": "yoloModelChange"; "openYoloParams": "openYoloParams"; "samModelChange": "samModelChange"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, ["*"], false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "plotting-toolbar", never, { "imageInfo": { "alias": "imageInfo"; "required": false; }; "plotTypeOptions": { "alias": "plotTypeOptions"; "required": false; }; "selectedPlotType": { "alias": "selectedPlotType"; "required": false; }; "isoRange": { "alias": "isoRange"; "required": false; }; "maxIndex": { "alias": "maxIndex"; "required": false; }; "zIndex": { "alias": "zIndex"; "required": false; }; "isHeatmap": { "alias": "isHeatmap"; "required": false; }; "activeDragMode": { "alias": "activeDragMode"; "required": false; }; "activeSurface3dMode": { "alias": "activeSurface3dMode"; "required": false; }; "axesVisible": { "alias": "axesVisible"; "required": false; }; "wireframeActive": { "alias": "wireframeActive"; "required": false; }; "resolutionScale": { "alias": "resolutionScale"; "required": false; }; "wandSensitivity": { "alias": "wandSensitivity"; "required": false; }; "brushSize": { "alias": "brushSize"; "required": false; }; "vertexEraserRadius": { "alias": "vertexEraserRadius"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; "stackOptions": { "alias": "stackOptions"; "required": false; }; "tools": { "alias": "tools"; "required": false; }; "imageSmoothingEnabled": { "alias": "imageSmoothingEnabled"; "required": false; }; "samModels": { "alias": "samModels"; "required": false; }; "samModelId": { "alias": "samModelId"; "required": false; }; "yoloModels": { "alias": "yoloModels"; "required": false; }; "yoloModelId": { "alias": "yoloModelId"; "required": false; }; "retinalModels": { "alias": "retinalModels"; "required": false; }; "retinalModelId": { "alias": "retinalModelId"; "required": false; }; }, { "selectPlotType": "selectPlotType"; "addProfileLine": "addProfileLine"; "toggleImageSmoothing": "toggleImageSmoothing"; "isoRangeChange": "isoRangeChange"; "openChannelHistogram": "openChannelHistogram"; "openRegionEditor": "openRegionEditor"; "selectStackOption": "selectStackOption"; "zScrub": "zScrub"; "zSlide": "zSlide"; "zIndexInput": "zIndexInput"; "reloadAndPlot": "reloadAndPlot"; "downloadImage": "downloadImage"; "autoscaleImage": "autoscaleImage"; "toggleDragMode": "toggleDragMode"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "toggleSurface3dMode": "toggleSurface3dMode"; "resetSurfaceCamera": "resetSurfaceCamera"; "toggleAxes": "toggleAxes"; "toggleWireframe": "toggleWireframe"; "selectResolution": "selectResolution"; "deleteRegion": "deleteRegion"; "undoRegion": "undoRegion"; "redoRegion": "redoRegion"; "segmentRegions": "segmentRegions"; "segmentCellpose": "segmentCellpose"; "detectYolo": "detectYolo"; "yoloModelChange": "yoloModelChange"; "openYoloParams": "openYoloParams"; "segmentRetinal": "segmentRetinal"; "retinalModelChange": "retinalModelChange"; "openRetinalParams": "openRetinalParams"; "samModelChange": "samModelChange"; "wandSensitivityChange": "wandSensitivityChange"; "brushSizeChange": "brushSizeChange"; "vertexEraserRadiusChange": "vertexEraserRadiusChange"; }, never, ["*"], false, never>;
 }

package/lib/visualizer.component.d.ts

@@ -14,6 +14,8 @@ import { SamPointToolService } from './toolbar/segmentation/sam-point-tool.servi
 import { CellSegmentToolService } from './toolbar/segmentation/cell-segment-tool.service';
 import { YoloDetectToolService } from './toolbar/segmentation/yolo-detect-tool.service';
 import type { IInstanceSegmenter, InstanceSegmentOptions } from './contracts/instance-segmenter.contract';
+import { RetinalLayerToolService } from './toolbar/segmentation/retinal-layer-tool.service';
+import type { ISemanticSegmenter, SemanticSegmentOptions } from './contracts/semantic-segmenter.contract';
 import { ToolbarToolVisibility } from './contracts/toolbar-config';
 import { VizConfig } from './contracts/viz-config';
 import * as i0 from "@angular/core";
@@ -28,6 +30,8 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
     private cellSegmentTool;
     private yoloDetectTool;
     private instanceSegmenter;
+    private semanticSegmenter;
+    private retinalLayerTool;
     private samPointTool;
     private regionOps;
     private vizConfig?;
@@ -137,6 +141,18 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      *  encode the scale and crowding each checkpoint was trained for. */
     showYoloParams: boolean;
     yoloParams: InstanceSegmentOptions;
+    /** Retinal-layer checkpoints with a configured URL, and the active one.
+     *  Only VNet ships — see the registry for why the ResUNet-a entries are off. */
+    retinalModels: {
+        id: string;
+        label: string;
+    }[];
+    retinalModelId: string;
+    showRetinalParams: boolean;
+    retinalParams: SemanticSegmentOptions;
+    /** Download size of the active retinal model, surfaced in the dialog because
+     *  ~590 MB is worth knowing before clicking Run rather than after. */
+    get retinalModelSizeMb(): number;
     /** SAM download/segment toast state (bound by the `sam` p-toast template). */
     samStatus: string;
     samProgress: number;
@@ -247,7 +263,7 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
     private wheelListener?;
     /** Debounced z-slice scrubbing (see SliceScrubber — refactoring plan Step 7). */
     private readonly scrubber;
-    constructor(state: ImageStatePort, plotService: IVisualizer, messageService: MessageService, ngZone: NgZone, cdr: ChangeDetectorRef, session: VisualizerStore, samTool: SamToolService, cellSegmentTool: CellSegmentToolService, yoloDetectTool: YoloDetectToolService, instanceSegmenter: IInstanceSegmenter, samPointTool: SamPointToolService, regionOps: RegionOpsService, vizConfig?: VizConfig | undefined);
+    constructor(state: ImageStatePort, plotService: IVisualizer, messageService: MessageService, ngZone: NgZone, cdr: ChangeDetectorRef, session: VisualizerStore, samTool: SamToolService, cellSegmentTool: CellSegmentToolService, yoloDetectTool: YoloDetectToolService, instanceSegmenter: IInstanceSegmenter, semanticSegmenter: ISemanticSegmenter, retinalLayerTool: RetinalLayerToolService, samPointTool: SamPointToolService, regionOps: RegionOpsService, vizConfig?: VizConfig | undefined);
     /**
      * Plot types offered in the selector for the current image:
      *  - Outside **test mode**, only the curated default set (descriptors with a
@@ -406,6 +422,26 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
      *  in a field rather than being pointed at one. Reuses the shared segmentation
      *  toast so progress and status read the same as the SAM/cellpose tools. */
     detectYolo(): Promise<void>;
+    /**
+     * Defaults for the retinal tool.
+     *
+     * `classThreshold` is 0.5 to match the reference worker, which thresholds each
+     * class channel independently rather than taking an argmax — with a softmax
+     * output that makes it argmax plus a confidence floor.
+     *
+     * `downsamplingFactor` is 1 rather than YOLO's 5: these checkpoints were
+     * trained on native 40x patches, so the model wants full resolution and
+     * downsampling actively hurts.
+     */
+    private defaultRetinalParams;
+    /** Switching checkpoint re-seeds the parameters, since the defaults belong to
+     *  the model rather than to the tool. */
+    onRetinalModelChange(id: string): void;
+    openRetinalParams(): void;
+    resetRetinalParams(): void;
+    /** Segment retinal layers across the current view. Like YOLO this takes no
+     *  prompt — it labels every pixel — and reuses the shared segmentation toast. */
+    segmentRetinal(): Promise<void>;
     /** Shared driver for the box-prompt segment tools: wires the tool's status +
      *  download progress into the sticky `sam` toast, runs `op`, and reports the
      *  region count. Keeps the toast open until the run settles (bar hits 100%). */
@@ -449,6 +485,6 @@ export declare class VisualizerComponent implements OnInit, OnChanges, AfterView
     onSelectPlotType(type: PlotType): void;
     /** Deactivate whatever tool is armed and clear every tool mode. */
     private deactivateActiveTool;
-    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerComponent, [null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VisualizerComponent, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<VisualizerComponent, "visualizer", never, { "toolbarTools": { "alias": "toolbarTools"; "required": false; }; "testMode": { "alias": "testMode"; "required": false; }; }, { "isStackEvent": "isStackEvent"; "isGrayscaleEvent": "isGrayscaleEvent"; }, never, ["*"], false, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jax-data-science/sci-image-visualizer",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "Browser-based scientific image visualization for Angular — gigapixel whole-slide (OpenSeadragon), 2D/3D (Plotly) and WebGPU (napari-js) rendering, with region/annotation editing and in-browser SAM segmentation.",
   "keywords": [
     "angular",
@@ -36,6 +36,7 @@
   "dependencies": {
     "cellpose-js": "^0.4.1",
     "fast-png": "^6.4.0",
+    "jax-ai-js": "^0.1.1",
     "napari-js": "^0.11.0",
     "openseadragon": "^6.0.2",
     "plotly.js-dist-min": "^3.0.1",