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

package/esm2022/index.mjs

@@ -26,6 +26,9 @@ 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';
 // ── Generic client-side image utilities (shared with the host's pipeline) ──
 export { ProcessingImage } from './lib/processing/processing-image';
 export { cropImage } from './lib/processing/image-crop';
@@ -34,6 +37,8 @@ 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';
 // ── YOLO instance-segmentation model registry (same repointing story) ─────
 export { YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls, setDefaultYoloModel, getDefaultYoloModelId, } from './lib/toolbar/segmentation/yolo-model-registry';
+// ── Retinal-layer semantic-segmentation registry (same repointing story) ──
+export { RETINAL_MODELS, DEFAULT_RETINAL_MODEL_ID, getRetinalModel, isRetinalModelReady, readyRetinalModels, setRetinalModelUrls, setDefaultRetinalModel, getDefaultRetinalModelId, } from './lib/toolbar/segmentation/retinal-model-registry';
 // ── onnxruntime-web WASM location (host overrides once, at app init) ───────
 export { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';
 // ── Neutral data models ──────────────────────────────────────────────────
@@ -54,4 +59,4 @@ export { VisualizerComponent } from './lib/visualizer.component';
 export { RegionEditorComponent } from './lib/region-editor/region-editor.component';
 export { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';
 export { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4EAA4E;AAC5E,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACjG,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAEhH,8EAA8E;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAoB,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,6EAA6E;AAC7E,OAAO,EACL,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAC/E,kBAAkB,EAAE,oBAAoB,GACzC,MAAM,+CAA+C,CAAC;AAEvD,6EAA6E;AAC7E,OAAO,EACL,WAAW,EAAE,qBAAqB,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EACpF,mBAAmB,EAAE,qBAAqB,GAC3C,MAAM,gDAAgD,CAAC;AAExD,8EAA8E;AAC9E,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAE/F,4EAA4E;AAC5E,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,4EAA4E;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,6DAA6D;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC","sourcesContent":["/**\n * Public API of the jax-image-visualization library. External consumers import\n * ONLY from here (`@jax-data-science/sci-image-visualizer`); everything else under `lib/` is\n * internal. The surface is contracts + tokens + neutral models + the Angular\n * module, plus the routing service the host's composition root binds the tokens\n * to (`useExisting`).\n */\n\n// ── Contracts & DI tokens ────────────────────────────────────────────────\nexport * from './lib/contracts/visualizer.contract';\nexport * from './lib/contracts/region-editor-api.contract';\nexport * from './lib/contracts/ports/image-state.port';\nexport * from './lib/contracts/ports/tile-access.port';\nexport * from './lib/contracts/ports/region-io.port';\nexport * from './lib/contracts/ports/preferences.port';\nexport * from './lib/contracts/channel-histogram-api.contract';\nexport * from './lib/contracts/viz-config';\nexport * from './lib/contracts/image.contract';\nexport * from './lib/contracts/plot-type';\nexport * from './lib/contracts/toolbar-config';\nexport * from './lib/contracts/capabilities.contract';\nexport * from './lib/contracts/region-overlay.contract';\nexport * from './lib/contracts/display-types';\nexport * from './lib/contracts/sam.contract';\nexport * from './lib/contracts/cell-segmenter.contract';\nexport { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';\nexport * from './lib/contracts/instance-segmenter.contract';\nexport { YoloSegmenterService } from './lib/toolbar/segmentation/yolo-segmenter.service';\nexport { YoloDetectToolService, YOLO_REGION_SOURCE } from './lib/toolbar/segmentation/yolo-detect-tool.service';\n\n// ── Generic client-side image utilities (shared with the host's pipeline) ──\nexport { ProcessingImage } from './lib/processing/processing-image';\nexport { cropImage, CropImageOptions } from './lib/processing/image-crop';\nexport { ImageConverterService } from './lib/processing/image-converter.service';\n\n// ── SAM model registry (host configures hosted ONNX URLs once available) ──\nexport {\n  SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls,\n  setDefaultSamModel, getDefaultSamModelId,\n} from './lib/toolbar/segmentation/sam-model-registry';\n\n// ── YOLO instance-segmentation model registry (same repointing story) ─────\nexport {\n  YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls,\n  setDefaultYoloModel, getDefaultYoloModelId, YoloModelDef,\n} from './lib/toolbar/segmentation/yolo-model-registry';\n\n// ── onnxruntime-web WASM location (host overrides once, at app init) ───────\nexport { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';\n\n// ── Neutral data models ──────────────────────────────────────────────────\nexport * from './lib/models/region';\nexport * from './lib/models/class-preset';\nexport { ShapeSelection } from './lib/models/shape';\n\n// ── Angular module + composition-root service ────────────────────────────\nexport { VisualizationModule } from './lib/visualization.module';\nexport { RoutingVisualizerService } from './lib/routing-visualizer.service';\n// Provider factory for an isolated, component-scoped viewer instance (e.g. a\n// modal that must not share the main viewer's region/image state).\nexport { provideVisualization } from './lib/provide-visualization';\n\n// ── Public components (exported by VisualizationModule) ───────────────────\n// ng-packagr requires module-exported components to be reachable from the\n// entry point so consumers get their types; these are the embeddable elements\n// (`<visualizer>`, `<region-editor>`, `<hex-color-picker>`).\nexport { VisualizerComponent } from './lib/visualizer.component';\nexport { RegionEditorComponent } from './lib/region-editor/region-editor.component';\nexport { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';\nexport { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,4EAA4E;AAC5E,cAAc,qCAAqC,CAAC;AACpD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wCAAwC,CAAC;AACvD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,yCAAyC,CAAC;AACxD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yCAAyC,CAAC;AACxD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACjG,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AACzF,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAChH,cAAc,6CAA6C,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sDAAsD,CAAC;AAC/F,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,uDAAuD,CAAC;AAE/D,8EAA8E;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,SAAS,EAAoB,MAAM,6BAA6B,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AAEjF,6EAA6E;AAC7E,OAAO,EACL,UAAU,EAAE,oBAAoB,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAC/E,kBAAkB,EAAE,oBAAoB,GACzC,MAAM,+CAA+C,CAAC;AAEvD,6EAA6E;AAC7E,OAAO,EACL,WAAW,EAAE,qBAAqB,EAAE,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EACpF,mBAAmB,EAAE,qBAAqB,GAC3C,MAAM,gDAAgD,CAAC;AAExD,6EAA6E;AAC7E,OAAO,EACL,cAAc,EAAE,wBAAwB,EAAE,eAAe,EAAE,mBAAmB,EAC9E,kBAAkB,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,wBAAwB,GAE1F,MAAM,mDAAmD,CAAC;AAE3D,8EAA8E;AAC9E,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAE/F,4EAA4E;AAC5E,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,4EAA4E;AAC5E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,6EAA6E;AAC7E,mEAAmE;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAEnE,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,6DAA6D;AAC7D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,mDAAmD,CAAC;AAC5F,OAAO,EAAE,yBAAyB,EAAE,MAAM,qDAAqD,CAAC","sourcesContent":["/**\n * Public API of the jax-image-visualization library. External consumers import\n * ONLY from here (`@jax-data-science/sci-image-visualizer`); everything else under `lib/` is\n * internal. The surface is contracts + tokens + neutral models + the Angular\n * module, plus the routing service the host's composition root binds the tokens\n * to (`useExisting`).\n */\n\n// ── Contracts & DI tokens ────────────────────────────────────────────────\nexport * from './lib/contracts/visualizer.contract';\nexport * from './lib/contracts/region-editor-api.contract';\nexport * from './lib/contracts/ports/image-state.port';\nexport * from './lib/contracts/ports/tile-access.port';\nexport * from './lib/contracts/ports/region-io.port';\nexport * from './lib/contracts/ports/preferences.port';\nexport * from './lib/contracts/channel-histogram-api.contract';\nexport * from './lib/contracts/viz-config';\nexport * from './lib/contracts/image.contract';\nexport * from './lib/contracts/plot-type';\nexport * from './lib/contracts/toolbar-config';\nexport * from './lib/contracts/capabilities.contract';\nexport * from './lib/contracts/region-overlay.contract';\nexport * from './lib/contracts/display-types';\nexport * from './lib/contracts/sam.contract';\nexport * from './lib/contracts/cell-segmenter.contract';\nexport { CellposeSegmenterService } from './lib/toolbar/segmentation/cellpose-segmenter.service';\nexport * from './lib/contracts/instance-segmenter.contract';\nexport { YoloSegmenterService } from './lib/toolbar/segmentation/yolo-segmenter.service';\nexport { YoloDetectToolService, YOLO_REGION_SOURCE } from './lib/toolbar/segmentation/yolo-detect-tool.service';\nexport * from './lib/contracts/semantic-segmenter.contract';\nexport { RetinalSegmenterService } from './lib/toolbar/segmentation/retinal-segmenter.service';\nexport {\n  RetinalLayerToolService,\n  RETINAL_REGION_SOURCE,\n} from './lib/toolbar/segmentation/retinal-layer-tool.service';\n\n// ── Generic client-side image utilities (shared with the host's pipeline) ──\nexport { ProcessingImage } from './lib/processing/processing-image';\nexport { cropImage, CropImageOptions } from './lib/processing/image-crop';\nexport { ImageConverterService } from './lib/processing/image-converter.service';\n\n// ── SAM model registry (host configures hosted ONNX URLs once available) ──\nexport {\n  SAM_MODELS, DEFAULT_SAM_MODEL_ID, getSamModel, isSamModelReady, setSamModelUrls,\n  setDefaultSamModel, getDefaultSamModelId,\n} from './lib/toolbar/segmentation/sam-model-registry';\n\n// ── YOLO instance-segmentation model registry (same repointing story) ─────\nexport {\n  YOLO_MODELS, DEFAULT_YOLO_MODEL_ID, getYoloModel, isYoloModelReady, setYoloModelUrls,\n  setDefaultYoloModel, getDefaultYoloModelId, YoloModelDef,\n} from './lib/toolbar/segmentation/yolo-model-registry';\n\n// ── Retinal-layer semantic-segmentation registry (same repointing story) ──\nexport {\n  RETINAL_MODELS, DEFAULT_RETINAL_MODEL_ID, getRetinalModel, isRetinalModelReady,\n  readyRetinalModels, setRetinalModelUrls, setDefaultRetinalModel, getDefaultRetinalModelId,\n  RetinalModelDef,\n} from './lib/toolbar/segmentation/retinal-model-registry';\n\n// ── onnxruntime-web WASM location (host overrides once, at app init) ───────\nexport { setOrtWasmBase, getOrtWasmBase } from './lib/toolbar/segmentation/ort-runtime-config';\n\n// ── Neutral data models ──────────────────────────────────────────────────\nexport * from './lib/models/region';\nexport * from './lib/models/class-preset';\nexport { ShapeSelection } from './lib/models/shape';\n\n// ── Angular module + composition-root service ────────────────────────────\nexport { VisualizationModule } from './lib/visualization.module';\nexport { RoutingVisualizerService } from './lib/routing-visualizer.service';\n// Provider factory for an isolated, component-scoped viewer instance (e.g. a\n// modal that must not share the main viewer's region/image state).\nexport { provideVisualization } from './lib/provide-visualization';\n\n// ── Public components (exported by VisualizationModule) ───────────────────\n// ng-packagr requires module-exported components to be reachable from the\n// entry point so consumers get their types; these are the embeddable elements\n// (`<visualizer>`, `<region-editor>`, `<hex-color-picker>`).\nexport { VisualizerComponent } from './lib/visualizer.component';\nexport { RegionEditorComponent } from './lib/region-editor/region-editor.component';\nexport { HexColorPickerComponent } from './lib/hex-color-picker/hex-color-picker.component';\nexport { ChannelHistogramComponent } from './lib/channel-histogram/channel-histogram.component';\n"]}

package/esm2022/lib/contracts/semantic-segmenter.contract.mjs

@@ -0,0 +1,11 @@
+import { InjectionToken, inject } from '@angular/core';
+import { RetinalSegmenterService } from '../toolbar/segmentation/retinal-segmenter.service';
+/**
+ * DI token for the semantic segmenter, defaulting to the in-library
+ * jax-ai-js-backed implementation. Hosts override it to supply their own.
+ */
+export const SEMANTIC_SEGMENTER = new InjectionToken('SEMANTIC_SEGMENTER', {
+    providedIn: 'root',
+    factory: () => inject(RetinalSegmenterService),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VtYW50aWMtc2VnbWVudGVyLmNvbnRyYWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9jb250cmFjdHMvc2VtYW50aWMtc2VnbWVudGVyLmNvbnRyYWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXZELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLG1EQUFtRCxDQUFDO0FBNEc1Rjs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxJQUFJLGNBQWMsQ0FBcUIsb0JBQW9CLEVBQUU7SUFDN0YsVUFBVSxFQUFFLE1BQU07SUFDbEIsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyx1QkFBdUIsQ0FBQztDQUMvQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgaW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFJldGluYWxTZWdtZW50ZXJTZXJ2aWNlIH0gZnJvbSAnLi4vdG9vbGJhci9zZWdtZW50YXRpb24vcmV0aW5hbC1zZWdtZW50ZXIuc2VydmljZSc7XG5cbi8qKlxuICogUG9ydCBmb3IgYSAqKnNlbWFudGljKiogc2VnbWVudGVyIOKAlCBvbmUgdGhhdCBhc3NpZ25zIGV2ZXJ5IHBpeGVsIGEgY2xhc3MgZnJvbVxuICogYSBmaXhlZCBzZXQsIHdpdGggbm8gbm90aW9uIG9mIHNlcGFyYXRlIG9iamVjdHMuXG4gKlxuICogVGhlIHRoaXJkIHNpYmxpbmcgb2Yge0BsaW5rIElDZWxsU2VnbWVudGVyfSBhbmQge0BsaW5rIElJbnN0YW5jZVNlZ21lbnRlcn0sXG4gKiBhbmQgZ2VudWluZWx5IGEgZGlmZmVyZW50IHNoYXBlIGZyb20gYm90aC4gQ2VsbHBvc2Ugc2VwYXJhdGVzIHRvdWNoaW5nXG4gKiBpbnN0YW5jZXMgb2Ygb25lIGNsYXNzOyBZT0xPIHJldHVybnMgb3ZlcmxhcHBpbmcgY2xhc3NpZmllZCBvYmplY3RzOyB0aGlzXG4gKiByZXR1cm5zICpsYXllcnMqIOKAlCByZWdpb25zIHRoYXQgdGlsZSB0aGUgaW1hZ2UsIG5ldmVyIG92ZXJsYXAsIGFuZCB3aGVyZSB0d29cbiAqIGRpc2Nvbm5lY3RlZCBwYXRjaGVzIG9mIHRoZSBzYW1lIGNsYXNzIGFyZSB0aGUgc2FtZSBmaW5kaW5nIHJhdGhlciB0aGFuIHR3b1xuICogb2JqZWN0cy4gVGhlcmUgaXMgbm8gY29uZmlkZW5jZSBwZXIgb2JqZWN0IGFuZCBubyBOTVMsIGJlY2F1c2UgdGhlcmUgYXJlIG5vXG4gKiBvYmplY3RzLlxuICpcbiAqIFJlc3VsdHMgYXJlIGRlbGl2ZXJlZCBhcyBwb2x5Z29uIHJpbmdzIGluICoqaW1hZ2UgcGl4ZWxzKiosIHNvIGEgY2FsbGVyIGNhblxuICogYnVpbGQge0BsaW5rIFJlZ2lvbn1zIGRpcmVjdGx5IOKAlCB0aGUgc2FtZSBjdXJyZW5jeSB0aGUgb3RoZXIgdHdvIHBvcnRzIHVzZS5cbiAqL1xuXG4vKiogQSBjbG9zZWQgcmluZzsgdGhlIGxhc3QgcG9pbnQgaXMgTk9UIGEgcmVwZWF0IG9mIHRoZSBmaXJzdC4gKi9cbmV4cG9ydCB0eXBlIFNlbWFudGljUmluZyA9IEFycmF5PFtudW1iZXIsIG51bWJlcl0+O1xuXG4vKiogT25lIGNvbm5lY3RlZCBjb21wb25lbnQgb2Ygb25lIGNsYXNzLCB3aXRoIGFueSBpbnRlcmlvciB2b2lkcy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2VtYW50aWNSZWdpb24ge1xuICBleHRlcmlvcjogU2VtYW50aWNSaW5nO1xuICBob2xlczogU2VtYW50aWNSaW5nW107XG4gIGNsYXNzSWQ6IG51bWJlcjtcbiAgY2xhc3NOYW1lOiBzdHJpbmc7XG4gIC8qKiBBcmVhIGluIHBpeGVscywgaG9sZXMgYWxyZWFkeSBzdWJ0cmFjdGVkLiAqL1xuICBhcmVhOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VtYW50aWNTZWdtZW50YXRpb24ge1xuICByZWdpb25zOiBTZW1hbnRpY1JlZ2lvbltdO1xuICAvKiogVG90YWwgcGl4ZWxzIGFzc2lnbmVkIHRvIGVhY2ggY2xhc3MsIGluZGV4ZWQgYnkgY2xhc3MgaWQuICovXG4gIGNsYXNzQXJlYXM6IG51bWJlcltdO1xuICAvKiogQ2xhc3MgbmFtZXMgaW5kZXhlZCBieSBjbGFzcyBpZCwgZnJvbSB0aGUgbW9kZWwncyBvd24gbWV0YWRhdGEuICovXG4gIGNsYXNzTmFtZXM6IHN0cmluZ1tdO1xuICB3aWR0aDogbnVtYmVyO1xuICBoZWlnaHQ6IG51bWJlcjtcbiAgLyoqXG4gICAqIEZyYWN0aW9uIG9mIHBpeGVscyB0aGF0IG1ldCBubyBjbGFzcydzIHRocmVzaG9sZC5cbiAgICpcbiAgICogV29ydGggc3VyZmFjaW5nIHJhdGhlciB0aGFuIGRpc2NhcmRpbmc6IHRoZXNlIG1vZGVscyBhcmUgdGhyZXNob2xkZWQgcGVyXG4gICAqIGNsYXNzIHJhdGhlciB0aGFuIGFyZ21heGVkLCBzbyBhIGhpZ2ggdmFsdWUgbWVhbnMgdGhlIG1vZGVsIHdhcyB1bnN1cmVcbiAgICogZXZlcnl3aGVyZSDigJQgd2hpY2ggaXMgdGhlIHNpZ25hdHVyZSBvZiB3cm9uZyBwcmVwcm9jZXNzaW5nICh3cm9uZyBpbnB1dFxuICAgKiBzY2FsZSwgd3JvbmcgZ3JleXNjYWxlKSBsb25nIGJlZm9yZSB0aGUgcG9seWdvbnMgbG9vayBvYnZpb3VzbHkgd3JvbmcuXG4gICAqL1xuICB1bmFzc2lnbmVkRnJhY3Rpb246IG51bWJlcjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTZW1hbnRpY1NlZ21lbnRPcHRpb25zIHtcbiAgLyoqIFdoaWNoIHJlZ2lzdGVyZWQgbW9kZWwgdG8gcnVuLiBEZWZhdWx0cyB0byB0aGUgcmVnaXN0cnkncyBkZWZhdWx0LiAqL1xuICBtb2RlbElkPzogc3RyaW5nO1xuICAvKipcbiAgICogU2NhbGUgdG8gcnVuIGF0LCBhcyBhIGRpdmlzb3Igb2YgZnVsbCByZXNvbHV0aW9uIOKAlCB0aGUgc2FtZSBtZWFuaW5nIHRoZVxuICAgKiBzZXJ2ZXIgZ2l2ZXMgaXQuXG4gICAqXG4gICAqIE1hdHRlcnMgYXMgbXVjaCBoZXJlIGFzIGZvciBhIGRldGVjdG9yOiB0aGVzZSBjaGVja3BvaW50cyB3ZXJlIHRyYWluZWQgb25cbiAgICogNDB4IG9yIDIweCBwYXRjaGVzLCBhbmQgYSBsYXllciBpbWFnZWQgYXQgdGhlIHdyb25nIHNjYWxlIGRvZXMgbm90IGxvb2tcbiAgICogbGlrZSB0aGUgbGF5ZXIgdGhlIG1vZGVsIGxlYXJuZWQuXG4gICAqL1xuICBkb3duc2FtcGxpbmdGYWN0b3I/OiBudW1iZXI7XG4gIC8qKlxuICAgKiBNaW5pbXVtIHByb2JhYmlsaXR5IGZvciBhIHBpeGVsIHRvIGJlIGFzc2lnbmVkIHRvIGEgY2xhc3MsIGRlZmF1bHQgMC41LlxuICAgKlxuICAgKiBOb3QgYSBwbGFpbiBhcmdtYXguIFRoZSByZWZlcmVuY2Ugd29ya2VyIHRocmVzaG9sZHMgZWFjaCBjbGFzcyBjaGFubmVsXG4gICAqIGluZGVwZW5kZW50bHkgYXQgMC41OyBiZWNhdXNlIHRoZSBtb2RlbCdzIGxhc3QgbGF5ZXIgaXMgYSBzb2Z0bWF4IGF0IG1vc3RcbiAgICogb25lIGNsYXNzIGNhbiBjbGVhciB0aGF0LCBzbyB0aGlzIGlzIGFyZ21heCAqcGx1cyBhIGNvbmZpZGVuY2UgZmxvb3IqIOKAlFxuICAgKiBwaXhlbHMgd2hlcmUgdGhlIHdpbm5lciBpcyB3ZWFrIGFyZSBsZWZ0IHVuYXNzaWduZWQgcmF0aGVyIHRoYW4gZm9yY2VkIGludG9cbiAgICogdGhlIGJlc3Qgb2YgYSBiYWQgc2V0LiBMb3dlcmluZyBpdCB0b3dhcmQgMC4yNSBhcHByb2FjaGVzIGEgdHJ1ZSBhcmdtYXggYW5kXG4gICAqIHZpc2libHkgZmF0dGVucyBldmVyeSBsYXllci5cbiAgICovXG4gIGNsYXNzVGhyZXNob2xkPzogbnVtYmVyO1xuICAvKiogS2VlcCBvbmx5IHRoZXNlIGNsYXNzIGlkczsgb21pdCBmb3IgZXZlcnl0aGluZyBleGNlcHQgYmFja2dyb3VuZC4gKi9cbiAgY2xhc3NGaWx0ZXI/OiBudW1iZXJbXTtcbiAgLyoqIERvdWdsYXMtUGV1Y2tlciB0b2xlcmFuY2UgaW4gcGl4ZWxzIGZvciBvdXRsaW5lIHNpbXBsaWZpY2F0aW9uOyAwIGRpc2FibGVzLiAqL1xuICBzaW1wbGlmeVRvbGVyYW5jZT86IG51bWJlcjtcbiAgLyoqIERyb3AgcmVnaW9ucyB3aG9zZSBhcmVhIGlzIGJlbG93IHRoaXMsIGluIHNxdWFyZSBwaXhlbHMuICovXG4gIG1pbkFyZWE/OiBudW1iZXI7XG4gIC8qKlxuICAgKiBDb29wZXJhdGl2ZSBjYW5jZWxsYXRpb24sIGNoZWNrZWQgYXQgcGF0Y2ggYm91bmRhcmllcyDigJQgc28gaXQgdGFrZXMgZWZmZWN0XG4gICAqIHdpdGhpbiByb3VnaGx5IG9uZSBwYXRjaCByYXRoZXIgdGhhbiBpbnN0YW50bHkuXG4gICAqL1xuICBzaWduYWw/OiBBYm9ydFNpZ25hbDtcbn1cblxuLyoqIFByb2dyZXNzL3N0YXR1cyBjYWxsYmFja3MgKGFsbCBvcHRpb25hbCkuIE1pcnJvcnMge0BsaW5rIEluc3RhbmNlU2VnbWVudFByb2dyZXNzfS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2VtYW50aWNTZWdtZW50UHJvZ3Jlc3Mge1xuICAvKiogTW9kZWwtZG93bmxvYWQgcHJvZ3Jlc3MsIDAuLjEgKGZpcnN0IHJ1biBvbmx5KS4gKi9cbiAgb25Qcm9ncmVzcz86IChmcmFjdGlvbjogbnVtYmVyKSA9PiB2b2lkO1xuICAvKipcbiAgICogUmF3IGRvd25sb2FkIGJ5dGUgY291bnRzLCBmb3IgaG9zdHMgdGhhdCByZW5kZXIgYSBzaXplIHJhdGhlciB0aGFuIGEgYmFyZVxuICAgKiBwZXJjZW50YWdlLiBgdG90YWxgIGlzIG51bGwgd2hlbiB0aGUgcmVzcG9uc2UgY2FycmllZCBubyBDb250ZW50LUxlbmd0aC5cbiAgICovXG4gIG9uQnl0ZXM/OiAobG9hZGVkOiBudW1iZXIsIHRvdGFsOiBudW1iZXIgfCBudWxsKSA9PiB2b2lkO1xuICAvKiogSHVtYW4tcmVhZGFibGUgcGhhc2UsIGUuZy4gJ1NlZ21lbnRpbmcgcGF0Y2ggMy844oCmJy4gKi9cbiAgb25TdGF0dXM/OiAoc3RhdHVzOiBzdHJpbmcpID0+IHZvaWQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVNlbWFudGljU2VnbWVudGVyIHtcbiAgLyoqIEFzc2lnbiBldmVyeSBwaXhlbCBhIGNsYXNzIGFuZCByZXR1cm4gdGhlIHJlc3VsdGluZyByZWdpb25zLiAqL1xuICBzZWdtZW50U2VtYW50aWMoXG4gICAgaW1hZ2U6IHsgZGF0YTogVWludDhDbGFtcGVkQXJyYXk7IHdpZHRoOiBudW1iZXI7IGhlaWdodDogbnVtYmVyIH0sXG4gICAgb3B0cz86IFNlbWFudGljU2VnbWVudE9wdGlvbnMsXG4gICAgcHJvZ3Jlc3M/OiBTZW1hbnRpY1NlZ21lbnRQcm9ncmVzcyxcbiAgKTogUHJvbWlzZTxTZW1hbnRpY1NlZ21lbnRhdGlvbj47XG59XG5cbi8qKlxuICogREkgdG9rZW4gZm9yIHRoZSBzZW1hbnRpYyBzZWdtZW50ZXIsIGRlZmF1bHRpbmcgdG8gdGhlIGluLWxpYnJhcnlcbiAqIGpheC1haS1qcy1iYWNrZWQgaW1wbGVtZW50YXRpb24uIEhvc3RzIG92ZXJyaWRlIGl0IHRvIHN1cHBseSB0aGVpciBvd24uXG4gKi9cbmV4cG9ydCBjb25zdCBTRU1BTlRJQ19TRUdNRU5URVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48SVNlbWFudGljU2VnbWVudGVyPignU0VNQU5USUNfU0VHTUVOVEVSJywge1xuICBwcm92aWRlZEluOiAncm9vdCcsXG4gIGZhY3Rvcnk6ICgpID0+IGluamVjdChSZXRpbmFsU2VnbWVudGVyU2VydmljZSksXG59KTtcbiJdfQ==

package/esm2022/lib/toolbar/segmentation/retinal-layer-tool.service.mjs

@@ -0,0 +1,197 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { Region, Polygon } from '../../models/region';
+import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
+import * as i0 from "@angular/core";
+/** Marks regions this tool produced, so a re-run can replace only its own. */
+export 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 class RetinalLayerToolService {
+    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 = null) {
+        this.tileAccess = tileAccess;
+        this.status$ = new BehaviorSubject('');
+        this.busy$ = new BehaviorSubject(false);
+        this.progress$ = new BehaviorSubject(-1);
+    }
+    /**
+     * Segment the current view and commit the layers as regions.
+     *
+     * @returns the number of regions added.
+     */
+    async segmentInView(viz, segmenter, opts = {}) {
+        const pixels = viz.getDisplayedPixelData?.();
+        if (!pixels || pixels.width === 0 || pixels.height === 0) {
+            this.status$.next('No image on screen to segment.');
+            return 0;
+        }
+        this.busy$.next(true);
+        this.progress$.next(-1);
+        try {
+            const rect = viz.getDisplayedSourceRect?.() ?? null;
+            const target = Number(opts.downsamplingFactor ?? 0) || 0;
+            const viewFactor = rect && pixels.width > 0 ? rect.width / pixels.width : 1;
+            // Re-crop at the model's scale when the view is coarser than it wants.
+            // The image is tile-backed, so that detail exists server-side even though
+            // the displayed pixels have discarded it.
+            let source = { data: pixels.data, width: pixels.width, height: pixels.height };
+            if (rect && target > 0 && target < viewFactor * 0.98) {
+                this.status$.next('Fetching image at model resolution…');
+                const hi = await this.fetchCropAtScale(rect, target);
+                if (hi)
+                    source = hi;
+            }
+            const result = await segmenter.segmentSemantic(source, opts, {
+                onProgress: (f) => this.progress$.next(f),
+                onStatus: (s) => this.status$.next(s),
+            });
+            // View pixels -> full-resolution image pixels. Without this every region
+            // would sit at view-local coordinates, i.e. the wrong place on the slide
+            // for any zoomed or panned view.
+            const offsetX = rect ? rect.x : 0;
+            const offsetY = rect ? rect.y : 0;
+            // Against the pixels actually inferred on, which may be the re-crop.
+            const ratioX = rect && source.width > 0 ? rect.width / source.width : 1;
+            const ratioY = rect && source.height > 0 ? rect.height / source.height : 1;
+            // View pixels -> image pixels, for any ring.
+            const mapRing = (ring) => ring.map(([x, y]) => [Math.round(offsetX + x * ratioX), Math.round(offsetY + y * ratioY)]);
+            const added = [];
+            for (const r of result.regions) {
+                if (r.exterior.length < 3)
+                    continue;
+                const exterior = mapRing(r.exterior);
+                added.push(this.makeRegion(exterior.map(([x]) => x), exterior.map(([, y]) => y), r.className, 
+                // Holes are real findings here, not noise: a layer with a void
+                // through it is a donut, and dropping the interior rings fills it
+                // in silently. Rings that survive simplification to fewer than 3
+                // points cannot bound anything, so they are skipped rather than
+                // emitted as degenerate geometry.
+                r.holes.filter((h) => h.length >= 3).map(mapRing)));
+            }
+            if (added.length === 0) {
+                // Distinguish "found nothing" from "was unsure everywhere". The second
+                // is the signature of wrong preprocessing or the wrong magnification,
+                // and reads as a silent no-op unless it is said out loud.
+                this.status$.next(result.unassignedFraction > 0.9
+                    ? 'No layers found — the model was unsure across the whole view. ' +
+                        'Check the magnification matches the model.'
+                    : 'No layers found.');
+                return 0;
+            }
+            // Replace this tool's own previous output, keep everything else.
+            // Hand-drawn regions and other tools' output carry a different `source`
+            // (or none) and are untouched.
+            const kept = (viz.getRegions() ?? []).filter((x) => x.source !== RETINAL_REGION_SOURCE);
+            viz.setRegions([...kept, ...added]);
+            this.status$.next(`Added ${added.length} region(s).`);
+            return added.length;
+        }
+        catch (err) {
+            this.status$.next(err instanceof Error ? err.message : 'Retinal layer segmentation failed.');
+            return 0;
+        }
+        finally {
+            this.busy$.next(false);
+            this.progress$.next(-1);
+        }
+    }
+    /**
+     * 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.
+     */
+    async fetchCropAtScale(rect, target) {
+        if (!this.tileAccess)
+            return null;
+        let w = Math.round(rect.width / target);
+        let h = Math.round(rect.height / target);
+        // A factor of 1 over a whole-slide ROI would ask for hundreds of megapixels.
+        const MAX_PIXELS = 16_777_216; // 4096²
+        const pixels = w * h;
+        if (pixels > MAX_PIXELS) {
+            const k = Math.sqrt(MAX_PIXELS / pixels);
+            w = Math.round(w * k);
+            h = Math.round(h * k);
+        }
+        if (w < 64 || h < 64)
+            return null;
+        try {
+            const roi = {
+                x: Math.round(rect.x),
+                y: Math.round(rect.y),
+                width: Math.round(rect.width),
+                height: Math.round(rect.height),
+            };
+            const screen = { x: 0, y: 0, width: w, height: h };
+            const bytes = await firstValueFrom(this.tileAccess.zoomOnRegion(roi, screen, 0));
+            if (!bytes || bytes.byteLength === 0)
+                return null;
+            const bitmap = await createImageBitmap(new Blob([bytes]));
+            const canvas = document.createElement('canvas');
+            canvas.width = bitmap.width;
+            canvas.height = bitmap.height;
+            const ctx = canvas.getContext('2d');
+            if (!ctx)
+                return null;
+            ctx.drawImage(bitmap, 0, 0);
+            // Read the dimensions BEFORE close(): closing an ImageBitmap zeroes its
+            // width/height, so returning them afterwards yields a 0x0 image with a
+            // full pixel buffer — inference then runs on nothing and finds nothing.
+            const width = bitmap.width;
+            const height = bitmap.height;
+            const out = ctx.getImageData(0, 0, width, height);
+            bitmap.close?.();
+            return { data: out.data, width, height };
+        }
+        catch {
+            return null;
+        }
+    }
+    makeRegion(xs, ys, className, holes = []) {
+        const poly = new Polygon();
+        poly.npoints = xs.length;
+        poly.xpoints = xs;
+        poly.ypoints = ys;
+        poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+        poly.closed = true;
+        // Same closed-ring convention as the exterior: no repeated closing point.
+        // Left unset when empty so a solid region does not carry an empty array
+        // through export and round-tripping.
+        if (holes.length)
+            poly.holes = holes;
+        const region = new Region();
+        region.bounds = poly;
+        region.source = RETINAL_REGION_SOURCE;
+        // The class name drives preset colour resolution; leaving `color` unset lets
+        // an existing preset for this layer win.
+        region.label = className;
+        return region;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalLayerToolService, deps: [{ token: TILE_ACCESS_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalLayerToolService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RetinalLayerToolService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retinal-layer-tool.service.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/retinal-layer-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 {\n  ISemanticSegmenter,\n  SemanticSegmentOptions,\n} from '../../contracts/semantic-segmenter.contract';\n\n/** Marks regions this tool produced, so a re-run can replace only its own. */\nexport const RETINAL_REGION_SOURCE = 'retinal-layer';\n\n/**\n * Retinal-layer segmentation over the current view.\n *\n * Sibling of {@link YoloDetectToolService}, and structured the same way: run on\n * whatever is on screen, map the results onto full-image coordinates through\n * the viewer's source rect, and commit them as regions. The difference is what\n * comes back — layers that tile the field rather than discrete objects, so\n * every region is one connected component of one layer and there is no\n * per-object confidence to filter on.\n *\n * Exposes the same `status$` / `busy$` / `progress$` surface as the cellpose and\n * YOLO tools so the host's shared segmentation toast drives it unchanged.\n */\n@Injectable({ providedIn: 'root' })\nexport class RetinalLayerToolService {\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 segmentation can run at the model's scale rather\n     *  than the viewer's. Optional: without it the tool falls back to the\n     *  displayed pixels, which is correct but scale-dependent. */\n    @Optional() @Inject(TILE_ACCESS_PORT) private tileAccess: TileAccessPort | null = null,\n  ) {}\n\n  /**\n   * Segment the current view and commit the layers as regions.\n   *\n   * @returns the number of regions added.\n   */\n  async segmentInView(\n    viz: IVisualizer,\n    segmenter: ISemanticSegmenter,\n    opts: SemanticSegmentOptions = {},\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 segment.');\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.segmentSemantic(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      // View pixels -> image pixels, for any ring.\n      const mapRing = (ring: Array<[number, number]>): number[][] =>\n        ring.map(([x, y]) => [Math.round(offsetX + x * ratioX), Math.round(offsetY + y * ratioY)]);\n\n      const added: Region[] = [];\n      for (const r of result.regions) {\n        if (r.exterior.length < 3) continue;\n        const exterior = mapRing(r.exterior);\n        added.push(\n          this.makeRegion(\n            exterior.map(([x]) => x),\n            exterior.map(([, y]) => y),\n            r.className,\n            // Holes are real findings here, not noise: a layer with a void\n            // through it is a donut, and dropping the interior rings fills it\n            // in silently. Rings that survive simplification to fewer than 3\n            // points cannot bound anything, so they are skipped rather than\n            // emitted as degenerate geometry.\n            r.holes.filter((h) => h.length >= 3).map(mapRing),\n          ),\n        );\n      }\n\n      if (added.length === 0) {\n        // Distinguish \"found nothing\" from \"was unsure everywhere\". The second\n        // is the signature of wrong preprocessing or the wrong magnification,\n        // and reads as a silent no-op unless it is said out loud.\n        this.status$.next(\n          result.unassignedFraction > 0.9\n            ? 'No layers found — the model was unsure across the whole view. ' +\n                'Check the magnification matches the model.'\n            : 'No layers found.',\n        );\n        return 0;\n      }\n\n      // Replace this tool's own previous output, keep everything else.\n      // Hand-drawn regions and other tools' output carry a different `source`\n      // (or none) and are untouched.\n      const kept = (viz.getRegions() ?? []).filter((x) => x.source !== RETINAL_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 : 'Retinal layer segmentation 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, holes: number[][][] = []): 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    // Same closed-ring convention as the exterior: no repeated closing point.\n    // Left unset when empty so a solid region does not carry an empty array\n    // through export and round-tripping.\n    if (holes.length) poly.holes = holes;\n\n    const region = new Region();\n    region.bounds = poly;\n    region.source = RETINAL_REGION_SOURCE;\n    // The class name drives preset colour resolution; leaving `color` unset lets\n    // an existing preset for this layer win.\n    region.label = className;\n    return region;\n  }\n}\n"]}

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

@@ -0,0 +1,119 @@
+/**
+ * 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.
+ */
+const HF = 'https://huggingface.co/Ballon999';
+const RESUNET_UNAVAILABLE = 'Not available in the browser: this checkpoint scores mIoU ~0.3 against its own ' +
+    'ground-truth masks, pending a review of its class definitions. Run this step on the server.';
+export const RETINAL_MODELS = [
+    {
+        id: 'vnet-2d-retinal',
+        label: 'VNet 2D (40x)',
+        modelUrl: `${HF}/vnet-2d-retinal-layer-onnx/resolve/main/model.fp16w.onnx`,
+        patchSize: 512,
+        // Nearly 6x the YOLO checkpoints. Worth surfacing before a user on a
+        // metered connection triggers it by clicking a toolbar button.
+        sizeMb: 590,
+        miou: 0.9061,
+    },
+    {
+        id: 'resunet-a-2d-retinal',
+        label: 'ResUNet-a 2D (40x)',
+        modelUrl: '',
+        patchSize: 512,
+        sizeMb: 102,
+        miou: 0.3065,
+        unavailableReason: RESUNET_UNAVAILABLE,
+    },
+    {
+        id: 'resunet-a-2d-retinal-20x',
+        label: 'ResUNet-a 2D (20x)',
+        modelUrl: '',
+        patchSize: 256,
+        sizeMb: 102,
+        miou: 0.2869,
+        unavailableReason: RESUNET_UNAVAILABLE,
+    },
+    {
+        id: 'resunet-a-2d-retinal-40x',
+        label: 'ResUNet-a 2D (40x, alt)',
+        modelUrl: '',
+        patchSize: 512,
+        sizeMb: 102,
+        miou: 0.2718,
+        unavailableReason: RESUNET_UNAVAILABLE,
+    },
+];
+export const DEFAULT_RETINAL_MODEL_ID = 'vnet-2d-retinal';
+let defaultModelId = DEFAULT_RETINAL_MODEL_ID;
+/** Look up a model definition by id. Returns undefined for an unknown id. */
+export function getRetinalModel(id) {
+    return RETINAL_MODELS.find((m) => m.id === id);
+}
+/** Whether a model has usable weights configured. */
+export function isRetinalModelReady(id) {
+    const m = getRetinalModel(id);
+    return !!m && m.modelUrl.trim().length > 0;
+}
+/** Only the models a browser can actually run. */
+export function readyRetinalModels() {
+    return RETINAL_MODELS.filter((m) => m.modelUrl.trim().length > 0);
+}
+/**
+ * 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 function setRetinalModelUrls(id, urls) {
+    const m = getRetinalModel(id);
+    if (!m)
+        return;
+    if (urls.modelUrl !== undefined)
+        m.modelUrl = urls.modelUrl;
+    if (urls.metaUrl !== undefined)
+        m.metaUrl = urls.metaUrl;
+    // A host that supplies weights has answered the question the reason
+    // describes. Decided from the model's post-update state rather than from the
+    // argument: a whitespace-only url, or a call that sets only `metaUrl`, leaves
+    // the model just as disabled — and clearing the reason there would strip the
+    // one explanation the user gets while `isRetinalModelReady` still says no.
+    if (isRetinalModelReady(id))
+        delete m.unavailableReason;
+}
+/** Change which model runs when a caller does not name one. */
+export function setDefaultRetinalModel(id) {
+    if (getRetinalModel(id))
+        defaultModelId = id;
+}
+export function getDefaultRetinalModelId() {
+    return defaultModelId;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retinal-model-registry.js","sourceRoot":"","sources":["../../../../../src/lib/toolbar/segmentation/retinal-model-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAsBH,MAAM,EAAE,GAAG,kCAAkC,CAAC;AAE9C,MAAM,mBAAmB,GACvB,iFAAiF;IACjF,6FAA6F,CAAC;AAEhG,MAAM,CAAC,MAAM,cAAc,GAAsB;IAC/C;QACE,EAAE,EAAE,iBAAiB;QACrB,KAAK,EAAE,eAAe;QACtB,QAAQ,EAAE,GAAG,EAAE,2DAA2D;QAC1E,SAAS,EAAE,GAAG;QACd,qEAAqE;QACrE,+DAA+D;QAC/D,MAAM,EAAE,GAAG;QACX,IAAI,EAAE,MAAM;KACb;IACD;QACE,EAAE,EAAE,sBAAsB;QAC1B,KAAK,EAAE,oBAAoB;QAC3B,QAAQ,EAAE,EAAE;QACZ,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,GAAG;QACX,IAAI,EAAE,MAAM;QACZ,iBAAiB,EAAE,mBAAmB;KACvC;IACD;QACE,EAAE,EAAE,0BAA0B;QAC9B,KAAK,EAAE,oBAAoB;QAC3B,QAAQ,EAAE,EAAE;QACZ,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,GAAG;QACX,IAAI,EAAE,MAAM;QACZ,iBAAiB,EAAE,mBAAmB;KACvC;IACD;QACE,EAAE,EAAE,0BAA0B;QAC9B,KAAK,EAAE,yBAAyB;QAChC,QAAQ,EAAE,EAAE;QACZ,SAAS,EAAE,GAAG;QACd,MAAM,EAAE,GAAG;QACX,IAAI,EAAE,MAAM;QACZ,iBAAiB,EAAE,mBAAmB;KACvC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,iBAAiB,CAAC;AAE1D,IAAI,cAAc,GAAG,wBAAwB,CAAC;AAE9C,6EAA6E;AAC7E,MAAM,UAAU,eAAe,CAAC,EAAU;IACxC,OAAO,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;AACjD,CAAC;AAED,qDAAqD;AACrD,MAAM,UAAU,mBAAmB,CAAC,EAAU;IAC5C,MAAM,CAAC,GAAG,eAAe,CAAC,EAAE,CAAC,CAAC;IAC9B,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7C,CAAC;AAED,kDAAkD;AAClD,MAAM,UAAU,kBAAkB;IAChC,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AACpE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAU,EAAE,IAA6C;IAC3F,MAAM,CAAC,GAAG,eAAe,CAAC,EAAE,CAAC,CAAC;IAC9B,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;IACzD,oEAAoE;IACpE,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,2EAA2E;IAC3E,IAAI,mBAAmB,CAAC,EAAE,CAAC;QAAE,OAAO,CAAC,CAAC,iBAAiB,CAAC;AAC1D,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,sBAAsB,CAAC,EAAU;IAC/C,IAAI,eAAe,CAAC,EAAE,CAAC;QAAE,cAAc,GAAG,EAAE,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,wBAAwB;IACtC,OAAO,cAAc,CAAC;AACxB,CAAC","sourcesContent":["/**\n * Registry of retinal-layer semantic-segmentation models.\n *\n * Mirrors {@link YOLO_MODELS}: public HF-hosted ONNX by default, repointable at\n * private hosting via {@link setRetinalModelUrls}.\n *\n * ONLY ONE CHECKPOINT IS ENABLED, AND THAT IS DELIBERATE\n * The server offers four. Measured against the ground-truth masks shipped\n * alongside them, only VNet reproduces them:\n *\n * | checkpoint | mIoU |\n * |---|---|\n * | **VNet 2D** | **0.9061** |\n * | ResUNet-a 2D (base) | 0.3065 |\n * | ResUNet-a 2D 20x | 0.2869 |\n * | ResUNet-a 2D 40x | 0.2718 |\n *\n * The ResUNet-a numbers are not quantization damage — their ONNX exports match\n * their own Keras originals exactly. They disagree with the *masks*, folding\n * ground-truth class 1 into their class 2 and class 3 into background, and no\n * relabelling rescues them (the best of all 24 class permutations reaches only\n * 0.36). Either those masks belong to a different model generation or the class\n * definitions moved — an open question for whoever trained them.\n *\n * So their weights stay unpublished (their Hub repos are private) and their\n * entries here carry an empty `modelUrl`, which {@link isRetinalModelReady}\n * reports as not-ready. They are listed rather than deleted so a host shows\n * them as unavailable-in-browser instead of pretending the server's choice does\n * not exist — and so enabling one later is a URL, not a code change.\n *\n * Export tooling: the sibling `browser-onnx-tools` project.\n */\n\nexport interface RetinalModelDef {\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  /** Patch size the checkpoint was trained at, for callers that size reads to it. */\n  patchSize: number;\n  /** Download size of the `fp16w` weights, MB — these are large enough to warn about. */\n  sizeMb: number;\n  /** Measured mIoU against the bucket's ground-truth masks. */\n  miou: number;\n  /** Set when the model is knowingly disabled; shown to the user. */\n  unavailableReason?: string;\n}\n\nconst HF = 'https://huggingface.co/Ballon999';\n\nconst RESUNET_UNAVAILABLE =\n  'Not available in the browser: this checkpoint scores mIoU ~0.3 against its own ' +\n  'ground-truth masks, pending a review of its class definitions. Run this step on the server.';\n\nexport const RETINAL_MODELS: RetinalModelDef[] = [\n  {\n    id: 'vnet-2d-retinal',\n    label: 'VNet 2D (40x)',\n    modelUrl: `${HF}/vnet-2d-retinal-layer-onnx/resolve/main/model.fp16w.onnx`,\n    patchSize: 512,\n    // Nearly 6x the YOLO checkpoints. Worth surfacing before a user on a\n    // metered connection triggers it by clicking a toolbar button.\n    sizeMb: 590,\n    miou: 0.9061,\n  },\n  {\n    id: 'resunet-a-2d-retinal',\n    label: 'ResUNet-a 2D (40x)',\n    modelUrl: '',\n    patchSize: 512,\n    sizeMb: 102,\n    miou: 0.3065,\n    unavailableReason: RESUNET_UNAVAILABLE,\n  },\n  {\n    id: 'resunet-a-2d-retinal-20x',\n    label: 'ResUNet-a 2D (20x)',\n    modelUrl: '',\n    patchSize: 256,\n    sizeMb: 102,\n    miou: 0.2869,\n    unavailableReason: RESUNET_UNAVAILABLE,\n  },\n  {\n    id: 'resunet-a-2d-retinal-40x',\n    label: 'ResUNet-a 2D (40x, alt)',\n    modelUrl: '',\n    patchSize: 512,\n    sizeMb: 102,\n    miou: 0.2718,\n    unavailableReason: RESUNET_UNAVAILABLE,\n  },\n];\n\nexport const DEFAULT_RETINAL_MODEL_ID = 'vnet-2d-retinal';\n\nlet defaultModelId = DEFAULT_RETINAL_MODEL_ID;\n\n/** Look up a model definition by id. Returns undefined for an unknown id. */\nexport function getRetinalModel(id: string): RetinalModelDef | undefined {\n  return RETINAL_MODELS.find((m) => m.id === id);\n}\n\n/** Whether a model has usable weights configured. */\nexport function isRetinalModelReady(id: string): boolean {\n  const m = getRetinalModel(id);\n  return !!m && m.modelUrl.trim().length > 0;\n}\n\n/** Only the models a browser can actually run. */\nexport function readyRetinalModels(): RetinalModelDef[] {\n  return RETINAL_MODELS.filter((m) => m.modelUrl.trim().length > 0);\n}\n\n/**\n * Repoint a model at different hosting (a GCS bucket, a same-origin proxy), or\n * enable one of the disabled entries. Call once at app init, before first use.\n * An empty `modelUrl` disables the model.\n */\nexport function setRetinalModelUrls(id: string, urls: { modelUrl?: string; metaUrl?: string }): void {\n  const m = getRetinalModel(id);\n  if (!m) return;\n  if (urls.modelUrl !== undefined) m.modelUrl = urls.modelUrl;\n  if (urls.metaUrl !== undefined) m.metaUrl = urls.metaUrl;\n  // A host that supplies weights has answered the question the reason\n  // describes. Decided from the model's post-update state rather than from the\n  // argument: a whitespace-only url, or a call that sets only `metaUrl`, leaves\n  // the model just as disabled — and clearing the reason there would strip the\n  // one explanation the user gets while `isRetinalModelReady` still says no.\n  if (isRetinalModelReady(id)) delete m.unavailableReason;\n}\n\n/** Change which model runs when a caller does not name one. */\nexport function setDefaultRetinalModel(id: string): void {\n  if (getRetinalModel(id)) defaultModelId = id;\n}\n\nexport function getDefaultRetinalModelId(): string {\n  return defaultModelId;\n}\n"]}