@jax-data-science/sci-image-visualizer 0.8.3 → 0.9.0

package/esm2022/lib/implementations/base-store-visualizer.mjs

@@ -1,76 +1,229 @@
 /**
- * Shared store-delegation base for the OpenSeadragon and napari-js
+ * Shared store-delegation base for the OpenSeadragon, napari-js and Plotly
  * `IVisualizer` backends. The entire `IRegionStore` and `IDisplayOptions`
  * surfaces (plus the two classification-colour members) are pure forwarders to
- * the shared `RegionStore` / `VisualizerStore` in BOTH backends — so they live
- * here once, as a single source of truth, rather than being copied per backend.
- * (This is the "cross-backend behaviour that isn't rendering belongs in a
- * shared abstraction" convention from CLAUDE.md; the extraction closes
- * SHARED-BACKEND-REFACTOR.md.)
+ * the shared `RegionStore` / `VisualizerStore` — so they live here once, as a
+ * single source of truth, rather than being copied per backend. (This is the
+ * "cross-backend behaviour that isn't rendering belongs in a shared
+ * abstraction" convention from CLAUDE.md; see
+ * docs/history/2026-07-shared-backend-refactor.md.)
+ *
+ * The on-canvas tool controls (`setActiveTool` and the per-tool setters) live
+ * here too: each subclass creates its own {@link CanvasToolManager} over its own
+ * tool host and gates pointer/readback in {@link beforeToolChange}.
  *
  * Backend-specific members — `load`/`plot`/`reset`/zoom/`setZIndex`/readback,
- * the region OVERLAY, tool wiring, histograms, scale bar, tiling, colormap LUT
- * application — deliberately stay in each subclass.
+ * the region OVERLAY, the tool host, SAM/Cellpose runs, histograms, scale bar,
+ * tiling, colormap LUT application — deliberately stay in each subclass. Plotly keeps a Plotly-shape
+ * working-set beside the store and redraws it from the store's update events
+ * (like the OSD/napari overlays), so it overrides only the colormap and reverse
+ * scale (a live restyle) and `exportRegions` (the file name).
  *
  * NOT `@Injectable`: an abstract base doesn't participate in Angular DI. Each
  * subclass stays `@Injectable`, declares its own injected dependencies
- * (including the two stores), and passes them to `super(...)`. Plotly is
- * intentionally not a subclass — it has its own region model.
+ * (including the two stores), and passes them to `super(...)`.
  */
 export class BaseStoreVisualizer {
     constructor(regionStore, store) {
         this.regionStore = regionStore;
         this.store = store;
+        // Undo, redo and a slice switch replace the regions an in-progress stroke or
+        // SAM prompt was building on — whoever called them (the router writes the
+        // store directly). Service-lifetime, like the store.
+        regionStore.getRegionSetReplaced$().subscribe(() => this.canvasTools.resetAll());
     }
     // ── IRegionStore → shared RegionStore ────────────────────────────────────
     setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append) {
         this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
     }
-    getRegions() { return this.regionStore.getRegions(); }
-    getRegionPolygons() { return this.regionStore.getRegionPolygons(); }
-    getRegionUpdateEvent() { return this.regionStore.getRegionUpdateEvent(); }
-    setSelectedShapeIndices(indices) { this.regionStore.setSelectedShapeIndices(indices); }
-    getSelectedShapeIndices$() { return this.regionStore.getSelectedShapeIndices$(); }
-    selectRegion(region) { this.regionStore.selectRegion(region); }
-    deleteActiveShape() { this.regionStore.deleteActiveShape(); }
-    getShowShapeLabel() { return this.regionStore.getShowShapeLabel(); }
-    getShapeColor() { return this.regionStore.getShapeColor(); }
-    getFillColor() { return this.regionStore.getFillColor(); }
-    plotPreviousShapes() { this.regionStore.plotPreviousShapes(); }
-    setPreviousShapes(shapes) { this.regionStore.setPreviousShapes(shapes); }
-    getPreviousShapes() { return this.regionStore.getPreviousShapes(); }
-    undo() { this.regionStore.undo(); }
-    redo() { this.regionStore.redo(); }
-    canUndo() { return this.regionStore.canUndo(); }
-    canRedo() { return this.regionStore.canRedo(); }
-    getCanUndo$() { return this.regionStore.getCanUndo$(); }
-    getCanRedo$() { return this.regionStore.getCanRedo$(); }
-    resetUndoHistory() { this.regionStore.resetUndoHistory(); }
-    importRegions(geoJsonStr) { return this.regionStore.importRegions(geoJsonStr); }
-    exportRegions(regions) { this.regionStore.exportRegions(regions); }
-    getGeoJsonString(regions) { return this.regionStore.getGeoJsonString(regions); }
+    getRegions() {
+        return this.regionStore.getRegions();
+    }
+    getRegionPolygons() {
+        return this.regionStore.getRegionPolygons();
+    }
+    getRegionUpdateEvent() {
+        return this.regionStore.getRegionUpdateEvent();
+    }
+    setSelectedShapeIndices(indices) {
+        this.regionStore.setSelectedShapeIndices(indices);
+    }
+    getSelectedShapeIndices$() {
+        return this.regionStore.getSelectedShapeIndices$();
+    }
+    selectRegion(region) {
+        this.regionStore.selectRegion(region);
+    }
+    deleteActiveShape() {
+        this.regionStore.deleteActiveShape();
+    }
+    getShowShapeLabel() {
+        return this.regionStore.getShowShapeLabel();
+    }
+    getShapeColor() {
+        return this.regionStore.getShapeColor();
+    }
+    getFillColor() {
+        return this.regionStore.getFillColor();
+    }
+    // Undo/redo reset the canvas tools through the store's getRegionSetReplaced$ (see the constructor).
+    undo() {
+        this.regionStore.undo();
+    }
+    redo() {
+        this.regionStore.redo();
+    }
+    canUndo() {
+        return this.regionStore.canUndo();
+    }
+    canRedo() {
+        return this.regionStore.canRedo();
+    }
+    getCanUndo$() {
+        return this.regionStore.getCanUndo$();
+    }
+    getCanRedo$() {
+        return this.regionStore.getCanRedo$();
+    }
+    resetUndoHistory() {
+        this.regionStore.resetUndoHistory();
+    }
+    importRegions(geoJsonStr) {
+        return this.regionStore.importRegions(geoJsonStr);
+    }
+    exportRegions(regions) {
+        this.regionStore.exportRegions(regions);
+    }
+    getGeoJsonString(regions) {
+        return this.regionStore.getGeoJsonString(regions);
+    }
     // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────
     enterStackMode(slices, initialZ, saveLayout) {
         this.regionStore.enterStackMode(slices, initialZ, saveLayout);
     }
-    exitStackMode() { this.regionStore.exitStackMode(); }
-    isStackMode() { return this.regionStore.isStackMode(); }
-    getStackSaveLayout() { return this.regionStore.getStackSaveLayout(); }
-    setDisplaySlice(z) { this.regionStore.setDisplaySlice(z); }
-    getSliceRegions() { return this.regionStore.getSliceRegions(); }
-    getStackSaveSlices() { return this.regionStore.getStackSaveSlices(); }
+    exitStackMode() {
+        this.regionStore.exitStackMode();
+    }
+    isStackMode() {
+        return this.regionStore.isStackMode();
+    }
+    getStackSaveLayout() {
+        return this.regionStore.getStackSaveLayout();
+    }
+    setDisplaySlice(z) {
+        this.regionStore.setDisplaySlice(z);
+    }
+    getSliceRegions() {
+        return this.regionStore.getSliceRegions();
+    }
+    getStackSaveSlices() {
+        return this.regionStore.getStackSaveSlices();
+    }
+    /**
+     * Runs before every tool change, for the backend's pointer and readback
+     * gating (pan/zoom off while a tool holds the pointer, a fresh pixel
+     * readback). Return false to arm nothing; the armed tool is disarmed anyway.
+     */
+    beforeToolChange(_next) {
+        return true;
+    }
+    /**
+     * Arm one on-canvas tool, disarming the armed one; null — or any id that is
+     * not a canvas tool (a region draw mode, pan) — disarms only. Re-arming the
+     * armed tool applies `options` and keeps its work in progress.
+     */
+    setActiveTool(id, options) {
+        const next = this.canvasTools.has(id) ? id : null;
+        if (!this.beforeToolChange(next)) {
+            this.canvasTools.deactivate();
+            return;
+        }
+        this.canvasTools.activate(next, options);
+    }
+    /** @deprecated Use {@link setActiveTool}(`'wand'`, options) / (null). */
+    setWandMode(active, options) {
+        this.setToolMode('wand', active, options);
+    }
+    setWandOptions(options) {
+        this.canvasTools.setOptions('wand', options);
+    }
+    clearActiveWandRegion() {
+        this.canvasTools.reset('wand');
+    }
+    /** @deprecated Use {@link setActiveTool}(`'brush'`, options) / (null). */
+    setBrushMode(active, options) {
+        this.setToolMode('brush', active, options);
+    }
+    setBrushOptions(options) {
+        this.canvasTools.setOptions('brush', options ?? {});
+    }
+    /** @deprecated Use {@link setActiveTool}(`'eraseVertex'`, { radius }) / (null). */
+    setVertexEraserMode(active) {
+        this.setToolMode('eraseVertex', active);
+    }
+    setVertexEraserRadius(radius) {
+        this.canvasTools.setOptions('eraseVertex', { radius });
+    }
+    /** @deprecated Use {@link setActiveTool}(`'zoomToBox'`) / (null). */
+    setZoomToBoxMode(active) {
+        this.setToolMode('zoomToBox', active);
+    }
+    /** @deprecated Use {@link setActiveTool}(`'samPoint'`) / (null). */
+    setSamPointMode(active) {
+        this.setToolMode('samPoint', active);
+    }
+    commitSamPoints() {
+        this.canvasTools.get('samPoint')?.commit();
+    }
+    clearSamPoints() {
+        this.canvasTools.get('samPoint')?.clear();
+    }
+    /** A per-tool setter: arm `id`, or disarm it if it is the armed tool. */
+    setToolMode(id, active, options) {
+        if (active)
+            this.setActiveTool(id, options);
+        else if (this.canvasTools.activeId === id)
+            this.setActiveTool(null);
+    }
+    /** The view is going away: release what is bound to it (`IViewerBackend.detach`) —
+     *  first the armed tool, whose overlay canvas and ResizeObserver sit on the view's
+     *  container (the backend outlives the view). */
+    detach() {
+        this.canvasTools.deactivate();
+        this.unsubscribe();
+    }
+    /** Fit the image into the view (`IViewerBackend.fitToView`). */
+    fitToView() {
+        this.autoscale();
+    }
     // ── Classification colours → shared VisualizerStore ──────────────────────
-    getClassificationColors() { return this.store.getClassificationColors(); }
+    getClassificationColors() {
+        return this.store.getClassificationColors();
+    }
     setClassificationColor(label, color) {
         this.store.setClassificationColor(label, color);
     }
     // ── IDisplayOptions → shared VisualizerStore ─────────────────────────────
-    getColormap() { return this.store.getColormap(); }
-    setColormap(colormap) { this.store.setColormap(colormap); }
-    getColormapOptions() { return this.store.getColormapOptions(); }
-    getReverseScale() { return this.store.getReverseScale(); }
-    setReverseScale(reverscale) { this.store.setReverseScale(reverscale); }
-    setImageMeta(imageMeta) { this.store.setImageMeta(imageMeta); }
-    getImageMeta() { return this.store.getImageMeta(); }
+    getColormap() {
+        return this.store.getColormap();
+    }
+    setColormap(colormap) {
+        this.store.setColormap(colormap);
+    }
+    getColormapOptions() {
+        return this.store.getColormapOptions();
+    }
+    getReverseScale() {
+        return this.store.getReverseScale();
+    }
+    setReverseScale(reverscale) {
+        this.store.setReverseScale(reverscale);
+    }
+    setImageMeta(imageMeta) {
+        this.store.setImageMeta(imageMeta);
+    }
+    getImageMeta() {
+        return this.store.getImageMeta();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-store-visualizer.js","sourceRoot":"","sources":["../../../../src/lib/implementations/base-store-visualizer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\n\nimport { IDisplayOptions, IRegionStore } from '../contracts/visualizer.contract';\nimport { Region } from '../models/region';\nimport { ColormapNode } from '../contracts/display-types';\nimport { IImageMetadata } from '../contracts/image.contract';\nimport { RegionStore } from '../store/region-store.service';\nimport { VisualizerStore } from '../store/visualizer-store.service';\n\n/**\n * Shared store-delegation base for the OpenSeadragon and napari-js\n * `IVisualizer` backends. The entire `IRegionStore` and `IDisplayOptions`\n * surfaces (plus the two classification-colour members) are pure forwarders to\n * the shared `RegionStore` / `VisualizerStore` in BOTH backends — so they live\n * here once, as a single source of truth, rather than being copied per backend.\n * (This is the \"cross-backend behaviour that isn't rendering belongs in a\n * shared abstraction\" convention from CLAUDE.md; the extraction closes\n * SHARED-BACKEND-REFACTOR.md.)\n *\n * Backend-specific members — `load`/`plot`/`reset`/zoom/`setZIndex`/readback,\n * the region OVERLAY, tool wiring, histograms, scale bar, tiling, colormap LUT\n * application — deliberately stay in each subclass.\n *\n * NOT `@Injectable`: an abstract base doesn't participate in Angular DI. Each\n * subclass stays `@Injectable`, declares its own injected dependencies\n * (including the two stores), and passes them to `super(...)`. Plotly is\n * intentionally not a subclass — it has its own region model.\n */\nexport abstract class BaseStoreVisualizer implements IRegionStore, IDisplayOptions {\n  protected constructor(\n    protected readonly regionStore: RegionStore,\n    protected readonly store: VisualizerStore,\n  ) {}\n\n  // ── IRegionStore → shared RegionStore ────────────────────────────────────\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void {\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] { return this.regionStore.getRegions(); }\n  getRegionPolygons(): any[] { return this.regionStore.getRegionPolygons(); }\n  getRegionUpdateEvent(): Observable<any[]> { return this.regionStore.getRegionUpdateEvent(); }\n  setSelectedShapeIndices(indices: number[]): void { this.regionStore.setSelectedShapeIndices(indices); }\n  getSelectedShapeIndices$(): Observable<number[]> { return this.regionStore.getSelectedShapeIndices$(); }\n  selectRegion(region: Region): void { this.regionStore.selectRegion(region); }\n  deleteActiveShape(): void { this.regionStore.deleteActiveShape(); }\n  getShowShapeLabel(): boolean { return this.regionStore.getShowShapeLabel(); }\n  getShapeColor(): string { return this.regionStore.getShapeColor(); }\n  getFillColor(): string { return this.regionStore.getFillColor(); }\n  plotPreviousShapes(): void { this.regionStore.plotPreviousShapes(); }\n  setPreviousShapes(shapes: any[]): void { this.regionStore.setPreviousShapes(shapes); }\n  getPreviousShapes(): any[] { return this.regionStore.getPreviousShapes(); }\n  undo(): void { this.regionStore.undo(); }\n  redo(): void { this.regionStore.redo(); }\n  canUndo(): boolean { return this.regionStore.canUndo(); }\n  canRedo(): boolean { return this.regionStore.canRedo(); }\n  getCanUndo$(): Observable<boolean> { return this.regionStore.getCanUndo$(); }\n  getCanRedo$(): Observable<boolean> { return this.regionStore.getCanRedo$(); }\n  resetUndoHistory(): void { this.regionStore.resetUndoHistory(); }\n  importRegions(geoJsonStr: string): Region[] { return this.regionStore.importRegions(geoJsonStr); }\n  exportRegions(regions: Region[]): void { this.regionStore.exportRegions(regions); }\n  getGeoJsonString(regions: Region[]): string { return this.regionStore.getGeoJsonString(regions); }\n\n  // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void { this.regionStore.exitStackMode(); }\n  isStackMode(): boolean { return this.regionStore.isStackMode(); }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.regionStore.getStackSaveLayout(); }\n  setDisplaySlice(z: number): void { this.regionStore.setDisplaySlice(z); }\n  getSliceRegions(): Region[] { return this.regionStore.getSliceRegions(); }\n  getStackSaveSlices(): Map<number, Region[]> { return this.regionStore.getStackSaveSlices(); }\n\n  // ── Classification colours → shared VisualizerStore ──────────────────────\n  getClassificationColors(): Map<string, string> { return this.store.getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n\n  // ── IDisplayOptions → shared VisualizerStore ─────────────────────────────\n  getColormap(): Observable<ColormapNode | null> { return this.store.getColormap(); }\n  setColormap(colormap: ColormapNode): void { this.store.setColormap(colormap); }\n  getColormapOptions(): ColormapNode[] { return this.store.getColormapOptions(); }\n  getReverseScale(): Observable<boolean> { return this.store.getReverseScale(); }\n  setReverseScale(reverscale: any): void { this.store.setReverseScale(reverscale); }\n  setImageMeta(imageMeta: IImageMetadata[]): void { this.store.setImageMeta(imageMeta); }\n  getImageMeta(): Observable<IImageMetadata[]> { return this.store.getImageMeta(); }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-store-visualizer.js","sourceRoot":"","sources":["../../../../src/lib/implementations/base-store-visualizer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\n\nimport { IDisplayOptions, IRegionStore } from '../contracts/visualizer.contract';\nimport { Region } from '../models/region';\nimport {\n  CanvasToolId,\n  CanvasToolOptions,\n  ColormapNode,\n  IBrushOptions,\n  IWandOptions,\n} from '../contracts/display-types';\nimport type { CanvasToolManager } from '../toolbar/tool-kit/canvas-tool-manager';\nimport type { SamPointTool } from '../toolbar/segmentation/sam-point-tool.service';\nimport { IImageMetadata } from '../contracts/image.contract';\nimport { RegionStore } from '../store/region-store.service';\nimport { VisualizerStore } from '../store/visualizer-store.service';\n\n/**\n * Shared store-delegation base for the OpenSeadragon, napari-js and Plotly\n * `IVisualizer` backends. The entire `IRegionStore` and `IDisplayOptions`\n * surfaces (plus the two classification-colour members) are pure forwarders to\n * the shared `RegionStore` / `VisualizerStore` — so they live here once, as a\n * single source of truth, rather than being copied per backend. (This is the\n * \"cross-backend behaviour that isn't rendering belongs in a shared\n * abstraction\" convention from CLAUDE.md; see\n * docs/history/2026-07-shared-backend-refactor.md.)\n *\n * The on-canvas tool controls (`setActiveTool` and the per-tool setters) live\n * here too: each subclass creates its own {@link CanvasToolManager} over its own\n * tool host and gates pointer/readback in {@link beforeToolChange}.\n *\n * Backend-specific members — `load`/`plot`/`reset`/zoom/`setZIndex`/readback,\n * the region OVERLAY, the tool host, SAM/Cellpose runs, histograms, scale bar,\n * tiling, colormap LUT application — deliberately stay in each subclass. Plotly keeps a Plotly-shape\n * working-set beside the store and redraws it from the store's update events\n * (like the OSD/napari overlays), so it overrides only the colormap and reverse\n * scale (a live restyle) and `exportRegions` (the file name).\n *\n * NOT `@Injectable`: an abstract base doesn't participate in Angular DI. Each\n * subclass stays `@Injectable`, declares its own injected dependencies\n * (including the two stores), and passes them to `super(...)`.\n */\nexport abstract class BaseStoreVisualizer implements IRegionStore, IDisplayOptions {\n  protected constructor(\n    protected readonly regionStore: RegionStore,\n    protected readonly store: VisualizerStore,\n  ) {\n    // Undo, redo and a slice switch replace the regions an in-progress stroke or\n    // SAM prompt was building on — whoever called them (the router writes the\n    // store directly). Service-lifetime, like the store.\n    regionStore.getRegionSetReplaced$().subscribe(() => this.canvasTools.resetAll());\n  }\n\n  // ── IRegionStore → shared RegionStore ────────────────────────────────────\n  setRegions(\n    regions: Region[],\n    showRegionLabel?: boolean,\n    isRegionSaveOn?: boolean,\n    fillColor?: string,\n    append?: boolean,\n  ): void {\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n  getRegionPolygons(): any[] {\n    return this.regionStore.getRegionPolygons();\n  }\n  getRegionUpdateEvent(): Observable<any[]> {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n  setSelectedShapeIndices(indices: number[]): void {\n    this.regionStore.setSelectedShapeIndices(indices);\n  }\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n  selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n  }\n  deleteActiveShape(): void {\n    this.regionStore.deleteActiveShape();\n  }\n  getShowShapeLabel(): boolean {\n    return this.regionStore.getShowShapeLabel();\n  }\n  getShapeColor(): string {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor(): string {\n    return this.regionStore.getFillColor();\n  }\n  // Undo/redo reset the canvas tools through the store's getRegionSetReplaced$ (see the constructor).\n  undo(): void {\n    this.regionStore.undo();\n  }\n  redo(): void {\n    this.regionStore.redo();\n  }\n  canUndo(): boolean {\n    return this.regionStore.canUndo();\n  }\n  canRedo(): boolean {\n    return this.regionStore.canRedo();\n  }\n  getCanUndo$(): Observable<boolean> {\n    return this.regionStore.getCanUndo$();\n  }\n  getCanRedo$(): Observable<boolean> {\n    return this.regionStore.getCanRedo$();\n  }\n  resetUndoHistory(): void {\n    this.regionStore.resetUndoHistory();\n  }\n  importRegions(geoJsonStr: string): Region[] {\n    return this.regionStore.importRegions(geoJsonStr);\n  }\n  exportRegions(regions: Region[]): void {\n    this.regionStore.exportRegions(regions);\n  }\n  getGeoJsonString(regions: Region[]): string {\n    return this.regionStore.getGeoJsonString(regions);\n  }\n\n  // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────\n  enterStackMode(\n    slices: Map<number, Region[]>,\n    initialZ?: number,\n    saveLayout?: 'combined' | 'per-slice-file',\n  ): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void {\n    this.regionStore.exitStackMode();\n  }\n  isStackMode(): boolean {\n    return this.regionStore.isStackMode();\n  }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  setDisplaySlice(z: number): void {\n    this.regionStore.setDisplaySlice(z);\n  }\n  getSliceRegions(): Region[] {\n    return this.regionStore.getSliceRegions();\n  }\n  getStackSaveSlices(): Map<number, Region[]> {\n    return this.regionStore.getStackSaveSlices();\n  }\n\n  // ── IToolController: on-canvas tools → this backend's CanvasToolManager ──\n\n  /** This backend's canvas tools, created by the subclass over its own host. */\n  protected abstract readonly canvasTools: CanvasToolManager;\n\n  /**\n   * Runs before every tool change, for the backend's pointer and readback\n   * gating (pan/zoom off while a tool holds the pointer, a fresh pixel\n   * readback). Return false to arm nothing; the armed tool is disarmed anyway.\n   */\n  protected beforeToolChange(_next: CanvasToolId | null): boolean {\n    return true;\n  }\n\n  /**\n   * Arm one on-canvas tool, disarming the armed one; null — or any id that is\n   * not a canvas tool (a region draw mode, pan) — disarms only. Re-arming the\n   * armed tool applies `options` and keeps its work in progress.\n   */\n  setActiveTool(id: string | null, options?: CanvasToolOptions): void {\n    const next = this.canvasTools.has(id) ? id : null;\n    if (!this.beforeToolChange(next)) {\n      this.canvasTools.deactivate();\n      return;\n    }\n    this.canvasTools.activate(next, options);\n  }\n\n  /** @deprecated Use {@link setActiveTool}(`'wand'`, options) / (null). */\n  setWandMode(active: boolean, options?: IWandOptions): void {\n    this.setToolMode('wand', active, options);\n  }\n  setWandOptions(options: IWandOptions): void {\n    this.canvasTools.setOptions('wand', options);\n  }\n  clearActiveWandRegion(): void {\n    this.canvasTools.reset('wand');\n  }\n  /** @deprecated Use {@link setActiveTool}(`'brush'`, options) / (null). */\n  setBrushMode(active: boolean, options?: IBrushOptions): void {\n    this.setToolMode('brush', active, options);\n  }\n  setBrushOptions(options: IBrushOptions): void {\n    this.canvasTools.setOptions('brush', options ?? {});\n  }\n  /** @deprecated Use {@link setActiveTool}(`'eraseVertex'`, { radius }) / (null). */\n  setVertexEraserMode(active: boolean): void {\n    this.setToolMode('eraseVertex', active);\n  }\n  setVertexEraserRadius(radius: number): void {\n    this.canvasTools.setOptions('eraseVertex', { radius });\n  }\n  /** @deprecated Use {@link setActiveTool}(`'zoomToBox'`) / (null). */\n  setZoomToBoxMode(active: boolean): void {\n    this.setToolMode('zoomToBox', active);\n  }\n  /** @deprecated Use {@link setActiveTool}(`'samPoint'`) / (null). */\n  setSamPointMode(active: boolean): void {\n    this.setToolMode('samPoint', active);\n  }\n  commitSamPoints(): void {\n    this.canvasTools.get<SamPointTool>('samPoint')?.commit();\n  }\n  clearSamPoints(): void {\n    this.canvasTools.get<SamPointTool>('samPoint')?.clear();\n  }\n\n  /** A per-tool setter: arm `id`, or disarm it if it is the armed tool. */\n  private setToolMode(id: CanvasToolId, active: boolean, options?: CanvasToolOptions): void {\n    if (active) this.setActiveTool(id, options);\n    else if (this.canvasTools.activeId === id) this.setActiveTool(null);\n  }\n\n  // ── View lifetime ─────────────────────────────────────────────────────────\n\n  /** Drop what is bound to the view (each backend's own teardown). */\n  abstract unsubscribe(): void;\n\n  /** The view is going away: release what is bound to it (`IViewerBackend.detach`) —\n   *  first the armed tool, whose overlay canvas and ResizeObserver sit on the view's\n   *  container (the backend outlives the view). */\n  detach(): void {\n    this.canvasTools.deactivate();\n    this.unsubscribe();\n  }\n\n  /** Each backend's own fit (Plotly autorange, OSD home, napari camera fit). */\n  abstract autoscale(): void;\n\n  /** Fit the image into the view (`IViewerBackend.fitToView`). */\n  fitToView(): void {\n    this.autoscale();\n  }\n\n  // ── Classification colours → shared VisualizerStore ──────────────────────\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n  setClassificationColor(label: string, color: string): void {\n    this.store.setClassificationColor(label, color);\n  }\n\n  // ── IDisplayOptions → shared VisualizerStore ─────────────────────────────\n  getColormap(): Observable<ColormapNode | null> {\n    return this.store.getColormap();\n  }\n  setColormap(colormap: ColormapNode): void {\n    this.store.setColormap(colormap);\n  }\n  getColormapOptions(): ColormapNode[] {\n    return this.store.getColormapOptions();\n  }\n  getReverseScale(): Observable<boolean> {\n    return this.store.getReverseScale();\n  }\n  setReverseScale(reverscale: boolean): void {\n    this.store.setReverseScale(reverscale);\n  }\n  setImageMeta(imageMeta: IImageMetadata[]): void {\n    this.store.setImageMeta(imageMeta);\n  }\n  getImageMeta(): Observable<IImageMetadata[]> {\n    return this.store.getImageMeta();\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-axes-gizmo.mjs

@@ -0,0 +1,65 @@
+import { AxesLabelsOverlay } from 'napari-js/overlays';
+/**
+ * The 3D coordinate-axes / scale gizmo (review Appendix B): napari-js's `AxesLayer` plus the DOM
+ * X/Y/Z labels that track it (its `AxesLabelsOverlay`) — what the volume and the surface used to
+ * build twice.
+ */
+export class Axes3dGizmo {
+    constructor(viewer, host, box, labels, opts) {
+        this.viewer = viewer;
+        this.layer = viewer.addAxes(box.width, box.height, box.depth, {
+            ...(opts.voxelSize ? { voxelSize: opts.voxelSize } : {}),
+            visible: opts.visible,
+        });
+        this.labels = new AxesLabelsOverlay(host, viewer, { labels, visible: opts.visible });
+    }
+    setVisible(visible) {
+        this.labels.setVisible(visible);
+        this.layer.visible = visible;
+        this.viewer.requestRender();
+    }
+    /** The box's depth changed (the volume's Z-height handle): restretch the axis and its labels. */
+    setDepth(depth, labels) {
+        this.layer.depth = depth;
+        this.labels.setLabels(labels);
+    }
+    destroy() {
+        this.labels.dispose();
+    }
+}
+/** A Plotly-style 3D drag mode, as napari-js's camera drag mode (orbit/turntable → rotate). */
+export function cameraDragMode(mode) {
+    return mode === 'pan' ? 'pan' : mode === 'zoom' ? 'zoom' : 'rotate';
+}
+/**
+ * The 3D view controls every 3D image scene offers: camera drag mode and re-framing, the axes
+ * gizmo's visibility and the surface's wireframe — both persisted in the viewer settings, so the
+ * next mount re-applies them.
+ */
+export function surface3dControls(ctx, gizmo, surface = () => null) {
+    const { viewer, settings } = ctx;
+    return {
+        setSurfaceDragMode: (mode) => viewer.setCameraDragMode(cameraDragMode(mode)),
+        // napari-js frames the union of every 3D layer's bounds, with its adders' framing.
+        resetSurfaceCamera: () => {
+            viewer.fitToLayers();
+            viewer.requestRender();
+        },
+        setAxesVisible: (visible) => {
+            settings.axesVisible = visible;
+            gizmo()?.setVisible(visible);
+        },
+        axesVisible: () => settings.axesVisible,
+        // Surface wireframe (napari-js surface only) — a live layer property, no rebuild needed.
+        setWireframe: (on) => {
+            settings.surfaceWireframe = on;
+            const layer = surface();
+            if (layer) {
+                layer.wireframe = on;
+                viewer.requestRender();
+            }
+        },
+        wireframe: () => settings.surfaceWireframe,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/napari-js/napari-display-state.mjs

@@ -0,0 +1,136 @@
+import { combineLatest } from 'rxjs';
+import { colormapFromLut, reverseColormap, tintColormap } from 'napari-js';
+import { buildColormapLut } from '../../contracts/colormap-lut';
+import { spatialContinuousLut } from '../../spatial/spatial-encoding';
+import { colormapId } from './napari-helpers';
+/** The selected display colormap's value (a name or inline stops), if any. */
+function colormapValue(s) {
+    return s.colormap?.data?.value;
+}
+/** The grayscale display colormap from the store selection (+reverse), defaulting to gray.
+ *  Maps the store colormap node to a napari `Colormap` via the library's LUT factory; the
+ *  multichannel tint ramps are built inside napari-js's `MultiChannelImageView` from each
+ *  channel's hex colour. */
+export function grayscaleColormap(s) {
+    const value = colormapValue(s);
+    const lut = value != null ? buildColormapLut(value, s.reverse) : null;
+    if (lut)
+        return colormapFromLut('gray-cmap', lut);
+    return s.reverse
+        ? colormapFromLut('gray-rev', [
+            [255, 255, 255],
+            [0, 0, 0],
+        ])
+        : 'gray';
+}
+/** A channel's tint colormap (black→colour), flipped for reverse-scale. Invert is not a colormap
+ *  flip: it goes on the layer (`invert`), before gamma, as on the 2D image. */
+export function channelTintColormap(color, s) {
+    const cmap = tintColormap(color);
+    return s.reverse ? reverseColormap(cmap) : cmap;
+}
+/**
+ * Colour map for the volume/isosurface (and the surface and 3D scatter). A real colormap
+ * selection (viridis/magma/…) wins; otherwise the channel's colour tints it (so the channel-dialog
+ * colour swatch recolors the 3D render). Reverse-scale flips the ramp; invert is the layer's own
+ * `invert` (window → invert → gamma → colormap), not a second flip — the two differ once gamma ≠ 1.
+ */
+export function volumeColormap(st, s) {
+    const node = s.colormap;
+    // A colored colormap (viridis/magma/…) drives the volume; the default grayscale family
+    // (gray / Greys / Greys Inv) yields to the channel's colour so the dialog colour swatch
+    // recolors the 3D render.
+    const label = (node?.label ?? '').toLowerCase();
+    const grayFamily = label === '' || label.includes('grey') || label.includes('gray');
+    const value = node?.data?.value;
+    const lut = !grayFamily && value != null ? buildColormapLut(value, false) : null;
+    let cmap = lut ? colormapFromLut('vol-cmap', lut) : tintColormap(st?.color ?? '#ffffff');
+    if (s.reverse)
+        cmap = reverseColormap(cmap);
+    return cmap;
+}
+/** The LUT a continuous spatial layer draws with: the view's own choice, else the display
+ *  colormap and its reverse flag — one rule for the markers, the cloud and both gene maps. */
+export function spatialLut(view, s) {
+    return spatialContinuousLut(colormapValue(s), s.reverse, view.continuousColormap);
+}
+/**
+ * Identity of the colour scale a continuous spatial layer will draw with, for a
+ * cache key: the explicit choice, or else the display colormap and its reverse
+ * flag, since that is what {@link spatialLut} falls back to.
+ *
+ * The gene maps cache their coloured output, so without this in the key a change
+ * of colour scale left the field on screen in the previous colours — the markers
+ * recoloured and the map under them did not.
+ */
+export function continuousColormapKey(view, s) {
+    return [colormapId(view.continuousColormap), colormapId(colormapValue(s)), s.reverse ? 'rev' : ''].join(':');
+}
+/**
+ * The store's display state as the napari layers consume it (review Appendix B, step 3;
+ * NAPARI-SVC-21): one subscription to channel states, colormap, reverse, invert and the selected
+ * channel, a {@link DisplaySnapshot} of the last values seen, and the colormap/LUT derivations
+ * every scene shares.
+ *
+ * The snapshot outlives a scene, as the scenes' builders read it before their own subscription
+ * has emitted; each scene owns the subscription {@link watch} hands it.
+ */
+export class NapariDisplayState {
+    constructor(store) {
+        this.store = store;
+        this.colormap = null;
+        this.reverse = false;
+        this.invert = false;
+    }
+    /**
+     * Follow the store: record the colormap/reverse/invert the builders read, then hand `apply`
+     * the channel states and the selected channel. Emits at once with the current values.
+     */
+    watch(apply) {
+        return combineLatest([
+            this.store.getChannelStates(),
+            this.store.getColormap(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+            this.store.getSelectedChannel(),
+        ]).subscribe(([channels, colormap, reverse, invert, selected]) => {
+            this.colormap = colormap ?? null;
+            this.reverse = reverse;
+            this.invert = invert;
+            apply(channels, selected);
+        });
+    }
+    /**
+     * Follow the invert setting alone: record it for the builders, then hand it to `apply` — for a
+     * scene that draws inverted layers without the channel states (the spatial cloud's density
+     * volumes). Emits at once with the current value.
+     */
+    watchInvert(apply) {
+        return this.store.getInvert().subscribe((invert) => {
+            this.invert = invert;
+            apply(invert);
+        });
+    }
+    /** The spatial scenes' share: they follow the colormap and reverse flag (not invert) through
+     *  their own subscription, because a gene map recolours with them. */
+    record(colormap, reverse) {
+        this.colormap = colormap;
+        this.reverse = reverse;
+    }
+    grayscaleColormap() {
+        return grayscaleColormap(this);
+    }
+    channelTintColormap(color) {
+        return channelTintColormap(color, this);
+    }
+    volumeColormap(st) {
+        return volumeColormap(st, this);
+    }
+    spatialLut(view) {
+        return spatialLut(view, this);
+    }
+    continuousColormapKey(view) {
+        return continuousColormapKey(view, this);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-display-state.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-display-state.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription, combineLatest } from 'rxjs';\nimport { colormapFromLut, reverseColormap, tintColormap } from 'napari-js';\nimport type { Colormap } from 'napari-js';\n\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\nimport { buildColormapLut, Rgb } from '../../contracts/colormap-lut';\nimport { ColormapNode, SpatialViewState } from '../../contracts/display-types';\nimport { spatialContinuousLut } from '../../spatial/spatial-encoding';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { colormapId } from './napari-helpers';\n\n/** The display settings every napari layer's colours are derived from. */\nexport interface DisplaySnapshot {\n  /** The selected display colormap node (a name or inline stops in `data.value`), if any. */\n  colormap: ColormapNode | null;\n  reverse: boolean;\n  invert: boolean;\n}\n\n/** The selected display colormap's value (a name or inline stops), if any. */\nfunction colormapValue(s: DisplaySnapshot): unknown {\n  return s.colormap?.data?.value;\n}\n\n/** The grayscale display colormap from the store selection (+reverse), defaulting to gray.\n *  Maps the store colormap node to a napari `Colormap` via the library's LUT factory; the\n *  multichannel tint ramps are built inside napari-js's `MultiChannelImageView` from each\n *  channel's hex colour. */\nexport function grayscaleColormap(s: DisplaySnapshot): Colormap | string {\n  const value = colormapValue(s);\n  const lut = value != null ? buildColormapLut(value, s.reverse) : null;\n  if (lut) return colormapFromLut('gray-cmap', lut);\n  return s.reverse\n    ? colormapFromLut('gray-rev', [\n        [255, 255, 255],\n        [0, 0, 0],\n      ] as Rgb[])\n    : 'gray';\n}\n\n/** A channel's tint colormap (black→colour), flipped for reverse-scale. Invert is not a colormap\n *  flip: it goes on the layer (`invert`), before gamma, as on the 2D image. */\nexport function channelTintColormap(color: string, s: DisplaySnapshot): Colormap | string {\n  const cmap = tintColormap(color);\n  return s.reverse ? reverseColormap(cmap) : cmap;\n}\n\n/**\n * Colour map for the volume/isosurface (and the surface and 3D scatter). A real colormap\n * selection (viridis/magma/…) wins; otherwise the channel's colour tints it (so the channel-dialog\n * colour swatch recolors the 3D render). Reverse-scale flips the ramp; invert is the layer's own\n * `invert` (window → invert → gamma → colormap), not a second flip — the two differ once gamma ≠ 1.\n */\nexport function volumeColormap(st: IChannelState | undefined, s: DisplaySnapshot): Colormap | string {\n  const node = s.colormap;\n  // A colored colormap (viridis/magma/…) drives the volume; the default grayscale family\n  // (gray / Greys / Greys Inv) yields to the channel's colour so the dialog colour swatch\n  // recolors the 3D render.\n  const label = (node?.label ?? '').toLowerCase();\n  const grayFamily = label === '' || label.includes('grey') || label.includes('gray');\n  const value = node?.data?.value;\n  const lut = !grayFamily && value != null ? buildColormapLut(value, false) : null;\n  let cmap: Colormap | string = lut ? colormapFromLut('vol-cmap', lut) : tintColormap(st?.color ?? '#ffffff');\n  if (s.reverse) cmap = reverseColormap(cmap);\n  return cmap;\n}\n\n/** The LUT a continuous spatial layer draws with: the view's own choice, else the display\n *  colormap and its reverse flag — one rule for the markers, the cloud and both gene maps. */\nexport function spatialLut(view: SpatialViewState, s: DisplaySnapshot): Rgb[] {\n  return spatialContinuousLut(colormapValue(s), s.reverse, view.continuousColormap);\n}\n\n/**\n * Identity of the colour scale a continuous spatial layer will draw with, for a\n * cache key: the explicit choice, or else the display colormap and its reverse\n * flag, since that is what {@link spatialLut} falls back to.\n *\n * The gene maps cache their coloured output, so without this in the key a change\n * of colour scale left the field on screen in the previous colours — the markers\n * recoloured and the map under them did not.\n */\nexport function continuousColormapKey(view: SpatialViewState, s: DisplaySnapshot): string {\n  return [colormapId(view.continuousColormap), colormapId(colormapValue(s)), s.reverse ? 'rev' : ''].join(':');\n}\n\n/**\n * The store's display state as the napari layers consume it (review Appendix B, step 3;\n * NAPARI-SVC-21): one subscription to channel states, colormap, reverse, invert and the selected\n * channel, a {@link DisplaySnapshot} of the last values seen, and the colormap/LUT derivations\n * every scene shares.\n *\n * The snapshot outlives a scene, as the scenes' builders read it before their own subscription\n * has emitted; each scene owns the subscription {@link watch} hands it.\n */\nexport class NapariDisplayState implements DisplaySnapshot {\n  colormap: ColormapNode | null = null;\n  reverse = false;\n  invert = false;\n\n  constructor(private readonly store: VisualizerStore) {}\n\n  /**\n   * Follow the store: record the colormap/reverse/invert the builders read, then hand `apply`\n   * the channel states and the selected channel. Emits at once with the current values.\n   */\n  watch(apply: (channels: IChannelState[], selected: number) => void): Subscription {\n    return combineLatest([\n      this.store.getChannelStates(),\n      this.store.getColormap(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getSelectedChannel(),\n    ]).subscribe(([channels, colormap, reverse, invert, selected]) => {\n      this.colormap = (colormap as ColormapNode) ?? null;\n      this.reverse = reverse;\n      this.invert = invert;\n      apply(channels, selected);\n    });\n  }\n\n  /**\n   * Follow the invert setting alone: record it for the builders, then hand it to `apply` — for a\n   * scene that draws inverted layers without the channel states (the spatial cloud's density\n   * volumes). Emits at once with the current value.\n   */\n  watchInvert(apply: (invert: boolean) => void): Subscription {\n    return this.store.getInvert().subscribe((invert) => {\n      this.invert = invert;\n      apply(invert);\n    });\n  }\n\n  /** The spatial scenes' share: they follow the colormap and reverse flag (not invert) through\n   *  their own subscription, because a gene map recolours with them. */\n  record(colormap: ColormapNode | null, reverse: boolean): void {\n    this.colormap = colormap;\n    this.reverse = reverse;\n  }\n\n  grayscaleColormap(): Colormap | string {\n    return grayscaleColormap(this);\n  }\n  channelTintColormap(color: string): Colormap | string {\n    return channelTintColormap(color, this);\n  }\n  volumeColormap(st: IChannelState | undefined): Colormap | string {\n    return volumeColormap(st, this);\n  }\n  spatialLut(view: SpatialViewState): Rgb[] {\n    return spatialLut(view, this);\n  }\n  continuousColormapKey(view: SpatialViewState): string {\n    return continuousColormapKey(view, this);\n  }\n}\n"]}