@jax-data-science/sci-image-visualizer 0.3.3 → 0.4.0

package/esm2022/lib/routing-visualizer.service.mjs

@@ -1,9 +1,17 @@
-import { Inject, Injectable } from '@angular/core';
-import { combineLatest } from 'rxjs';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { combineLatest, firstValueFrom } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { PlotlyService } from './implementations/plotly/plotly.service';
 import { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';
-import { PlotType, isNapari3d, isNapariScatter } from './contracts/plot-type';
+import { PlotType, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d } from './contracts/plot-type';
+import { SPATIAL_DATA_PORT } from './contracts/ports/spatial-data.port';
+import { isCategoricalColumn } from './contracts/spatial-dataset.contract';
+import { resolveCategoryColors } from './spatial/spatial-encoding';
+import { sectionsOf } from './spatial/spatial-sections';
+import { observationsInSlice, volumeImageRef, } from './spatial/spatial-volume-image';
+import { emptySelection, selectByCategory, selectByIndices, selectInRegions, selectInRegionsProjected, } from './spatial/spatial-selection';
+import { RegionStore } from './store/region-store.service';
+import { SpatialSelectionStore } from './store/spatial-selection.service';
 import { VisualizerStore } from './store/visualizer-store.service';
 import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
 import { VIZ_CONFIG } from './contracts/viz-config';
@@ -12,6 +20,8 @@ import * as i1 from "./implementations/plotly/plotly.service";
 import * as i2 from "./implementations/osd/openseadragon-visualizer.service";
 import * as i3 from "./implementations/napari-js/napari-visualizer.service";
 import * as i4 from "./store/visualizer-store.service";
+import * as i5 from "./store/region-store.service";
+import * as i6 from "./store/spatial-selection.service";
 /**
  * Backend selector. Routes per plot type:
  *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,
@@ -74,12 +84,18 @@ function autoWindowFromHistogram(h, saturation) {
     return [min, max];
 }
 export class RoutingVisualizerService {
-    constructor(plotly, osd, napari, store, config) {
+    constructor(plotly, osd, napari, store, config, 
+    // Optional: a host that serves no spatial-omics data binds nothing,
+    // and `getSpatialControls()` then returns null.
+    regionStore, selectionStore, spatialData = null) {
         this.plotly = plotly;
         this.osd = osd;
         this.napari = napari;
         this.store = store;
         this.config = config;
+        this.regionStore = regionStore;
+        this.selectionStore = selectionStore;
+        this.spatialData = spatialData;
         this.currentPlotType = PlotType.IMAGE;
         this.lastRendered = null;
         /** OSD failed for the *current* render cycle (e.g. a fresh file still caching
@@ -91,18 +107,33 @@ export class RoutingVisualizerService {
         /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).
          *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */
         this.napariFellBack = false;
+        /** Memoised so consumers can hold the object across calls. */
+        this.spatialControls = null;
+        /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously
+         *  — it runs from a button click and must not await a round-trip. */
+        this.currentSpatialDataset = null;
+        /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a
+         *  region drawn over one section from selecting the whole depth behind it. */
+        this.currentZIndex = 0;
+        this.spatialDatasetSub = null;
     }
     isImageType(t) {
         return t === PlotType.IMAGE;
     }
-    /** The 2D napari types (image + region-centroid scatter) — a 2D fallback chain (OSD, then Plotly). */
+    /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain
+     *  (OSD, then Plotly).
+     *
+     *  NOTE for SPATIAL_OMICS: only napari-js draws the observation markers. If it fails (no WebGPU,
+     *  device loss) the fallback renders the tissue image ALONE — the spatial layer is absent, not
+     *  degraded. That is deliberate for now: showing the slide beats showing nothing, and a Plotly
+     *  `scattergl` spatial mode is the planned real fallback (see the plot-mode design doc). */
     isNapariImageType(t) {
-        return t === PlotType.NAPARI_IMAGE || isNapariScatter(t);
+        return t === PlotType.NAPARI_IMAGE || isNapariScatter(t) || isSpatialOmics(t);
     }
-    /** The 3D napari types (volume/isosurface, either resolution) — no 2D fallback exists (OSD is
-     *  image-only), so they fall straight to Plotly. */
+    /** The 3D napari types (volume/isosurface/surface/scatter, plus the 3D spatial cloud) — no 2D
+     *  fallback exists (OSD is image-only), so they fall straight to Plotly. */
     isNapari3dType(t) {
-        return isNapari3d(t);
+        return isNapari3d(t) || isSpatialOmics3d(t);
     }
     /**
      * Backend to attempt for the current plot type this render. The fallback chains below are
@@ -141,6 +172,9 @@ export class RoutingVisualizerService {
     get capabilities() { return this.plotly.capabilities; }
     // ── render / viewport → active renderer ──────────────────────────────
     async load(imageInfo, zIndex) {
+        // A stack can open away from slice 0 (`initialZIndex` — a volume opens
+        // mid-specimen), and that arrives here rather than through setZIndex.
+        this.currentZIndex = zIndex;
         const backend = this.imageBackend();
         if (backend === this.napari) {
             try {
@@ -223,7 +257,10 @@ export class RoutingVisualizerService {
         this.plotly.setImageSmoothingEnabled(enabled);
     }
     setShowStack(showstack) { this.renderer().setShowStack(showstack); }
-    setZIndex(zIndex) { this.renderer().setZIndex(zIndex); }
+    setZIndex(zIndex) {
+        this.currentZIndex = zIndex;
+        this.renderer().setZIndex(zIndex);
+    }
     getTrueImageSize() { return this.renderer().getTrueImageSize(); }
     getCurrentImage() { return this.renderer().getCurrentImage(); }
     getDisplayedPixelData() { return this.renderer().getDisplayedPixelData(); }
@@ -501,6 +538,175 @@ export class RoutingVisualizerService {
     /** Intensity (line-ROI) controls — always Plotly's, since the line profiles
      *  render their inset on Plotly regardless of which backend draws the image. */
     getIntensityControls() { return this.plotly.getIntensityControls(); }
+    /**
+     * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound.
+     *
+     * Implemented HERE rather than on a backend because the state is
+     * backend-neutral: the view state lives in the shared `VisualizerStore` (like
+     * the colormap), so the controls keep working across a plot-type switch and a
+     * host can drive them before any backend has mounted.
+     */
+    getSpatialControls() {
+        const port = this.spatialData;
+        if (!port)
+            return null;
+        // Mirror the dataset (and drop a stale selection when it changes — the masks
+        // are index-based, so they are meaningless against different observations).
+        this.spatialDatasetSub ??= port.getDataset$().subscribe((dataset) => {
+            const changed = dataset?.id !== this.currentSpatialDataset?.id;
+            this.currentSpatialDataset = dataset;
+            if (!changed)
+                return;
+            this.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));
+            // A colour source the new dataset cannot satisfy would leave the map flat
+            // while the panel and the charts kept naming the old column — so drop it,
+            // and only it: point size, opacity and the rest are the user's preferences,
+            // not the previous dataset's state.
+            const by = this.store.currentSpatialView().colorBy;
+            if (by && !this.canColorBy(dataset, by))
+                this.store.setSpatialView({ colorBy: null });
+        });
+        this.spatialControls ??= {
+            getDataset$: () => port.getDataset$(),
+            getViewState$: () => this.store.getSpatialView$(),
+            viewState: () => this.store.currentSpatialView(),
+            setViewState: (partial) => this.store.setSpatialView(partial),
+            // The hint SEEDS the toggle when the source changes, and nothing consults it
+            // afterwards. It used to be ORed in at render time, which meant an unchecked
+            // box could not turn log scaling off for a hinted column — and the linked
+            // chart, which reads `logScale` alone, disagreed with the map about what it
+            // was showing. One authority, set once per source.
+            colorByColumn: (name) => {
+                const meta = this.currentSpatialDataset?.columns.find((c) => c.name === name);
+                const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;
+                this.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });
+            },
+            colorByFeature: (name) => this.store.setSpatialView({
+                colorBy: { kind: 'feature', name },
+                logScale: !!this.currentSpatialDataset?.features?.logScaleHint,
+            }),
+            clearColorBy: () => this.store.setSpatialView({ colorBy: null }),
+            searchFeatures: async (query, limit = 50) => {
+                // Prefer the port's search (a 31k-gene dataset does not ship its names);
+                // otherwise filter whatever the manifest inlined.
+                if (port.searchFeatures)
+                    return port.searchFeatures(query, limit);
+                const dataset = await firstValueFrom(port.getDataset$());
+                const names = dataset?.features?.names ?? [];
+                const q = query.toLowerCase();
+                return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);
+            },
+            categoryColors: async (name) => {
+                const column = await port.getColumn(name);
+                if (!isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
+                }
+                // Resolved by the SAME function the renderer uses, so a legend swatch
+                // can never disagree with the colour on screen.
+                return resolveCategoryColors(column.meta);
+            },
+            continuousValues: async (source) => {
+                if (source.kind === 'feature')
+                    return port.getFeatureVector(source.name);
+                const column = await port.getColumn(source.name);
+                if (isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${source.name}" is categorical — it has no values to chart`);
+                }
+                return column.values;
+            },
+            categoricalView: async (name) => {
+                const column = await port.getColumn(name);
+                if (!isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
+                }
+                return {
+                    name,
+                    categories: column.meta.categories,
+                    colors: resolveCategoryColors(column.meta),
+                    codes: column.codes,
+                };
+            },
+            // Spread rather than always defined: `getEmbedding` is optional on both the port
+            // and this facade, and a panel checks for its presence to decide whether the view
+            // is offered at all. Defining it as a function that rejects would make an
+            // embedding-less source look like a broken one.
+            ...(port.getEmbedding
+                ? { getEmbedding: (name) => port.getEmbedding(name) }
+                : {}),
+            categoricalColumns: () => (this.currentSpatialDataset?.columns ?? [])
+                .filter((c) => c.kind === 'categorical')
+                .map((c) => c.name),
+            // Memoized on the observations object, so the renderer's own lookup and
+            // this one are the same single scan of up to 3.7M z values.
+            sampledSections: () => {
+                const obs = this.currentSpatialDataset?.observations;
+                return obs ? sectionsOf(obs) : null;
+            },
+            getSelection$: () => this.selectionStore.getSelection$(),
+            selectFromRegions: () => {
+                const dataset = this.currentSpatialDataset;
+                if (!dataset)
+                    return 0;
+                const regions = this.regionStore.getRegions();
+                // The union of every drawn region — so every ROI tool the library
+                // already has doubles as a spatial selection tool.
+                //
+                // In the 3D cloud there is no data-space affine to push a drawn shape
+                // through, so the observations are projected to canvas pixels by the
+                // renderer (which owns the camera) and tested in screen space instead.
+                // Falls back to the 2D path whenever the cloud is not mounted.
+                const projected = isSpatialOmics3d(this.currentPlotType)
+                    ? this.napari.getSpatialScreenProjection(dataset.observations)
+                    : null;
+                // In the 2D view of a volume-backed dataset the shape was drawn over ONE
+                // section, in the volume's pixel grid: it selects the cells of that
+                // section, not the whole depth of brain standing behind them.
+                const volume = !dataset.imageRef ? dataset.volume : undefined;
+                const selection = projected
+                    ? selectInRegionsProjected(projected, dataset.observations.count, regions)
+                    : selectInRegions(dataset.observations, volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef, regions, volume
+                        ? observationsInSlice(dataset.observations, volume, this.currentZIndex)
+                        : undefined);
+                this.selectionStore.set(selection);
+                return selection.count;
+            },
+            selectCategory: async (column, categoryIndex) => {
+                const loaded = await port.getColumn(column);
+                if (!isCategoricalColumn(loaded)) {
+                    throw new Error(`[spatial] column "${column}" is continuous — it has no categories`);
+                }
+                const selection = selectByCategory(loaded.codes, categoryIndex);
+                this.selectionStore.set(selection);
+                return selection.count;
+            },
+            selectIndices: (indices) => {
+                const count = this.currentSpatialDataset?.observations.count ?? 0;
+                if (count === 0)
+                    return 0;
+                const selection = selectByIndices(indices, count);
+                this.selectionStore.set(selection);
+                return selection.count;
+            },
+            clearSelection: () => this.selectionStore.clear(),
+        };
+        return this.spatialControls;
+    }
+    /**
+     * Whether `dataset` can answer this colour source.
+     *
+     * A column is checkable against the declared list. A gene is checkable only when
+     * the dataset inlines its feature names — a dataset too wide to inline them
+     * (typeahead-only) keeps the source, and a name that turns out not to exist
+     * surfaces as the chart's "could not be charted" rather than as a silent reset.
+     */
+    canColorBy(dataset, by) {
+        if (!dataset)
+            return false;
+        if (by.kind === 'column')
+            return dataset.columns.some((c) => c.name === by.name);
+        const names = dataset.features?.names;
+        return !!dataset.features && (!names || names.includes(by.name));
+    }
     /** Load pixel frames for intensity sampling when OpenSeadragon owns the image
      *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */
     ensureIntensitySampling(imageInfo, zIndex) {
@@ -521,7 +727,7 @@ export class RoutingVisualizerService {
         this.plotly.unsubscribe();
         this.osd.unsubscribe();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, deps: [{ token: i1.PlotlyService }, { token: i2.OpenSeadragonVisualizerService }, { token: i3.NapariVisualizerService }, { token: i4.VisualizerStore }, { token: VIZ_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, deps: [{ token: i1.PlotlyService }, { token: i2.OpenSeadragonVisualizerService }, { token: i3.NapariVisualizerService }, { token: i4.VisualizerStore }, { token: VIZ_CONFIG }, { token: i5.RegionStore }, { token: i6.SpatialSelectionStore }, { token: SPATIAL_DATA_PORT, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: RoutingVisualizerService, decorators: [{
@@ -530,5 +736,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
         }], ctorParameters: () => [{ type: i1.PlotlyService }, { type: i2.OpenSeadragonVisualizerService }, { type: i3.NapariVisualizerService }, { type: i4.VisualizerStore }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [VIZ_CONFIG]
+                }] }, { type: i5.RegionStore }, { type: i6.SpatialSelectionStore }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [SPATIAL_DATA_PORT]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-visualizer.service.js","sourceRoot":"","sources":["../../../src/lib/routing-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Observable, combineLatest } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { Region } from './models/region';\nimport { ClassPreset, PresetSet } from './models/class-preset';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport { PlotType, PlotTypeDescriptor, isNapari3d, isNapariScatter } from './contracts/plot-type';\nimport { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls } from './contracts/visualizer.contract';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\n\n/**\n * Backend selector. Routes per plot type:\n *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,\n *    zoomable raster backed by the jit-service tile endpoints. It's the default\n *    view and supports the region overlay/tools and (for grayscale) the\n *    colormap, applied client-side via the tile pixel pipeline.\n *  - every other plot type (heatmap, surface, contour, scatter, line,\n *    scatter3d, isosurface) renders through Plotly.\n *\n * Only the **render + viewport** path is routed. Region state, display options\n * (colormap/LUT), and the long-lived observables always live in Plotly (the\n * shared store) so both backends stay in sync; OSD reads them to drive its own\n * overlay and tile recoloring.\n *\n * The Image type renders through OpenSeadragon; a failed OSD load falls back to\n * Plotly for that image only (see `osdFellBack`) so it still renders.\n */\n/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.\n *  Package-internal predicate (property-based so it also matches plain objects\n *  after a drag round-trip). */\nfunction isProfileRegion(r: any): boolean {\n  return r?.kind === 'profile';\n}\n\n/** Saturation-based auto-window: pick [min,max] so ~`saturation` of pixels clip\n *  at each end of the histogram. A dominant first/last bin (unscanned padding /\n *  clipped background) is dropped so it doesn't skew the range. */\nfunction autoWindowFromHistogram(h: IHistogram, saturation: number): [number, number] {\n  const counts = h.counts.slice();\n  const n = counts.length;\n  if (n === 0) return [0, 255];\n  if (n > 2 && counts[0] > counts[1]) counts[0] = 0;\n  if (n > 2 && counts[n - 1] > counts[n - 2]) counts[n - 1] = 0;\n  let total = 0;\n  for (const c of counts) total += c;\n  if (total <= 0) return [0, 255];\n  const target = total * Math.max(0, Math.min(0.5, saturation));\n  let acc = 0;\n  let min = h.bins[0];\n  for (let i = 0; i < n; i++) {\n    acc += counts[i];\n    if (acc > target) { min = h.bins[i]; break; }\n  }\n  acc = 0;\n  let max = h.bins[n - 1];\n  for (let i = n - 1; i >= 0; i--) {\n    acc += counts[i];\n    if (acc > target) { max = h.bins[i]; break; }\n  }\n  return [min, max];\n}\n\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi {\n\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IVisualizer | null = null;\n  /** OSD failed for the *current* render cycle (e.g. a fresh file still caching\n   *  past the deadline) → fall back to Plotly for this image only. Reset by\n   *  reset() at the start of every render cycle, so the next file — or a\n   *  re-select once the file is cached — retries OSD. (Was a permanent flag,\n   *  which left the whole session stuck on Plotly after one slow load.) */\n  private osdFellBack = false;\n  /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).\n   *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */\n  private napariFellBack = false;\n\n  constructor(private plotly: PlotlyService,\n              private osd: OpenSeadragonVisualizerService,\n              private napari: NapariVisualizerService,\n              private store: VisualizerStore,\n              @Inject(VIZ_CONFIG) private config: VizConfig) {}\n\n  private isImageType(t: PlotType): boolean {\n    return t === PlotType.IMAGE;\n  }\n\n  /** The 2D napari types (image + region-centroid scatter) — a 2D fallback chain (OSD, then Plotly). */\n  private isNapariImageType(t: PlotType): boolean {\n    return t === PlotType.NAPARI_IMAGE || isNapariScatter(t);\n  }\n\n  /** The 3D napari types (volume/isosurface, either resolution) — no 2D fallback exists (OSD is\n   *  image-only), so they fall straight to Plotly. */\n  private isNapari3dType(t: PlotType): boolean {\n    return isNapari3d(t);\n  }\n\n  /**\n   * Backend to attempt for the current plot type this render. The fallback chains below are\n   * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the\n   * backend `plot()` selects (no load/plot backend mismatch):\n   *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.\n   *  - plain `IMAGE` (no opt-in): OSD → Plotly.\n   *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).\n   */\n  private imageBackend(): IVisualizer {\n    const t = this.currentPlotType;\n    // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).\n    if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {\n      if (!this.napariFellBack) return this.napari;\n      if (!this.osdFellBack) return this.osd;\n      return this.plotly;\n    }\n    // Plain Image type (no napari opt-in): OSD, then Plotly.\n    if (this.isImageType(t)) {\n      return this.osdFellBack ? this.plotly : this.osd;\n    }\n    // 3D napari types: napari-js, with Plotly as the only viable fallback.\n    if (this.isNapari3dType(t)) {\n      return this.napariFellBack ? this.plotly : this.napari;\n    }\n    return this.plotly;\n  }\n\n  /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */\n  private renderer(): IVisualizer {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities { return this.plotly.capabilities; }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<any> {\n    const backend = this.imageBackend();\n    if (backend === this.napari) {\n      try {\n        return await this.napari.load(imageInfo, zIndex);\n      } catch (err) {\n        this.napariFellBack = true;\n        // Mirror imageBackend()'s fallback so load + plot pick the same backend:\n        //  - 3D napari types have no 2D fallback → straight to Plotly.\n        //  - 2D image → OSD, then Plotly.\n        if (this.isNapari3dType(this.currentPlotType)) {\n          console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);\n          return this.plotly.load(imageInfo, zIndex);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n    }\n    return this.plotly.load(imageInfo, zIndex);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(imageInfo: IImageInfo, zIndex: number): Promise<any> {\n    try {\n      return await this.osd.load(imageInfo, zIndex);\n    } catch (err) {\n      console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);\n      this.osdFellBack = true;\n      return this.plotly.load(imageInfo, zIndex);\n    }\n  }\n  plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number,\n       plotType: PlotType, inPlace?: boolean): Promise<boolean> {\n    this.currentPlotType = plotType;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n  }\n  reloadAndPlot(): void { this.plotly.reloadAndPlot(); }\n  reset(): void {\n    // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior\n    // per-image fallback) and tear down whatever's on screen.\n    this.osdFellBack = false;\n    this.napariFellBack = false;\n    this.renderer().reset();\n  }\n  relayout(trueImageSize?: number[]): void { this.renderer().relayout(trueImageSize); }\n  resetAxes(): void { this.renderer().resetAxes(); }\n  autoscale(): void { this.renderer().autoscale(); }\n  zoomIn(): void { this.renderer().zoomIn(); }\n  zoomOut(): void { this.renderer().zoomOut(); }\n  setDragMode(mode: string | false): void { this.renderer().setDragMode(mode); }\n  // Set on both backends (not just the active renderer): consumers call this\n  // before the first render, when `renderer()` is still the Plotly default, so\n  // OSD must receive the flag to honour it at viewer creation.\n  setNavigatorVisible(visible: boolean): void {\n    this.osd.setNavigatorVisible(visible);\n    this.plotly.setNavigatorVisible(visible);\n  }\n  // Set on both backends (see setNavigatorVisible): consumers may set it before\n  // the first render, when the active renderer is still Plotly.\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.osd.setImageSmoothingEnabled(enabled);\n    this.plotly.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void { this.renderer().setShowStack(showstack); }\n  setZIndex(zIndex: number): void { this.renderer().setZIndex(zIndex); }\n  getTrueImageSize(): { width: number; height: number } | null { return this.renderer().getTrueImageSize(); }\n  getCurrentImage(): Promise<Image | null> { return this.renderer().getCurrentImage(); }\n  getDisplayedPixelData(): PixelData | null { return this.renderer().getDisplayedPixelData(); }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void { this.renderer().downloadImage(); }\n  exportComposite(): void { this.renderer().exportComposite(); }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.plotly.setPlotType(plotType);\n  }\n  setSurfaceDragMode(mode: string): void { this.renderer().setSurfaceDragMode(mode); }\n  resetSurfaceCamera(): void { this.renderer().resetSurfaceCamera(); }\n  setResolutionScale(scale: number): void { this.renderer().setResolutionScale?.(scale); }\n  getResolutionScale(): number { return this.renderer().getResolutionScale?.() ?? 1; }\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the\n    // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).\n    return this.plotly.getPlotTypeDescriptors();\n  }\n\n  // ── long-lived observables + stack flags ──────────────────────────────────\n  setStackLoading(b: boolean): void { this.plotly.setStackLoading(b); }\n  // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is\n  // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete\n  // backend classes don't all declare the optional contract method, so call it via IVisualizer.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IVisualizer[]) {\n      backend.cancelLoading?.();\n    }\n  }\n  // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume\n  // assembly) drive their own subjects, so merge all three into one stable stream the host\n  // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)\n  isStackLoading(): Observable<boolean> {\n    return combineLatest([\n      this.plotly.isStackLoading(),\n      this.osd.isStackLoading(),\n      this.napari.isStackLoading(),\n    ]).pipe(map((flags) => flags.some(Boolean)));\n  }\n  getStackLoadingProgress(): Observable<number> {\n    // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain\n    // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the\n    // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag\n    // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.\n    const track = (v: IVisualizer): Observable<[number, boolean]> =>\n      combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);\n    return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(\n      map((pairs) => {\n        const active = pairs.filter(([, loading]) => loading).map(([p]) => p);\n        return active.length ? Math.max(...active) : 0;\n      }),\n    );\n  }\n  getAutoscaleEvent(): Observable<any> { return this.plotly.getAutoscaleEvent(); }\n  getIntensityProfile$(): Observable<IntensityProfile[]> { return this.plotly.getIntensityProfile$(); }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly, which\n  // owns the profile stream regardless of which backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles); }\n\n  // ── regions → active renderer ────────────────────────────────────────\n  // Region *state* lives in the shared RegionStore; both backends implement\n  // IRegionStore by delegating to it. We route through the active renderer\n  // (not hardcoded Plotly) so the backend on screen also *renders* the change:\n  // Plotly relayouts its shapes, OpenSeadragon's overlay redraws from the store\n  // update event. Either way the same store is the single source of truth.\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void {\n    this.renderer().setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] { return this.renderer().getRegions(); }\n  getRegionPolygons(): any[] { return this.renderer().getRegionPolygons(); }\n  getRegionUpdateEvent(): Observable<any[]> { return this.renderer().getRegionUpdateEvent(); }\n  setSelectedShapeIndices(indices: number[]): void { this.renderer().setSelectedShapeIndices(indices); }\n  selectRegion(region: Region): void { this.renderer().selectRegion(region); }\n  getSelectedShapeIndices$(): Observable<number[]> { return this.renderer().getSelectedShapeIndices$(); }\n  deleteActiveShape(): void { this.renderer().deleteActiveShape(); }\n  getShowShapeLabel(): boolean { return this.renderer().getShowShapeLabel(); }\n  getShapeColor(): string { return this.renderer().getShapeColor(); }\n  getFillColor(): string { return this.renderer().getFillColor(); }\n  getClassificationColors(): Map<string, string> { return this.renderer().getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void {\n    this.renderer().setClassificationColor(label, color); }\n  // Annotation-class presets live in the shared VisualizerStore (backend-neutral\n  // session state), so route straight to it rather than through renderer(). (jit-ui#70)\n  getPresetSet(): PresetSet { return this.store.getPresetSet(); }\n  getPresetSet$(): Observable<PresetSet> { return this.store.getPresetSet$(); }\n  setPresetSet(set: PresetSet): void { this.store.setPresetSet(set); }\n  upsertClass(preset: ClassPreset): void { this.store.upsertClass(preset); }\n  removeClass(name: string): void { this.store.removeClass(name); }\n  resetPresets(): void { this.store.resetPresets(); }\n  plotPreviousShapes(): void { this.renderer().plotPreviousShapes(); }\n  setPreviousShapes(shapes: any[]): void { this.renderer().setPreviousShapes(shapes); }\n  getPreviousShapes(): any[] { return this.renderer().getPreviousShapes(); }\n  // Undo state is owned by the shared RegionStore (same instance for both\n  // backends), so routing through the active renderer is safe and stable.\n  undo(): void { this.renderer().undo(); }\n  redo(): void { this.renderer().redo(); }\n  canUndo(): boolean { return this.renderer().canUndo(); }\n  canRedo(): boolean { return this.renderer().canRedo(); }\n  getCanUndo$(): Observable<boolean> { return this.renderer().getCanUndo$(); }\n  getCanRedo$(): Observable<boolean> { return this.renderer().getCanRedo$(); }\n  resetUndoHistory(): void { this.renderer().resetUndoHistory(); }\n  importRegions(geoJsonStr: string): Region[] { return this.renderer().importRegions(geoJsonStr); }\n  exportRegions(regions: Region[]): void { this.renderer().exportRegions(regions); }\n  getGeoJsonString(regions: Region[]): string { return this.renderer().getGeoJsonString(regions); }\n\n  // ── Per-slice z-stack regions (jit-ui#93) — the RegionStore is shared across\n  //    backends, so routing to the active renderer hits the same store. ──────\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.renderer().enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void { this.renderer().exitStackMode(); }\n  isStackMode(): boolean { return this.renderer().isStackMode(); }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.renderer().getStackSaveLayout(); }\n  setDisplaySlice(z: number): void { this.renderer().setDisplaySlice(z); }\n  getSliceRegions(): Region[] { return this.renderer().getSliceRegions(); }\n  getStackSaveSlices(): Map<number, Region[]> { return this.renderer().getStackSaveSlices(); }\n  /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged\n   *  with its zero-based Region.z; profile lines excluded. Flat annotation set\n   *  outside stack mode. */\n  getSliceAnnotationRegions(): Region[] {\n    return this.renderer().getSliceRegions().filter((r) => !isProfileRegion(r));\n  }\n  /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):\n   *  slice index → that slice's annotation regions (profile lines excluded),\n   *  including now-empty slices that were loaded non-empty (so they overwrite). */\n  getStackSaveAnnotationSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    for (const [z, regs] of this.renderer().getStackSaveSlices()) {\n      out.set(z, regs.filter((r) => !isProfileRegion(r)));\n    }\n    return out;\n  }\n\n  /** Authoritative full-resolution image size for mask export. Prefers the\n   *  active renderer's reported size, falling back to the image metadata (x/y\n   *  are the full-res pixel dimensions used across the app). Rejects non-finite\n   *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is\n   *  fully laid out, which would otherwise crash mask creation. */\n  getMaskImageSize(): { width: number; height: number } | null {\n    const valid = (s: { width: number; height: number } | null | undefined) =>\n      s && Number.isFinite(s.width) && Number.isFinite(s.height) &&\n      s.width >= 1 && s.height >= 1\n        ? { width: Math.round(s.width), height: Math.round(s.height) }\n        : null;\n\n    const fromRenderer = valid(this.getTrueImageSize());\n    if (fromRenderer) return fromRenderer;\n\n    let meta: IImageMetadata[] = [];\n    this.getImageMeta().subscribe((m) => (meta = m)).unsubscribe();\n    const m0 = meta?.[0];\n    return m0 ? valid({ width: m0.x, height: m0.y }) : null;\n  }\n\n  // ── IRegionEditorApi: annotation-only surface for the Region Editor ───\n  // Intensity-profile lines (kind='profile') belong to the intensity tool, not\n  // the editor. These methods give external consumers an annotation-only view\n  // and guarantee profile lines are preserved. Routing (not the store) owns this\n  // so writes/selection go through renderer() and the active backend re-renders\n  // (Plotly relayouts its shapes in setRegions; it doesn't on regionUpdate$).\n\n  getAnnotationRegions(): Region[] {\n    return this.renderer().getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(regions: Region[], showRegionLabel?: boolean,\n                       isRegionSaveOn?: boolean, fillColor?: string): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop\n    // them, then route through setRegions so the active backend re-renders.\n    const profiles = this.renderer().getRegions().filter((r) => isProfileRegion(r));\n    const annotations = (regions || []).filter((r) => !isProfileRegion(r));\n    this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);\n  }\n  getSelectedRegions$(): Observable<Region[]> {\n    // Map the internal index-based selection to the selected annotation regions.\n    return this.getSelectedShapeIndices$().pipe(\n      map((idxs) => {\n        const regs = this.renderer().getRegions();\n        return idxs\n          .map((i) => regs[i])\n          .filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.renderer().getRegions();\n    const indices = (regions || [])\n      .map((r) => regs.findIndex((x) => x.id === r.id))\n      .filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer.\n  setWandMode(active: boolean, options?: any): void { this.renderer().setWandMode(active, options); }\n  setWandOptions(options: any): void { this.renderer().setWandOptions(options); }\n  clearActiveWandRegion(): void { this.renderer().clearActiveWandRegion(); }\n  setBrushMode(active: boolean, options?: any): void { this.renderer().setBrushMode(active, options); }\n  setBrushOptions(options: any): void { this.renderer().setBrushOptions(options); }\n  setVertexEraserMode(active: boolean): void { this.renderer().setVertexEraserMode(active); }\n  setVertexEraserRadius(radius: number): void { this.renderer().setVertexEraserRadius(radius); }\n  setZoomToBoxMode(active: boolean): void { this.renderer().setZoomToBoxMode(active); }\n  segmentRectangles(): Promise<number> { return this.renderer().segmentRectangles(); }\n  segmentRectanglesCellpose(): Promise<number> { return this.renderer().segmentRectanglesCellpose(); }\n  setSamModel(id: string): void { this.renderer().setSamModel(id); }\n  setSamPointMode(active: boolean): void { this.renderer().setSamPointMode(active); }\n  commitSamPoints(): void { this.renderer().commitSamPoints(); }\n  clearSamPoints(): void { this.renderer().clearSamPoints(); }\n\n  // ── display options ──────────────────────────────────────────────────\n  // State lives in the shared VisualizerStore — reads go straight to it.\n  // The two SETTERS still route through Plotly because its implementations\n  // carry render glue beyond the store write (a live Plotly.restyle of\n  // colorscale/reversescale on the mounted heatmap); OSD recolors via its own\n  // store subscription either way.\n  getColormap(): Observable<any> { return this.store.getColormap(); }\n  setColormap(colormap: any): void { this.plotly.setColormap(colormap); }\n  getColormapOptions(): any { return this.store.getColormapOptions(); }\n  getReverseScale(): Observable<boolean> { return this.store.getReverseScale(); }\n  setReverseScale(reverscale: any): void { this.plotly.setReverseScale(reverscale); }\n  setImageMeta(imageMeta: IImageMetadata[]): void { this.store.setImageMeta(imageMeta); }\n  getImageMeta(): Observable<IImageMetadata[]> { return this.store.getImageMeta(); }\n\n  // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────\n  // Channel/grayscale/invert state lives in the shared VisualizerStore; both\n  // backends subscribe and recolor live, so setters just write the store. The\n  // histogram comes from whichever backend is on screen (its native pixels).\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    return this.renderer().getHistogram(channelIndex, bins);\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return this.renderer().getHistogram$(channelIndex, bins);\n  }\n  /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */\n  exportData(): void { this.renderer().exportData(); }\n  getChannels$(): Observable<IChannelState[]> { return this.store.getChannelStates(); }\n  setSelectedChannel(index: number): void { this.store.setSelectedChannel(index); }\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    this.store.setChannelState(index, partial);\n  }\n  resetContrast(indices: number[]): void {\n    // Full reset: window (0..255), gamma (1) AND the channel's default tint.\n    for (const i of indices) this.store.resetChannelState(i);\n  }\n  /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each\n   *  end of its histogram (skipping outlier first/last bins). */\n  autoContrast(indices: number[], saturation: number): void {\n    for (const i of indices) {\n      const h = this.renderer().getHistogram(i, 256);\n      if (!h) continue;\n      const [min, max] = autoWindowFromHistogram(h, saturation);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> { return this.store.getGrayscale(); }\n  setGrayscale(on: boolean): void { this.store.setGrayscale(on); }\n  getInvert$(): Observable<boolean> { return this.store.getInvert(); }\n  setInvert(on: boolean): void { this.store.setInvert(on); }\n\n  /**\n   * The active backend's region overlay. Falls back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.renderer();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /**\n   * Isosurface controls when available — always Plotly's, since the isosurface\n   * plot type renders on Plotly (OSD only handles the image type).\n   */\n  getIsosurfaceControls(): IIsosurfaceControls | null { return this.renderer().getIsosurfaceControls(); }\n\n  /** 3D scene controls — always Plotly's, since the 3D plot types render on\n   *  Plotly (OSD only handles the image type). */\n  getSurface3dControls(): ISurface3dControls | null { return this.renderer().getSurface3dControls(); }\n\n  /** Intensity (line-ROI) controls — always Plotly's, since the line profiles\n   *  render their inset on Plotly regardless of which backend draws the image. */\n  getIntensityControls(): IIntensityControls | null { return this.plotly.getIntensityControls(); }\n\n  /** Load pixel frames for intensity sampling when OpenSeadragon owns the image\n   *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.plotly.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),\n   *  so the intensity inset can re-sample at the current zoom level. Plotly's own\n   *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.osd.getViewportChange$();\n  }\n\n  /** Re-sample the intensity profiles from a fresh crop of the given image-pixel\n   *  ROI at display resolution (sampling always lives in Plotly). */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.plotly.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  unsubscribe(): void {\n    this.plotly.unsubscribe();\n    this.osd.unsubscribe();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"routing-visualizer.service.js","sourceRoot":"","sources":["../../../src/lib/routing-visualizer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Observable, Subscription, combineLatest, firstValueFrom } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { Image } from 'image-js';\n\nimport { IImageInfo, IImageMetadata } from './contracts/image.contract';\nimport { Region } from './models/region';\nimport { ClassPreset, PresetSet } from './models/class-preset';\nimport { PlotlyService } from './implementations/plotly/plotly.service';\nimport { OpenSeadragonVisualizerService } from './implementations/osd/openseadragon-visualizer.service';\nimport { PlotType, PlotTypeDescriptor, isNapari3d, isNapariScatter, isSpatialOmics, isSpatialOmics3d } from './contracts/plot-type';\nimport { IVisualizer, PixelData, IntensityProfile, IIsosurfaceControls, IIntensityControls, ISurface3dControls, ISpatialControls } from './contracts/visualizer.contract';\nimport { SPATIAL_DATA_PORT, SpatialDataPort } from './contracts/ports/spatial-data.port';\nimport { SpatialColorBy } from './contracts/display-types';\nimport { SpatialDataset, isCategoricalColumn } from './contracts/spatial-dataset.contract';\nimport { resolveCategoryColors } from './spatial/spatial-encoding';\nimport { sectionsOf } from './spatial/spatial-sections';\nimport {\n  observationsInSlice, volumeImageRef,\n} from './spatial/spatial-volume-image';\nimport {\n  emptySelection,\n  selectByCategory,\n  selectByIndices,\n  selectInRegions,\n  selectInRegionsProjected,\n} from './spatial/spatial-selection';\nimport { RegionStore } from './store/region-store.service';\nimport { SpatialSelectionStore } from './store/spatial-selection.service';\nimport { ViewerCapabilities } from './contracts/capabilities.contract';\nimport { IRegionOverlay } from './contracts/region-overlay.contract';\nimport { IRegionEditorApi } from './contracts/region-editor-api.contract';\nimport { IChannelHistogramApi, IChannelState, IHistogram } from './contracts/channel-histogram-api.contract';\nimport { VisualizerStore } from './store/visualizer-store.service';\nimport { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';\nimport { VIZ_CONFIG, VizConfig } from './contracts/viz-config';\n\n/**\n * Backend selector. Routes per plot type:\n *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,\n *    zoomable raster backed by the jit-service tile endpoints. It's the default\n *    view and supports the region overlay/tools and (for grayscale) the\n *    colormap, applied client-side via the tile pixel pipeline.\n *  - every other plot type (heatmap, surface, contour, scatter, line,\n *    scatter3d, isosurface) renders through Plotly.\n *\n * Only the **render + viewport** path is routed. Region state, display options\n * (colormap/LUT), and the long-lived observables always live in Plotly (the\n * shared store) so both backends stay in sync; OSD reads them to drive its own\n * overlay and tile recoloring.\n *\n * The Image type renders through OpenSeadragon; a failed OSD load falls back to\n * Plotly for that image only (see `osdFellBack`) so it still renders.\n */\n/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.\n *  Package-internal predicate (property-based so it also matches plain objects\n *  after a drag round-trip). */\nfunction isProfileRegion(r: any): boolean {\n  return r?.kind === 'profile';\n}\n\n/** Saturation-based auto-window: pick [min,max] so ~`saturation` of pixels clip\n *  at each end of the histogram. A dominant first/last bin (unscanned padding /\n *  clipped background) is dropped so it doesn't skew the range. */\nfunction autoWindowFromHistogram(h: IHistogram, saturation: number): [number, number] {\n  const counts = h.counts.slice();\n  const n = counts.length;\n  if (n === 0) return [0, 255];\n  if (n > 2 && counts[0] > counts[1]) counts[0] = 0;\n  if (n > 2 && counts[n - 1] > counts[n - 2]) counts[n - 1] = 0;\n  let total = 0;\n  for (const c of counts) total += c;\n  if (total <= 0) return [0, 255];\n  const target = total * Math.max(0, Math.min(0.5, saturation));\n  let acc = 0;\n  let min = h.bins[0];\n  for (let i = 0; i < n; i++) {\n    acc += counts[i];\n    if (acc > target) { min = h.bins[i]; break; }\n  }\n  acc = 0;\n  let max = h.bins[n - 1];\n  for (let i = n - 1; i >= 0; i--) {\n    acc += counts[i];\n    if (acc > target) { max = h.bins[i]; break; }\n  }\n  return [min, max];\n}\n\n@Injectable({ providedIn: 'root' })\nexport class RoutingVisualizerService implements IVisualizer, IRegionEditorApi, IChannelHistogramApi {\n\n  private currentPlotType: PlotType = PlotType.IMAGE;\n  private lastRendered: IVisualizer | null = null;\n  /** OSD failed for the *current* render cycle (e.g. a fresh file still caching\n   *  past the deadline) → fall back to Plotly for this image only. Reset by\n   *  reset() at the start of every render cycle, so the next file — or a\n   *  re-select once the file is cached — retries OSD. (Was a permanent flag,\n   *  which left the whole session stuck on Plotly after one slow load.) */\n  private osdFellBack = false;\n  /** napari-js failed for the current render cycle → fall back to OSD (then Plotly).\n   *  Reset by reset() at the start of every cycle, like {@link osdFellBack}. */\n  private napariFellBack = false;\n\n  constructor(private plotly: PlotlyService,\n              private osd: OpenSeadragonVisualizerService,\n              private napari: NapariVisualizerService,\n              private store: VisualizerStore,\n              @Inject(VIZ_CONFIG) private config: VizConfig,\n              // Optional: a host that serves no spatial-omics data binds nothing,\n              // and `getSpatialControls()` then returns null.\n              private regionStore: RegionStore,\n              private selectionStore: SpatialSelectionStore,\n              @Optional() @Inject(SPATIAL_DATA_PORT)\n              private spatialData: SpatialDataPort | null = null) {}\n\n  private isImageType(t: PlotType): boolean {\n    return t === PlotType.IMAGE;\n  }\n\n  /** The 2D napari types (image, region-centroid scatter, spatial omics) — a 2D fallback chain\n   *  (OSD, then Plotly).\n   *\n   *  NOTE for SPATIAL_OMICS: only napari-js draws the observation markers. If it fails (no WebGPU,\n   *  device loss) the fallback renders the tissue image ALONE — the spatial layer is absent, not\n   *  degraded. That is deliberate for now: showing the slide beats showing nothing, and a Plotly\n   *  `scattergl` spatial mode is the planned real fallback (see the plot-mode design doc). */\n  private isNapariImageType(t: PlotType): boolean {\n    return t === PlotType.NAPARI_IMAGE || isNapariScatter(t) || isSpatialOmics(t);\n  }\n\n  /** The 3D napari types (volume/isosurface/surface/scatter, plus the 3D spatial cloud) — no 2D\n   *  fallback exists (OSD is image-only), so they fall straight to Plotly. */\n  private isNapari3dType(t: PlotType): boolean {\n    return isNapari3d(t) || isSpatialOmics3d(t);\n  }\n\n  /**\n   * Backend to attempt for the current plot type this render. The fallback chains below are\n   * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the\n   * backend `plot()` selects (no load/plot backend mismatch):\n   *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.\n   *  - plain `IMAGE` (no opt-in): OSD → Plotly.\n   *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).\n   */\n  private imageBackend(): IVisualizer {\n    const t = this.currentPlotType;\n    // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).\n    if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {\n      if (!this.napariFellBack) return this.napari;\n      if (!this.osdFellBack) return this.osd;\n      return this.plotly;\n    }\n    // Plain Image type (no napari opt-in): OSD, then Plotly.\n    if (this.isImageType(t)) {\n      return this.osdFellBack ? this.plotly : this.osd;\n    }\n    // 3D napari types: napari-js, with Plotly as the only viable fallback.\n    if (this.isNapari3dType(t)) {\n      return this.napariFellBack ? this.plotly : this.napari;\n    }\n    return this.plotly;\n  }\n\n  /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */\n  private renderer(): IVisualizer {\n    return this.lastRendered ?? this.plotly;\n  }\n\n  // System capabilities are Plotly's (the full-featured backend) so the UI\n  // keeps offering every plot type regardless of which one is on screen.\n  get capabilities(): ViewerCapabilities { return this.plotly.capabilities; }\n\n  // ── render / viewport → active renderer ──────────────────────────────\n  async load(imageInfo: IImageInfo, zIndex: number): Promise<any> {\n    // A stack can open away from slice 0 (`initialZIndex` — a volume opens\n    // mid-specimen), and that arrives here rather than through setZIndex.\n    this.currentZIndex = zIndex;\n    const backend = this.imageBackend();\n    if (backend === this.napari) {\n      try {\n        return await this.napari.load(imageInfo, zIndex);\n      } catch (err) {\n        this.napariFellBack = true;\n        // Mirror imageBackend()'s fallback so load + plot pick the same backend:\n        //  - 3D napari types have no 2D fallback → straight to Plotly.\n        //  - 2D image → OSD, then Plotly.\n        if (this.isNapari3dType(this.currentPlotType)) {\n          console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);\n          return this.plotly.load(imageInfo, zIndex);\n        }\n        console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);\n        return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n      }\n    }\n    if (backend === this.osd) {\n      return this.loadViaOsdThenPlotly(imageInfo, zIndex);\n    }\n    return this.plotly.load(imageInfo, zIndex);\n  }\n\n  /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */\n  private async loadViaOsdThenPlotly(imageInfo: IImageInfo, zIndex: number): Promise<any> {\n    try {\n      return await this.osd.load(imageInfo, zIndex);\n    } catch (err) {\n      console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);\n      this.osdFellBack = true;\n      return this.plotly.load(imageInfo, zIndex);\n    }\n  }\n  plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number,\n       plotType: PlotType, inPlace?: boolean): Promise<boolean> {\n    this.currentPlotType = plotType;\n    // Apply the per-image region cache (snapshot old regions, restore the new\n    // image's, clear selection) for whichever backend renders — Plotly does\n    // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent\n    // for the same image, so it's safe to call on every (re)plot.\n    this.plotly.setActiveImage(imageInfo);\n    const next = this.imageBackend();\n    // Both backends share the same div — tear down the outgoing one on switch.\n    // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD\n    // takes the div.\n    if (this.lastRendered && this.lastRendered !== next) {\n      if (this.lastRendered === this.plotly) this.plotly.purgePlot();\n      else this.lastRendered.reset();\n    }\n    this.lastRendered = next;\n    return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);\n  }\n  reloadAndPlot(): void { this.plotly.reloadAndPlot(); }\n  reset(): void {\n    // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior\n    // per-image fallback) and tear down whatever's on screen.\n    this.osdFellBack = false;\n    this.napariFellBack = false;\n    this.renderer().reset();\n  }\n  relayout(trueImageSize?: number[]): void { this.renderer().relayout(trueImageSize); }\n  resetAxes(): void { this.renderer().resetAxes(); }\n  autoscale(): void { this.renderer().autoscale(); }\n  zoomIn(): void { this.renderer().zoomIn(); }\n  zoomOut(): void { this.renderer().zoomOut(); }\n  setDragMode(mode: string | false): void { this.renderer().setDragMode(mode); }\n  // Set on both backends (not just the active renderer): consumers call this\n  // before the first render, when `renderer()` is still the Plotly default, so\n  // OSD must receive the flag to honour it at viewer creation.\n  setNavigatorVisible(visible: boolean): void {\n    this.osd.setNavigatorVisible(visible);\n    this.plotly.setNavigatorVisible(visible);\n  }\n  // Set on both backends (see setNavigatorVisible): consumers may set it before\n  // the first render, when the active renderer is still Plotly.\n  setImageSmoothingEnabled(enabled: boolean): void {\n    this.osd.setImageSmoothingEnabled(enabled);\n    this.plotly.setImageSmoothingEnabled(enabled);\n  }\n  setShowStack(showstack: boolean): void { this.renderer().setShowStack(showstack); }\n  setZIndex(zIndex: number): void {\n    this.currentZIndex = zIndex;\n    this.renderer().setZIndex(zIndex);\n  }\n  getTrueImageSize(): { width: number; height: number } | null { return this.renderer().getTrueImageSize(); }\n  getCurrentImage(): Promise<Image | null> { return this.renderer().getCurrentImage(); }\n  getDisplayedPixelData(): PixelData | null { return this.renderer().getDisplayedPixelData(); }\n  getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    return this.renderer().getDisplayedSourceRect();\n  }\n  downloadImage(): void { this.renderer().downloadImage(); }\n  exportComposite(): void { this.renderer().exportComposite(); }\n\n  setPlotType(plotType: PlotType): void {\n    this.currentPlotType = plotType;\n    this.plotly.setPlotType(plotType);\n  }\n  setSurfaceDragMode(mode: string): void { this.renderer().setSurfaceDragMode(mode); }\n  resetSurfaceCamera(): void { this.renderer().resetSurfaceCamera(); }\n  setResolutionScale(scale: number): void { this.renderer().setResolutionScale?.(scale); }\n  getResolutionScale(): number { return this.renderer().getResolutionScale?.() ?? 1; }\n  getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the\n    // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).\n    return this.plotly.getPlotTypeDescriptors();\n  }\n\n  // ── long-lived observables + stack flags ──────────────────────────────────\n  setStackLoading(b: boolean): void { this.plotly.setStackLoading(b); }\n  // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is\n  // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete\n  // backend classes don't all declare the optional contract method, so call it via IVisualizer.\n  cancelLoading(): void {\n    for (const backend of [this.plotly, this.osd, this.napari] as IVisualizer[]) {\n      backend.cancelLoading?.();\n    }\n  }\n  // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume\n  // assembly) drive their own subjects, so merge all three into one stable stream the host\n  // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)\n  isStackLoading(): Observable<boolean> {\n    return combineLatest([\n      this.plotly.isStackLoading(),\n      this.osd.isStackLoading(),\n      this.napari.isStackLoading(),\n    ]).pipe(map((flags) => flags.some(Boolean)));\n  }\n  getStackLoadingProgress(): Observable<number> {\n    // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain\n    // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the\n    // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag\n    // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.\n    const track = (v: IVisualizer): Observable<[number, boolean]> =>\n      combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);\n    return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(\n      map((pairs) => {\n        const active = pairs.filter(([, loading]) => loading).map(([p]) => p);\n        return active.length ? Math.max(...active) : 0;\n      }),\n    );\n  }\n  getAutoscaleEvent(): Observable<any> { return this.plotly.getAutoscaleEvent(); }\n  getIntensityProfile$(): Observable<IntensityProfile[]> { return this.plotly.getIntensityProfile$(); }\n  // The intensity inset is a Plotly LINE chart — render it through Plotly, which\n  // owns the profile stream regardless of which backend draws the main image.\n  renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    this.plotly.renderIntensityInset(divId, profiles); }\n\n  // ── regions → active renderer ────────────────────────────────────────\n  // Region *state* lives in the shared RegionStore; both backends implement\n  // IRegionStore by delegating to it. We route through the active renderer\n  // (not hardcoded Plotly) so the backend on screen also *renders* the change:\n  // Plotly relayouts its shapes, OpenSeadragon's overlay redraws from the store\n  // update event. Either way the same store is the single source of truth.\n  setRegions(regions: Region[], showRegionLabel?: boolean, isRegionSaveOn?: boolean,\n             fillColor?: string, append?: boolean): void {\n    this.renderer().setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n  }\n  getRegions(): Region[] { return this.renderer().getRegions(); }\n  getRegionPolygons(): any[] { return this.renderer().getRegionPolygons(); }\n  getRegionUpdateEvent(): Observable<any[]> { return this.renderer().getRegionUpdateEvent(); }\n  setSelectedShapeIndices(indices: number[]): void { this.renderer().setSelectedShapeIndices(indices); }\n  selectRegion(region: Region): void { this.renderer().selectRegion(region); }\n  getSelectedShapeIndices$(): Observable<number[]> { return this.renderer().getSelectedShapeIndices$(); }\n  deleteActiveShape(): void { this.renderer().deleteActiveShape(); }\n  getShowShapeLabel(): boolean { return this.renderer().getShowShapeLabel(); }\n  getShapeColor(): string { return this.renderer().getShapeColor(); }\n  getFillColor(): string { return this.renderer().getFillColor(); }\n  getClassificationColors(): Map<string, string> { return this.renderer().getClassificationColors(); }\n  setClassificationColor(label: string, color: string): void {\n    this.renderer().setClassificationColor(label, color); }\n  // Annotation-class presets live in the shared VisualizerStore (backend-neutral\n  // session state), so route straight to it rather than through renderer(). (jit-ui#70)\n  getPresetSet(): PresetSet { return this.store.getPresetSet(); }\n  getPresetSet$(): Observable<PresetSet> { return this.store.getPresetSet$(); }\n  setPresetSet(set: PresetSet): void { this.store.setPresetSet(set); }\n  upsertClass(preset: ClassPreset): void { this.store.upsertClass(preset); }\n  removeClass(name: string): void { this.store.removeClass(name); }\n  resetPresets(): void { this.store.resetPresets(); }\n  plotPreviousShapes(): void { this.renderer().plotPreviousShapes(); }\n  setPreviousShapes(shapes: any[]): void { this.renderer().setPreviousShapes(shapes); }\n  getPreviousShapes(): any[] { return this.renderer().getPreviousShapes(); }\n  // Undo state is owned by the shared RegionStore (same instance for both\n  // backends), so routing through the active renderer is safe and stable.\n  undo(): void { this.renderer().undo(); }\n  redo(): void { this.renderer().redo(); }\n  canUndo(): boolean { return this.renderer().canUndo(); }\n  canRedo(): boolean { return this.renderer().canRedo(); }\n  getCanUndo$(): Observable<boolean> { return this.renderer().getCanUndo$(); }\n  getCanRedo$(): Observable<boolean> { return this.renderer().getCanRedo$(); }\n  resetUndoHistory(): void { this.renderer().resetUndoHistory(); }\n  importRegions(geoJsonStr: string): Region[] { return this.renderer().importRegions(geoJsonStr); }\n  exportRegions(regions: Region[]): void { this.renderer().exportRegions(regions); }\n  getGeoJsonString(regions: Region[]): string { return this.renderer().getGeoJsonString(regions); }\n\n  // ── Per-slice z-stack regions (jit-ui#93) — the RegionStore is shared across\n  //    backends, so routing to the active renderer hits the same store. ──────\n  enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                 saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.renderer().enterStackMode(slices, initialZ, saveLayout);\n  }\n  exitStackMode(): void { this.renderer().exitStackMode(); }\n  isStackMode(): boolean { return this.renderer().isStackMode(); }\n  getStackSaveLayout(): 'combined' | 'per-slice-file' { return this.renderer().getStackSaveLayout(); }\n  setDisplaySlice(z: number): void { this.renderer().setDisplaySlice(z); }\n  getSliceRegions(): Region[] { return this.renderer().getSliceRegions(); }\n  getStackSaveSlices(): Map<number, Region[]> { return this.renderer().getStackSaveSlices(); }\n  /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged\n   *  with its zero-based Region.z; profile lines excluded. Flat annotation set\n   *  outside stack mode. */\n  getSliceAnnotationRegions(): Region[] {\n    return this.renderer().getSliceRegions().filter((r) => !isProfileRegion(r));\n  }\n  /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):\n   *  slice index → that slice's annotation regions (profile lines excluded),\n   *  including now-empty slices that were loaded non-empty (so they overwrite). */\n  getStackSaveAnnotationSlices(): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    for (const [z, regs] of this.renderer().getStackSaveSlices()) {\n      out.set(z, regs.filter((r) => !isProfileRegion(r)));\n    }\n    return out;\n  }\n\n  /** Authoritative full-resolution image size for mask export. Prefers the\n   *  active renderer's reported size, falling back to the image metadata (x/y\n   *  are the full-res pixel dimensions used across the app). Rejects non-finite\n   *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is\n   *  fully laid out, which would otherwise crash mask creation. */\n  getMaskImageSize(): { width: number; height: number } | null {\n    const valid = (s: { width: number; height: number } | null | undefined) =>\n      s && Number.isFinite(s.width) && Number.isFinite(s.height) &&\n      s.width >= 1 && s.height >= 1\n        ? { width: Math.round(s.width), height: Math.round(s.height) }\n        : null;\n\n    const fromRenderer = valid(this.getTrueImageSize());\n    if (fromRenderer) return fromRenderer;\n\n    let meta: IImageMetadata[] = [];\n    this.getImageMeta().subscribe((m) => (meta = m)).unsubscribe();\n    const m0 = meta?.[0];\n    return m0 ? valid({ width: m0.x, height: m0.y }) : null;\n  }\n\n  // ── IRegionEditorApi: annotation-only surface for the Region Editor ───\n  // Intensity-profile lines (kind='profile') belong to the intensity tool, not\n  // the editor. These methods give external consumers an annotation-only view\n  // and guarantee profile lines are preserved. Routing (not the store) owns this\n  // so writes/selection go through renderer() and the active backend re-renders\n  // (Plotly relayouts its shapes in setRegions; it doesn't on regionUpdate$).\n\n  getAnnotationRegions(): Region[] {\n    return this.renderer().getRegions().filter((r) => !isProfileRegion(r));\n  }\n  setAnnotationRegions(regions: Region[], showRegionLabel?: boolean,\n                       isRegionSaveOn?: boolean, fillColor?: string): void {\n    // Re-append the store's profile lines so an editor save/delete can't drop\n    // them, then route through setRegions so the active backend re-renders.\n    const profiles = this.renderer().getRegions().filter((r) => isProfileRegion(r));\n    const annotations = (regions || []).filter((r) => !isProfileRegion(r));\n    this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);\n  }\n  getSelectedRegions$(): Observable<Region[]> {\n    // Map the internal index-based selection to the selected annotation regions.\n    return this.getSelectedShapeIndices$().pipe(\n      map((idxs) => {\n        const regs = this.renderer().getRegions();\n        return idxs\n          .map((i) => regs[i])\n          .filter((r): r is Region => !!r && !isProfileRegion(r));\n      }),\n    );\n  }\n  setSelectedRegions(regions: Region[]): void {\n    const regs = this.renderer().getRegions();\n    const indices = (regions || [])\n      .map((r) => regs.findIndex((x) => x.id === r.id))\n      .filter((i) => i >= 0);\n    this.setSelectedShapeIndices(indices);\n  }\n\n  // ── tools → active renderer (run on either backend) ─────────────────\n  // The wand, vertex eraser and zoom-to-box are implemented on both backends\n  // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they\n  // follow the active renderer.\n  setWandMode(active: boolean, options?: any): void { this.renderer().setWandMode(active, options); }\n  setWandOptions(options: any): void { this.renderer().setWandOptions(options); }\n  clearActiveWandRegion(): void { this.renderer().clearActiveWandRegion(); }\n  setBrushMode(active: boolean, options?: any): void { this.renderer().setBrushMode(active, options); }\n  setBrushOptions(options: any): void { this.renderer().setBrushOptions(options); }\n  setVertexEraserMode(active: boolean): void { this.renderer().setVertexEraserMode(active); }\n  setVertexEraserRadius(radius: number): void { this.renderer().setVertexEraserRadius(radius); }\n  setZoomToBoxMode(active: boolean): void { this.renderer().setZoomToBoxMode(active); }\n  segmentRectangles(): Promise<number> { return this.renderer().segmentRectangles(); }\n  segmentRectanglesCellpose(): Promise<number> { return this.renderer().segmentRectanglesCellpose(); }\n  setSamModel(id: string): void { this.renderer().setSamModel(id); }\n  setSamPointMode(active: boolean): void { this.renderer().setSamPointMode(active); }\n  commitSamPoints(): void { this.renderer().commitSamPoints(); }\n  clearSamPoints(): void { this.renderer().clearSamPoints(); }\n\n  // ── display options ──────────────────────────────────────────────────\n  // State lives in the shared VisualizerStore — reads go straight to it.\n  // The two SETTERS still route through Plotly because its implementations\n  // carry render glue beyond the store write (a live Plotly.restyle of\n  // colorscale/reversescale on the mounted heatmap); OSD recolors via its own\n  // store subscription either way.\n  getColormap(): Observable<any> { return this.store.getColormap(); }\n  setColormap(colormap: any): void { this.plotly.setColormap(colormap); }\n  getColormapOptions(): any { return this.store.getColormapOptions(); }\n  getReverseScale(): Observable<boolean> { return this.store.getReverseScale(); }\n  setReverseScale(reverscale: any): void { this.plotly.setReverseScale(reverscale); }\n  setImageMeta(imageMeta: IImageMetadata[]): void { this.store.setImageMeta(imageMeta); }\n  getImageMeta(): Observable<IImageMetadata[]> { return this.store.getImageMeta(); }\n\n  // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────\n  // Channel/grayscale/invert state lives in the shared VisualizerStore; both\n  // backends subscribe and recolor live, so setters just write the store. The\n  // histogram comes from whichever backend is on screen (its native pixels).\n  getHistogram(channelIndex: number, bins: number): IHistogram | null {\n    return this.renderer().getHistogram(channelIndex, bins);\n  }\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return this.renderer().getHistogram$(channelIndex, bins);\n  }\n  /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */\n  exportData(): void { this.renderer().exportData(); }\n  getChannels$(): Observable<IChannelState[]> { return this.store.getChannelStates(); }\n  setSelectedChannel(index: number): void { this.store.setSelectedChannel(index); }\n  setChannelState(index: number, partial: Partial<IChannelState>): void {\n    this.store.setChannelState(index, partial);\n  }\n  resetContrast(indices: number[]): void {\n    // Full reset: window (0..255), gamma (1) AND the channel's default tint.\n    for (const i of indices) this.store.resetChannelState(i);\n  }\n  /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each\n   *  end of its histogram (skipping outlier first/last bins). */\n  autoContrast(indices: number[], saturation: number): void {\n    for (const i of indices) {\n      const h = this.renderer().getHistogram(i, 256);\n      if (!h) continue;\n      const [min, max] = autoWindowFromHistogram(h, saturation);\n      if (max > min) this.store.setChannelState(i, { min, max });\n    }\n  }\n  getGrayscale$(): Observable<boolean> { return this.store.getGrayscale(); }\n  setGrayscale(on: boolean): void { this.store.setGrayscale(on); }\n  getInvert$(): Observable<boolean> { return this.store.getInvert(); }\n  setInvert(on: boolean): void { this.store.setInvert(on); }\n\n  /**\n   * The active backend's region overlay. Falls back to Plotly's when the active backend\n   * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a\n   * usable overlay.\n   */\n  getRegionOverlay(): IRegionOverlay {\n    const r = this.renderer();\n    if (r === this.osd) {\n      return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    if (r === this.napari) {\n      return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();\n    }\n    return this.plotly.getRegionOverlay();\n  }\n\n  /**\n   * Isosurface controls when available — always Plotly's, since the isosurface\n   * plot type renders on Plotly (OSD only handles the image type).\n   */\n  getIsosurfaceControls(): IIsosurfaceControls | null { return this.renderer().getIsosurfaceControls(); }\n\n  /** 3D scene controls — always Plotly's, since the 3D plot types render on\n   *  Plotly (OSD only handles the image type). */\n  getSurface3dControls(): ISurface3dControls | null { return this.renderer().getSurface3dControls(); }\n\n  /** Intensity (line-ROI) controls — always Plotly's, since the line profiles\n   *  render their inset on Plotly regardless of which backend draws the image. */\n  getIntensityControls(): IIntensityControls | null { return this.plotly.getIntensityControls(); }\n\n  /**\n   * Spatial-omics controls, or null when no `SPATIAL_DATA_PORT` is bound.\n   *\n   * Implemented HERE rather than on a backend because the state is\n   * backend-neutral: the view state lives in the shared `VisualizerStore` (like\n   * the colormap), so the controls keep working across a plot-type switch and a\n   * host can drive them before any backend has mounted.\n   */\n  getSpatialControls(): ISpatialControls | null {\n    const port = this.spatialData;\n    if (!port) return null;\n    // Mirror the dataset (and drop a stale selection when it changes — the masks\n    // are index-based, so they are meaningless against different observations).\n    this.spatialDatasetSub ??= port.getDataset$().subscribe((dataset) => {\n      const changed = dataset?.id !== this.currentSpatialDataset?.id;\n      this.currentSpatialDataset = dataset;\n      if (!changed) return;\n      this.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));\n      // A colour source the new dataset cannot satisfy would leave the map flat\n      // while the panel and the charts kept naming the old column — so drop it,\n      // and only it: point size, opacity and the rest are the user's preferences,\n      // not the previous dataset's state.\n      const by = this.store.currentSpatialView().colorBy;\n      if (by && !this.canColorBy(dataset, by)) this.store.setSpatialView({ colorBy: null });\n    });\n    this.spatialControls ??= {\n      getDataset$: () => port.getDataset$(),\n      getViewState$: () => this.store.getSpatialView$(),\n      viewState: () => this.store.currentSpatialView(),\n      setViewState: (partial) => this.store.setSpatialView(partial),\n      // The hint SEEDS the toggle when the source changes, and nothing consults it\n      // afterwards. It used to be ORed in at render time, which meant an unchecked\n      // box could not turn log scaling off for a hinted column — and the linked\n      // chart, which reads `logScale` alone, disagreed with the map about what it\n      // was showing. One authority, set once per source.\n      colorByColumn: (name: string) => {\n        const meta = this.currentSpatialDataset?.columns.find((c) => c.name === name);\n        const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;\n        this.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });\n      },\n      colorByFeature: (name: string) =>\n        this.store.setSpatialView({\n          colorBy: { kind: 'feature', name },\n          logScale: !!this.currentSpatialDataset?.features?.logScaleHint,\n        }),\n      clearColorBy: () => this.store.setSpatialView({ colorBy: null }),\n      searchFeatures: async (query: string, limit = 50) => {\n        // Prefer the port's search (a 31k-gene dataset does not ship its names);\n        // otherwise filter whatever the manifest inlined.\n        if (port.searchFeatures) return port.searchFeatures(query, limit);\n        const dataset = await firstValueFrom(port.getDataset$());\n        const names = dataset?.features?.names ?? [];\n        const q = query.toLowerCase();\n        return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);\n      },\n      categoryColors: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        // Resolved by the SAME function the renderer uses, so a legend swatch\n        // can never disagree with the colour on screen.\n        return resolveCategoryColors(column.meta);\n      },\n\n      continuousValues: async (source) => {\n        if (source.kind === 'feature') return port.getFeatureVector(source.name);\n        const column = await port.getColumn(source.name);\n        if (isCategoricalColumn(column)) {\n          throw new Error(\n            `[spatial] column \"${source.name}\" is categorical — it has no values to chart`,\n          );\n        }\n        return column.values;\n      },\n\n      categoricalView: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        return {\n          name,\n          categories: column.meta.categories,\n          colors: resolveCategoryColors(column.meta),\n          codes: column.codes,\n        };\n      },\n\n      // Spread rather than always defined: `getEmbedding` is optional on both the port\n      // and this facade, and a panel checks for its presence to decide whether the view\n      // is offered at all. Defining it as a function that rejects would make an\n      // embedding-less source look like a broken one.\n      ...(port.getEmbedding\n        ? { getEmbedding: (name: string) => port.getEmbedding!(name) }\n        : {}),\n\n      categoricalColumns: () => (this.currentSpatialDataset?.columns ?? [])\n        .filter((c) => c.kind === 'categorical')\n        .map((c) => c.name),\n\n      // Memoized on the observations object, so the renderer's own lookup and\n      // this one are the same single scan of up to 3.7M z values.\n      sampledSections: () => {\n        const obs = this.currentSpatialDataset?.observations;\n        return obs ? sectionsOf(obs) : null;\n      },\n\n      getSelection$: () => this.selectionStore.getSelection$(),\n\n      selectFromRegions: () => {\n        const dataset = this.currentSpatialDataset;\n        if (!dataset) return 0;\n        const regions = this.regionStore.getRegions();\n        // The union of every drawn region — so every ROI tool the library\n        // already has doubles as a spatial selection tool.\n        //\n        // In the 3D cloud there is no data-space affine to push a drawn shape\n        // through, so the observations are projected to canvas pixels by the\n        // renderer (which owns the camera) and tested in screen space instead.\n        // Falls back to the 2D path whenever the cloud is not mounted.\n        const projected = isSpatialOmics3d(this.currentPlotType)\n          ? this.napari.getSpatialScreenProjection(dataset.observations)\n          : null;\n        // In the 2D view of a volume-backed dataset the shape was drawn over ONE\n        // section, in the volume's pixel grid: it selects the cells of that\n        // section, not the whole depth of brain standing behind them.\n        const volume = !dataset.imageRef ? dataset.volume : undefined;\n        const selection = projected\n          ? selectInRegionsProjected(projected, dataset.observations.count, regions)\n          : selectInRegions(\n              dataset.observations,\n              volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef,\n              regions,\n              volume\n                ? observationsInSlice(dataset.observations, volume, this.currentZIndex)\n                : undefined,\n            );\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectCategory: async (column: string, categoryIndex: number) => {\n        const loaded = await port.getColumn(column);\n        if (!isCategoricalColumn(loaded)) {\n          throw new Error(`[spatial] column \"${column}\" is continuous — it has no categories`);\n        }\n        const selection = selectByCategory(loaded.codes, categoryIndex);\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectIndices: (indices: Iterable<number>) => {\n        const count = this.currentSpatialDataset?.observations.count ?? 0;\n        if (count === 0) return 0;\n        const selection = selectByIndices(indices, count);\n        this.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      clearSelection: () => this.selectionStore.clear(),\n    };\n    return this.spatialControls;\n  }\n\n  /**\n   * Whether `dataset` can answer this colour source.\n   *\n   * A column is checkable against the declared list. A gene is checkable only when\n   * the dataset inlines its feature names — a dataset too wide to inline them\n   * (typeahead-only) keeps the source, and a name that turns out not to exist\n   * surfaces as the chart's \"could not be charted\" rather than as a silent reset.\n   */\n  private canColorBy(dataset: SpatialDataset | null, by: SpatialColorBy): boolean {\n    if (!dataset) return false;\n    if (by.kind === 'column') return dataset.columns.some((c) => c.name === by.name);\n    const names = dataset.features?.names;\n    return !!dataset.features && (!names || names.includes(by.name));\n  }\n\n  /** Memoised so consumers can hold the object across calls. */\n  private spatialControls: ISpatialControls | null = null;\n  /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously\n   *  — it runs from a button click and must not await a round-trip. */\n  private currentSpatialDataset: SpatialDataset | null = null;\n  /** Displayed slice. Only a volume-backed spatial dataset reads it, to keep a\n   *  region drawn over one section from selecting the whole depth behind it. */\n  private currentZIndex = 0;\n  private spatialDatasetSub: Subscription | null = null;\n\n  /** Load pixel frames for intensity sampling when OpenSeadragon owns the image\n   *  (it doesn't feed Plotly's frame cache). No-op needed when Plotly renders. */\n  ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    return this.plotly.ensureIntensitySampling(imageInfo, zIndex);\n  }\n\n  /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),\n   *  so the intensity inset can re-sample at the current zoom level. Plotly's own\n   *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */\n  getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return this.osd.getViewportChange$();\n  }\n\n  /** Re-sample the intensity profiles from a fresh crop of the given image-pixel\n   *  ROI at display resolution (sampling always lives in Plotly). */\n  refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number, zIndex: number): void {\n    this.plotly.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);\n  }\n\n  unsubscribe(): void {\n    this.plotly.unsubscribe();\n    this.osd.unsubscribe();\n  }\n}\n"]}