@jax-data-science/sci-image-visualizer 0.1.0

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

@@ -0,0 +1,533 @@
+import { Inject, Injectable } from '@angular/core';
+import { combineLatest } 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 { VisualizerStore } from './store/visualizer-store.service';
+import { NapariVisualizerService } from './implementations/napari-js/napari-visualizer.service';
+import { VIZ_CONFIG } from './contracts/viz-config';
+import * as i0 from "@angular/core";
+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";
+/**
+ * Backend selector. Routes per plot type:
+ *  - the **Image** plot type renders through OpenSeadragon — a natively-tiled,
+ *    zoomable raster backed by the jit-service tile endpoints. It's the default
+ *    view and supports the region overlay/tools and (for grayscale) the
+ *    colormap, applied client-side via the tile pixel pipeline.
+ *  - every other plot type (heatmap, surface, contour, scatter, line,
+ *    scatter3d, isosurface) renders through Plotly.
+ *
+ * Only the **render + viewport** path is routed. Region state, display options
+ * (colormap/LUT), and the long-lived observables always live in Plotly (the
+ * shared store) so both backends stay in sync; OSD reads them to drive its own
+ * overlay and tile recoloring.
+ *
+ * The Image type renders through OpenSeadragon; a failed OSD load falls back to
+ * Plotly for that image only (see `osdFellBack`) so it still renders.
+ */
+/** Intensity-profile line ROIs are owned by the intensity tool, not the editor.
+ *  Package-internal predicate (property-based so it also matches plain objects
+ *  after a drag round-trip). */
+function isProfileRegion(r) {
+    return r?.kind === 'profile';
+}
+/** Saturation-based auto-window: pick [min,max] so ~`saturation` of pixels clip
+ *  at each end of the histogram. A dominant first/last bin (unscanned padding /
+ *  clipped background) is dropped so it doesn't skew the range. */
+function autoWindowFromHistogram(h, saturation) {
+    const counts = h.counts.slice();
+    const n = counts.length;
+    if (n === 0)
+        return [0, 255];
+    if (n > 2 && counts[0] > counts[1])
+        counts[0] = 0;
+    if (n > 2 && counts[n - 1] > counts[n - 2])
+        counts[n - 1] = 0;
+    let total = 0;
+    for (const c of counts)
+        total += c;
+    if (total <= 0)
+        return [0, 255];
+    const target = total * Math.max(0, Math.min(0.5, saturation));
+    let acc = 0;
+    let min = h.bins[0];
+    for (let i = 0; i < n; i++) {
+        acc += counts[i];
+        if (acc > target) {
+            min = h.bins[i];
+            break;
+        }
+    }
+    acc = 0;
+    let max = h.bins[n - 1];
+    for (let i = n - 1; i >= 0; i--) {
+        acc += counts[i];
+        if (acc > target) {
+            max = h.bins[i];
+            break;
+        }
+    }
+    return [min, max];
+}
+export class RoutingVisualizerService {
+    constructor(plotly, osd, napari, store, config) {
+        this.plotly = plotly;
+        this.osd = osd;
+        this.napari = napari;
+        this.store = store;
+        this.config = config;
+        this.currentPlotType = PlotType.IMAGE;
+        this.lastRendered = null;
+        /** OSD failed for the *current* render cycle (e.g. a fresh file still caching
+         *  past the deadline) → fall back to Plotly for this image only. Reset by
+         *  reset() at the start of every render cycle, so the next file — or a
+         *  re-select once the file is cached — retries OSD. (Was a permanent flag,
+         *  which left the whole session stuck on Plotly after one slow load.) */
+        this.osdFellBack = false;
+        /** 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;
+    }
+    isImageType(t) {
+        return t === PlotType.IMAGE;
+    }
+    /** The 2D napari types (image + region-centroid scatter) — a 2D fallback chain (OSD, then Plotly). */
+    isNapariImageType(t) {
+        return t === PlotType.NAPARI_IMAGE || isNapariScatter(t);
+    }
+    /** The 3D napari types (volume/isosurface, either resolution) — no 2D fallback exists (OSD is
+     *  image-only), so they fall straight to Plotly. */
+    isNapari3dType(t) {
+        return isNapari3d(t);
+    }
+    /**
+     * Backend to attempt for the current plot type this render. The fallback chains below are
+     * mirrored exactly by {@link load} so the handle `plot()` receives always comes from the
+     * backend `plot()` selects (no load/plot backend mismatch):
+     *  - 2D image (explicit `NAPARI_IMAGE`, or `IMAGE` with the WebGPU opt-in): napari-js → OSD → Plotly.
+     *  - plain `IMAGE` (no opt-in): OSD → Plotly.
+     *  - 3D napari (`NAPARI_VOLUME`/`NAPARI_ISOSURFACE`): napari-js → Plotly (OSD can't render 3D).
+     */
+    imageBackend() {
+        const t = this.currentPlotType;
+        // 2D image with a napari-js attempt (explicit napari image, or opt-in on the Image type).
+        if (this.isNapariImageType(t) || (this.isImageType(t) && this.config.useNapariRenderer)) {
+            if (!this.napariFellBack)
+                return this.napari;
+            if (!this.osdFellBack)
+                return this.osd;
+            return this.plotly;
+        }
+        // Plain Image type (no napari opt-in): OSD, then Plotly.
+        if (this.isImageType(t)) {
+            return this.osdFellBack ? this.plotly : this.osd;
+        }
+        // 3D napari types: napari-js, with Plotly as the only viable fallback.
+        if (this.isNapari3dType(t)) {
+            return this.napariFellBack ? this.plotly : this.napari;
+        }
+        return this.plotly;
+    }
+    /** Backend currently on screen — what ongoing zoom/tool/region ops act on. */
+    renderer() {
+        return this.lastRendered ?? this.plotly;
+    }
+    // System capabilities are Plotly's (the full-featured backend) so the UI
+    // keeps offering every plot type regardless of which one is on screen.
+    get capabilities() { return this.plotly.capabilities; }
+    // ── render / viewport → active renderer ──────────────────────────────
+    async load(imageInfo, zIndex) {
+        const backend = this.imageBackend();
+        if (backend === this.napari) {
+            try {
+                return await this.napari.load(imageInfo, zIndex);
+            }
+            catch (err) {
+                this.napariFellBack = true;
+                // Mirror imageBackend()'s fallback so load + plot pick the same backend:
+                //  - 3D napari types have no 2D fallback → straight to Plotly.
+                //  - 2D image → OSD, then Plotly.
+                if (this.isNapari3dType(this.currentPlotType)) {
+                    console.warn('[visualizer] napari-js load failed — falling back to Plotly.', err);
+                    return this.plotly.load(imageInfo, zIndex);
+                }
+                console.warn('[visualizer] napari-js load failed — falling back to OpenSeadragon.', err);
+                return this.loadViaOsdThenPlotly(imageInfo, zIndex);
+            }
+        }
+        if (backend === this.osd) {
+            return this.loadViaOsdThenPlotly(imageInfo, zIndex);
+        }
+        return this.plotly.load(imageInfo, zIndex);
+    }
+    /** Try OSD; on failure fall back to Plotly for this image (not permanent — see reset()). */
+    async loadViaOsdThenPlotly(imageInfo, zIndex) {
+        try {
+            return await this.osd.load(imageInfo, zIndex);
+        }
+        catch (err) {
+            console.warn('[visualizer] OpenSeadragon load failed — falling back to Plotly for this image.', err);
+            this.osdFellBack = true;
+            return this.plotly.load(imageInfo, zIndex);
+        }
+    }
+    plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace) {
+        this.currentPlotType = plotType;
+        // Apply the per-image region cache (snapshot old regions, restore the new
+        // image's, clear selection) for whichever backend renders — Plotly does
+        // this inside its own plot(), but OSD doesn't, so drive it here. Idempotent
+        // for the same image, so it's safe to call on every (re)plot.
+        this.plotly.setActiveImage(imageInfo);
+        const next = this.imageBackend();
+        // Both backends share the same div — tear down the outgoing one on switch.
+        // Plotly must be *purged* (not reset, which re-draws empty axes) before OSD
+        // takes the div.
+        if (this.lastRendered && this.lastRendered !== next) {
+            if (this.lastRendered === this.plotly)
+                this.plotly.purgePlot();
+            else
+                this.lastRendered.reset();
+        }
+        this.lastRendered = next;
+        return next.plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace);
+    }
+    reloadAndPlot() { this.plotly.reloadAndPlot(); }
+    reset() {
+        // Start of a render cycle: re-enable napari-js/OSD attempts (clear any prior
+        // per-image fallback) and tear down whatever's on screen.
+        this.osdFellBack = false;
+        this.napariFellBack = false;
+        this.renderer().reset();
+    }
+    relayout(trueImageSize) { this.renderer().relayout(trueImageSize); }
+    resetAxes() { this.renderer().resetAxes(); }
+    autoscale() { this.renderer().autoscale(); }
+    zoomIn() { this.renderer().zoomIn(); }
+    zoomOut() { this.renderer().zoomOut(); }
+    setDragMode(mode) { this.renderer().setDragMode(mode); }
+    // Set on both backends (not just the active renderer): consumers call this
+    // before the first render, when `renderer()` is still the Plotly default, so
+    // OSD must receive the flag to honour it at viewer creation.
+    setNavigatorVisible(visible) {
+        this.osd.setNavigatorVisible(visible);
+        this.plotly.setNavigatorVisible(visible);
+    }
+    // Set on both backends (see setNavigatorVisible): consumers may set it before
+    // the first render, when the active renderer is still Plotly.
+    setImageSmoothingEnabled(enabled) {
+        this.osd.setImageSmoothingEnabled(enabled);
+        this.plotly.setImageSmoothingEnabled(enabled);
+    }
+    setShowStack(showstack) { this.renderer().setShowStack(showstack); }
+    setZIndex(zIndex) { this.renderer().setZIndex(zIndex); }
+    getTrueImageSize() { return this.renderer().getTrueImageSize(); }
+    getCurrentImage() { return this.renderer().getCurrentImage(); }
+    getDisplayedPixelData() { return this.renderer().getDisplayedPixelData(); }
+    getDisplayedSourceRect() {
+        return this.renderer().getDisplayedSourceRect();
+    }
+    downloadImage() { this.renderer().downloadImage(); }
+    exportComposite() { this.renderer().exportComposite(); }
+    setPlotType(plotType) {
+        this.currentPlotType = plotType;
+        this.plotly.setPlotType(plotType);
+    }
+    setSurfaceDragMode(mode) { this.renderer().setSurfaceDragMode(mode); }
+    resetSurfaceCamera() { this.renderer().resetSurfaceCamera(); }
+    setResolutionScale(scale) { this.renderer().setResolutionScale?.(scale); }
+    getResolutionScale() { return this.renderer().getResolutionScale?.() ?? 1; }
+    getPlotTypeDescriptors() {
+        // Plotly enumerates the full PLOT_TYPE_DESCRIPTORS map, which already includes the
+        // napari-js WebGPU types (jit-ui#102) — so this single source covers them (no duplicates).
+        return this.plotly.getPlotTypeDescriptors();
+    }
+    // ── long-lived observables + stack flags ──────────────────────────────────
+    setStackLoading(b) { this.plotly.setStackLoading(b); }
+    // Cancel in-flight loading on every backend — the user's Cancel shouldn't depend on which one is
+    // active. Only backends that stream frames (napari-js) do real work; the rest no-op. The concrete
+    // backend classes don't all declare the optional contract method, so call it via IVisualizer.
+    cancelLoading() {
+        for (const backend of [this.plotly, this.osd, this.napari]) {
+            backend.cancelLoading?.();
+        }
+    }
+    // Loading state is surfaced from whichever backend is doing the work: OSD and napari-js (volume
+    // assembly) drive their own subjects, so merge all three into one stable stream the host
+    // subscribes to once. (Previously hardcoded to Plotly, so napari/OSD progress never showed.)
+    isStackLoading() {
+        return combineLatest([
+            this.plotly.isStackLoading(),
+            this.osd.isStackLoading(),
+            this.napari.isStackLoading(),
+        ]).pipe(map((flags) => flags.some(Boolean)));
+    }
+    getStackLoadingProgress() {
+        // Report the progress of whichever backend is ACTIVELY loading (max across active ones). A plain
+        // merge let an idle backend's stale value win the stream on a re-load — leaving the bar below the
+        // active backend's real progress (e.g. stuck ~⅓ while the % read 100). Gating by the loading flag
+        // ignores idle backends, so the bar tracks the one doing the work and reaches 100%.
+        const track = (v) => combineLatest([v.getStackLoadingProgress(), v.isStackLoading()]);
+        return combineLatest([track(this.plotly), track(this.osd), track(this.napari)]).pipe(map((pairs) => {
+            const active = pairs.filter(([, loading]) => loading).map(([p]) => p);
+            return active.length ? Math.max(...active) : 0;
+        }));
+    }
+    getAutoscaleEvent() { return this.plotly.getAutoscaleEvent(); }
+    getIntensityProfile$() { return this.plotly.getIntensityProfile$(); }
+    // The intensity inset is a Plotly LINE chart — render it through Plotly, which
+    // owns the profile stream regardless of which backend draws the main image.
+    renderIntensityInset(divId, profiles) {
+        this.plotly.renderIntensityInset(divId, profiles);
+    }
+    // ── regions → active renderer ────────────────────────────────────────
+    // Region *state* lives in the shared RegionStore; both backends implement
+    // IRegionStore by delegating to it. We route through the active renderer
+    // (not hardcoded Plotly) so the backend on screen also *renders* the change:
+    // Plotly relayouts its shapes, OpenSeadragon's overlay redraws from the store
+    // update event. Either way the same store is the single source of truth.
+    setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append) {
+        this.renderer().setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
+    }
+    getRegions() { return this.renderer().getRegions(); }
+    getRegionPolygons() { return this.renderer().getRegionPolygons(); }
+    getRegionUpdateEvent() { return this.renderer().getRegionUpdateEvent(); }
+    setSelectedShapeIndices(indices) { this.renderer().setSelectedShapeIndices(indices); }
+    selectRegion(region) { this.renderer().selectRegion(region); }
+    getSelectedShapeIndices$() { return this.renderer().getSelectedShapeIndices$(); }
+    deleteActiveShape() { this.renderer().deleteActiveShape(); }
+    getShowShapeLabel() { return this.renderer().getShowShapeLabel(); }
+    getShapeColor() { return this.renderer().getShapeColor(); }
+    getFillColor() { return this.renderer().getFillColor(); }
+    getClassificationColors() { return this.renderer().getClassificationColors(); }
+    setClassificationColor(label, color) {
+        this.renderer().setClassificationColor(label, color);
+    }
+    // Annotation-class presets live in the shared VisualizerStore (backend-neutral
+    // session state), so route straight to it rather than through renderer(). (jit-ui#70)
+    getPresetSet() { return this.store.getPresetSet(); }
+    getPresetSet$() { return this.store.getPresetSet$(); }
+    setPresetSet(set) { this.store.setPresetSet(set); }
+    upsertClass(preset) { this.store.upsertClass(preset); }
+    removeClass(name) { this.store.removeClass(name); }
+    resetPresets() { this.store.resetPresets(); }
+    plotPreviousShapes() { this.renderer().plotPreviousShapes(); }
+    setPreviousShapes(shapes) { this.renderer().setPreviousShapes(shapes); }
+    getPreviousShapes() { return this.renderer().getPreviousShapes(); }
+    // Undo state is owned by the shared RegionStore (same instance for both
+    // backends), so routing through the active renderer is safe and stable.
+    undo() { this.renderer().undo(); }
+    redo() { this.renderer().redo(); }
+    canUndo() { return this.renderer().canUndo(); }
+    canRedo() { return this.renderer().canRedo(); }
+    getCanUndo$() { return this.renderer().getCanUndo$(); }
+    getCanRedo$() { return this.renderer().getCanRedo$(); }
+    resetUndoHistory() { this.renderer().resetUndoHistory(); }
+    importRegions(geoJsonStr) { return this.renderer().importRegions(geoJsonStr); }
+    exportRegions(regions) { this.renderer().exportRegions(regions); }
+    getGeoJsonString(regions) { return this.renderer().getGeoJsonString(regions); }
+    // ── Per-slice z-stack regions (jit-ui#93) — the RegionStore is shared across
+    //    backends, so routing to the active renderer hits the same store. ──────
+    enterStackMode(slices, initialZ, saveLayout) {
+        this.renderer().enterStackMode(slices, initialZ, saveLayout);
+    }
+    exitStackMode() { this.renderer().exitStackMode(); }
+    isStackMode() { return this.renderer().isStackMode(); }
+    getStackSaveLayout() { return this.renderer().getStackSaveLayout(); }
+    setDisplaySlice(z) { this.renderer().setDisplaySlice(z); }
+    getSliceRegions() { return this.renderer().getSliceRegions(); }
+    getStackSaveSlices() { return this.renderer().getStackSaveSlices(); }
+    /** All slices' ANNOTATION regions for a z-stack save (jit-ui#93), each tagged
+     *  with its zero-based Region.z; profile lines excluded. Flat annotation set
+     *  outside stack mode. */
+    getSliceAnnotationRegions() {
+        return this.renderer().getSliceRegions().filter((r) => !isProfileRegion(r));
+    }
+    /** Per-slice annotation regions to write on a folder-stack save (jit-ui#93):
+     *  slice index → that slice's annotation regions (profile lines excluded),
+     *  including now-empty slices that were loaded non-empty (so they overwrite). */
+    getStackSaveAnnotationSlices() {
+        const out = new Map();
+        for (const [z, regs] of this.renderer().getStackSaveSlices()) {
+            out.set(z, regs.filter((r) => !isProfileRegion(r)));
+        }
+        return out;
+    }
+    /** Authoritative full-resolution image size for mask export. Prefers the
+     *  active renderer's reported size, falling back to the image metadata (x/y
+     *  are the full-res pixel dimensions used across the app). Rejects non-finite
+     *  or non-positive sizes — the Plotly bounds can yield NaN before a plot is
+     *  fully laid out, which would otherwise crash mask creation. */
+    getMaskImageSize() {
+        const valid = (s) => s && Number.isFinite(s.width) && Number.isFinite(s.height) &&
+            s.width >= 1 && s.height >= 1
+            ? { width: Math.round(s.width), height: Math.round(s.height) }
+            : null;
+        const fromRenderer = valid(this.getTrueImageSize());
+        if (fromRenderer)
+            return fromRenderer;
+        let meta = [];
+        this.getImageMeta().subscribe((m) => (meta = m)).unsubscribe();
+        const m0 = meta?.[0];
+        return m0 ? valid({ width: m0.x, height: m0.y }) : null;
+    }
+    // ── IRegionEditorApi: annotation-only surface for the Region Editor ───
+    // Intensity-profile lines (kind='profile') belong to the intensity tool, not
+    // the editor. These methods give external consumers an annotation-only view
+    // and guarantee profile lines are preserved. Routing (not the store) owns this
+    // so writes/selection go through renderer() and the active backend re-renders
+    // (Plotly relayouts its shapes in setRegions; it doesn't on regionUpdate$).
+    getAnnotationRegions() {
+        return this.renderer().getRegions().filter((r) => !isProfileRegion(r));
+    }
+    setAnnotationRegions(regions, showRegionLabel, isRegionSaveOn, fillColor) {
+        // Re-append the store's profile lines so an editor save/delete can't drop
+        // them, then route through setRegions so the active backend re-renders.
+        const profiles = this.renderer().getRegions().filter((r) => isProfileRegion(r));
+        const annotations = (regions || []).filter((r) => !isProfileRegion(r));
+        this.setRegions([...annotations, ...profiles], showRegionLabel, isRegionSaveOn, fillColor, false);
+    }
+    getSelectedRegions$() {
+        // Map the internal index-based selection to the selected annotation regions.
+        return this.getSelectedShapeIndices$().pipe(map((idxs) => {
+            const regs = this.renderer().getRegions();
+            return idxs
+                .map((i) => regs[i])
+                .filter((r) => !!r && !isProfileRegion(r));
+        }));
+    }
+    setSelectedRegions(regions) {
+        const regs = this.renderer().getRegions();
+        const indices = (regions || [])
+            .map((r) => regs.findIndex((x) => x.id === r.id))
+            .filter((i) => i >= 0);
+        this.setSelectedShapeIndices(indices);
+    }
+    // ── tools → active renderer (run on either backend) ─────────────────
+    // The wand, vertex eraser and zoom-to-box are implemented on both backends
+    // via ICoordinateTransform (+ a viewport pixel readback for the wand), so they
+    // follow the active renderer.
+    setWandMode(active, options) { this.renderer().setWandMode(active, options); }
+    setWandOptions(options) { this.renderer().setWandOptions(options); }
+    clearActiveWandRegion() { this.renderer().clearActiveWandRegion(); }
+    setBrushMode(active, options) { this.renderer().setBrushMode(active, options); }
+    setBrushOptions(options) { this.renderer().setBrushOptions(options); }
+    setVertexEraserMode(active) { this.renderer().setVertexEraserMode(active); }
+    setVertexEraserRadius(radius) { this.renderer().setVertexEraserRadius(radius); }
+    setZoomToBoxMode(active) { this.renderer().setZoomToBoxMode(active); }
+    segmentRectangles() { return this.renderer().segmentRectangles(); }
+    segmentRectanglesCellpose() { return this.renderer().segmentRectanglesCellpose(); }
+    setSamModel(id) { this.renderer().setSamModel(id); }
+    setSamPointMode(active) { this.renderer().setSamPointMode(active); }
+    commitSamPoints() { this.renderer().commitSamPoints(); }
+    clearSamPoints() { this.renderer().clearSamPoints(); }
+    // ── display options ──────────────────────────────────────────────────
+    // State lives in the shared VisualizerStore — reads go straight to it.
+    // The two SETTERS still route through Plotly because its implementations
+    // carry render glue beyond the store write (a live Plotly.restyle of
+    // colorscale/reversescale on the mounted heatmap); OSD recolors via its own
+    // store subscription either way.
+    getColormap() { return this.store.getColormap(); }
+    setColormap(colormap) { this.plotly.setColormap(colormap); }
+    getColormapOptions() { return this.store.getColormapOptions(); }
+    getReverseScale() { return this.store.getReverseScale(); }
+    setReverseScale(reverscale) { this.plotly.setReverseScale(reverscale); }
+    setImageMeta(imageMeta) { this.store.setImageMeta(imageMeta); }
+    getImageMeta() { return this.store.getImageMeta(); }
+    // ── IChannelHistogramApi: Channels & Histogram pane surface ───────────
+    // Channel/grayscale/invert state lives in the shared VisualizerStore; both
+    // backends subscribe and recolor live, so setters just write the store. The
+    // histogram comes from whichever backend is on screen (its native pixels).
+    getHistogram(channelIndex, bins) {
+        return this.renderer().getHistogram(channelIndex, bins);
+    }
+    getHistogram$(channelIndex, bins) {
+        return this.renderer().getHistogram$(channelIndex, bins);
+    }
+    /** Export the underlying data (16-bit multi-band TIFF) via the active backend. */
+    exportData() { this.renderer().exportData(); }
+    getChannels$() { return this.store.getChannelStates(); }
+    setChannelState(index, partial) {
+        this.store.setChannelState(index, partial);
+    }
+    resetContrast(indices) {
+        // Full reset: window (0..255), gamma (1) AND the channel's default tint.
+        for (const i of indices)
+            this.store.resetChannelState(i);
+    }
+    /** Auto-window each channel by saturating `saturation` (0..1) of pixels at each
+     *  end of its histogram (skipping outlier first/last bins). */
+    autoContrast(indices, saturation) {
+        for (const i of indices) {
+            const h = this.renderer().getHistogram(i, 256);
+            if (!h)
+                continue;
+            const [min, max] = autoWindowFromHistogram(h, saturation);
+            if (max > min)
+                this.store.setChannelState(i, { min, max });
+        }
+    }
+    getGrayscale$() { return this.store.getGrayscale(); }
+    setGrayscale(on) { this.store.setGrayscale(on); }
+    getInvert$() { return this.store.getInvert(); }
+    setInvert(on) { this.store.setInvert(on); }
+    /**
+     * The active backend's region overlay. Falls back to Plotly's when the active backend
+     * (OSD or napari-js) is selected but a plot isn't mounted yet, so callers always get a
+     * usable overlay.
+     */
+    getRegionOverlay() {
+        const r = this.renderer();
+        if (r === this.osd) {
+            return this.osd.getRegionOverlay() ?? this.plotly.getRegionOverlay();
+        }
+        if (r === this.napari) {
+            return this.napari.getRegionOverlay() ?? this.plotly.getRegionOverlay();
+        }
+        return this.plotly.getRegionOverlay();
+    }
+    /**
+     * Isosurface controls when available — always Plotly's, since the isosurface
+     * plot type renders on Plotly (OSD only handles the image type).
+     */
+    getIsosurfaceControls() { return this.renderer().getIsosurfaceControls(); }
+    /** 3D scene controls — always Plotly's, since the 3D plot types render on
+     *  Plotly (OSD only handles the image type). */
+    getSurface3dControls() { return this.renderer().getSurface3dControls(); }
+    /** 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(); }
+    /** 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) {
+        return this.plotly.ensureIntensitySampling(imageInfo, zIndex);
+    }
+    /** Visible-region changes from the OpenSeadragon viewer (image-pixel coords),
+     *  so the intensity inset can re-sample at the current zoom level. Plotly's own
+     *  high-def zoom updates the sampling cache inline, so only OSD feeds this. */
+    getViewportChange$() {
+        return this.osd.getViewportChange$();
+    }
+    /** Re-sample the intensity profiles from a fresh crop of the given image-pixel
+     *  ROI at display resolution (sampling always lives in Plotly). */
+    refreshIntensitySamplingForRoi(x, y, width, height, zIndex) {
+        this.plotly.refreshIntensitySamplingForRoi(x, y, width, height, zIndex);
+    }
+    unsubscribe() {
+        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.ɵ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: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.PlotlyService }, { type: i2.OpenSeadragonVisualizerService }, { type: i3.NapariVisualizerService }, { type: i4.VisualizerStore }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VIZ_CONFIG]
+                }] }] });
+//# 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  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"]}