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

package/esm2022/lib/implementations/plotly/plotly.service.mjs

@@ -0,0 +1,2137 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import * as Plotly from 'plotly.js-dist-min';
+import { Image } from 'image-js';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import { Polygon, Rectangle, Region } from '../../models/region';
+import { Buffer } from 'buffer';
+import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
+import { IMAGE_STATE_PORT } from '../../contracts/ports/image-state.port';
+import { BehaviorSubject, EMPTY, Subject, combineLatest, of } from 'rxjs';
+import { MessageService } from 'primeng/api';
+import { ShapeSelection } from '../../models/shape';
+import { CONFIG, CONFIG_SURFACE, PlotUtilities } from '../../plot.utilities';
+import { WandService } from '../../toolbar/wand/wand.service';
+import { WandToolService } from '../../toolbar/wand/wand-tool.service';
+import { BrushToolService } from '../../toolbar/brush/brush-tool.service';
+import { SamToolService } from '../../toolbar/segmentation/sam-tool.service';
+import { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';
+import { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';
+import { CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';
+import { VertexEraserToolService } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';
+import { ZoomToBoxToolService } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';
+import { PlotType, PLOT_TYPE_DESCRIPTORS } from '../../contracts/plot-type';
+import { PLOTLY_PLOT_TYPE_IMPLS, } from './plotly-trace-builders';
+import { bt601Luminance, histogram256 } from '../../contracts/intensity';
+import { ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';
+import { PlotlyRegionOverlay } from './plotly-region-overlay';
+import { PlotlyCoordinateTransform } from './plotly-coordinate-transform';
+import { VisualizerStore } from '../../store/visualizer-store.service';
+import { RegionStore } from '../../store/region-store.service';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../../toolbar/wand/wand.service";
+import * as i4 from "../../toolbar/wand/wand-tool.service";
+import * as i5 from "../../toolbar/brush/brush-tool.service";
+import * as i6 from "../../toolbar/segmentation/sam-tool.service";
+import * as i7 from "../../toolbar/segmentation/sam-point-tool.service";
+import * as i8 from "../../toolbar/segmentation/cell-segment-tool.service";
+import * as i9 from "../../toolbar/vertex-eraser/vertex-eraser-tool.service";
+import * as i10 from "../../toolbar/zoom-to-box/zoom-to-box-tool.service";
+import * as i11 from "../../store/visualizer-store.service";
+import * as i12 from "../../store/region-store.service";
+// Re-exported so existing consumers can keep importing PlotType from this
+// module while it physically lives in the backend-neutral contracts/ dir.
+// TODO(plotting-abstraction): once all consumers import from
+// './contracts/plot-type' directly, drop this re-export.
+export { PlotType } from '../../contracts/plot-type';
+window.Buffer = Buffer;
+export class PlotlyService {
+    constructor(tiles, state, messageService, http, wandService, wandTool, brushTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, vertexEraserTool, zoomToBoxTool, store, regionStore) {
+        this.tiles = tiles;
+        this.state = state;
+        this.messageService = messageService;
+        this.http = http;
+        this.wandService = wandService;
+        this.wandTool = wandTool;
+        this.brushTool = brushTool;
+        this.samTool = samTool;
+        this.samPointTool = samPointTool;
+        this.cellSegmentTool = cellSegmentTool;
+        this.cellSegmenter = cellSegmenter;
+        this.vertexEraserTool = vertexEraserTool;
+        this.zoomToBoxTool = zoomToBoxTool;
+        this.store = store;
+        this.regionStore = regionStore;
+        /**
+         * Plotly is the full-featured data backend: it supports every feature,
+         * including 3D scenes, live scalar colormaps, pixel readback and the
+         * server-side high-def zoom re-fetch. (OpenSeadragon's stub advertises only
+         * image display.)
+         */
+        this.capabilities = capabilitiesOf([
+            ViewerFeature.ImageDisplay,
+            ViewerFeature.Surface3D,
+            ViewerFeature.ScalarColormap,
+            ViewerFeature.PixelReadback,
+            ViewerFeature.HighDefZoom,
+            ViewerFeature.StackSlider,
+            ViewerFeature.Isosurface,
+        ]);
+        this.shapes = [];
+        this.previousShapes = [];
+        this.isRegionSavedOn = true;
+        this.isRealZoom = true;
+        this.scaleratio = true;
+        this.zoomCoordinates = [];
+        this.plotUtilities = new PlotUtilities();
+        this.onPlotMouseDown = null;
+        this.cachedImageWidth = 0;
+        this.cachedImageHeight = 0;
+        this.cachedImageRatios = [1, 1];
+        this.cachedIsGrayscale = false;
+        /** Data-space coordinate of the cached frame's pixel (0,0). [0,0] for the full
+         *  image; a crop's top-left when zoomed (so the intensity profile samples the
+         *  zoom-level pixels at the right offset/resolution). */
+        this.cachedFrameOrigin = [0, 0];
+        /** Last visible image-pixel rectangle from the active backend's viewport (set by
+         *  the OSD viewport-change hook via refreshIntensitySamplingForRoi). New profile lines are
+         *  placed within it so they land on-screen when zoomed in; null → use full image. */
+        this.lastVisibleRoi = null;
+        this.stackLoading$ = new BehaviorSubject(false);
+        this.stackLoadingProgress$ = new BehaviorSubject(0);
+        // current index of image in stack (if stack), 0 if single image
+        this.zIndex = new BehaviorSubject(0);
+        this.autoscaleEvent = new Subject();
+        // The region update event and selection stream are owned by the shared
+        // RegionStore; getRegionUpdateEvent()/getSelectedShapeIndices$() delegate to
+        // it so every consumer (and the OSD backend) sees one stream.
+        /** Bright, well-separated colours cycled as the user adds profile-line ROIs.
+         *  The matching inset trace is drawn in the same colour. */
+        this.PROFILE_PALETTE = [
+            '#FFD400', // yellow
+            '#00E5FF', // cyan
+            '#FF2D95', // magenta
+            '#39FF14', // green
+            '#FF9500', // orange
+            '#7C4DFF', // violet
+            '#FF3B30', // red
+            '#18FFFF', // aqua
+        ];
+        /** Palette cursor for profile lines (never reset on delete, so colours keep
+         *  cycling across the session). */
+        this.profileColorSeq = 0;
+        this.intensityProfile$ = new Subject();
+        /** ISOSURFACE band as a 0–255 slider position, mapped onto the volume's real
+         *  intensity range at render time (see mapIsoBand). Defaults to the full range
+         *  so the first render shows the whole structure regardless of how bright or
+         *  dark the volume is; the user then narrows the band to isolate intensities. */
+        this.isoMin = 0;
+        this.isoMax = 255;
+        /** Actual intensity range of the volume on screen ([min,max] over the loaded
+         *  frames). The slider spans 0–255, but a given stack often occupies only a
+         *  sub-range, so we clamp the iso band into this range (with a small margin)
+         *  to guarantee non-degenerate surfaces — both on first render and on live
+         *  slider moves. Null until an isosurface volume has been measured. */
+        this.isoDataRange = null;
+        // Id minting and the selection index stream are owned by the shared
+        // RegionStore. Selection still drives Plotly's `_activeShapeIndex` (so a
+        // single shape gets the edit handles) — see setSelectedShapeIndices().
+        this.imageCached = false;
+        this.coordinateTransform = new PlotlyCoordinateTransform(() => document.getElementById(this.plotDiv), () => this.getOverlayContainer());
+        // relayout event router
+        this.onRelayoutEvent = (event) => { this.relayoutEventHandler(event); };
+        // Tool services read/mutate our state via small *Host interfaces. Stored
+        // so we can re-bind them to ourselves whenever a Plotly tool is activated
+        // (the OpenSeadragon backend re-binds the same singleton tools to itself).
+        this.wandHost = {
+            getRegions: () => this.regionStore.getRegions(),
+            setRegions: (regions) => this.setRegions(regions),
+            getCachedImageData: () => this.getCachedImageData(),
+            getActiveFrameIndex: () => this.activeFrameIndex(),
+            getOverlayContainer: () => this.getOverlayContainer(),
+            getCoordinateTransform: () => this.getCoordinateTransform(),
+            getFileName: () => this.fileName,
+            getShapeColor: () => this.regionStore.getShapeColor(),
+        };
+        this.eraserHost = {
+            getRegions: () => this.regionStore.getRegions(),
+            setRegions: (regions) => this.setRegions(regions),
+            invalidateWandRegion: () => this.wandTool.clearActiveRegion(),
+            getOverlayContainer: () => this.getOverlayContainer(),
+            getCoordinateTransform: () => this.getCoordinateTransform(),
+            getCachedImageRatio: () => this.cachedImageRatios[0] || 1,
+        };
+        this.wandTool.bindHost(this.wandHost);
+        // The brush reuses the wand host (same coordinate frame + region access).
+        this.brushTool.bindHost(this.wandHost);
+        this.vertexEraserTool.bindHost(this.eraserHost);
+        this.bindZoomToBoxHost();
+        this.imageCachedSubscription = this.state.isImageCached$().subscribe(imageCached => {
+            this.imageCached = imageCached;
+        });
+        this.filenameSubscription = this.state.getFilename$().subscribe(filename => {
+            this.fileName = filename;
+        });
+        // Live recolor from the Channels & Histogram pane: restyle the display window (zmin/zmax for
+        // a heatmap, cmin/cmax for isosurface/surface), the colorscale (colormap), and reverse/invert
+        // when the channel state OR the colormap changes. (Gamma is applied by the OSD image view; the
+        // Plotly colorscale window covers the common contrast case.)
+        this.channelSub = combineLatest([
+            this.store.getChannelStates(),
+            this.store.getReverseScale(),
+            this.store.getInvert(),
+            this.store.getColormap(),
+        ]).subscribe(([channels, rev, inv]) => this.applyChannelDisplay(channels, rev, inv));
+        // Profile lines are store regions; any region change (add/drag/delete, on
+        // either backend) should refresh the inset traces. The live-edit stream
+        // fires per frame during a drag (OSD coalesces regionUpdate$ until release),
+        // so the inset tracks an OSD line ROI live as it's moved.
+        this.regionUpdateSubscription = this.regionStore.getRegionUpdateEvent().subscribe(() => {
+            this.emitProfiles();
+        });
+        this.regionLiveEditSubscription = this.regionStore.getRegionLiveEdit$().subscribe(() => {
+            this.emitProfiles();
+        });
+    }
+    getTrueImageSize() {
+        if (!this.trueImgSize)
+            return null;
+        return {
+            width: this.trueImgSize[1] - this.trueImgSize[0],
+            height: this.trueImgSize[3] - this.trueImgSize[2],
+        };
+    }
+    /**
+     * Load image
+     * @param imageInfo
+     * @param zIndex index of the image to load
+     * @return an object with data and ratio keys
+     */
+    async load(imageInfo, zIndex) {
+        const urls = imageInfo.urls;
+        // use zIndex provided if any, 0 otherwise
+        let imageUrl;
+        if (zIndex) {
+            imageUrl = urls[zIndex];
+        }
+        else {
+            imageUrl = urls[0];
+        }
+        const isGrayscale = imageInfo.isGrayscale;
+        const image = await this.loadImage(imageUrl);
+        const xRatio = imageInfo.trueImageSize[0] / image.width;
+        const yRatio = imageInfo.trueImageSize[1] / image.height;
+        const trueImageSize = [];
+        // [x0, x1, y0, y1]
+        trueImageSize[0] = 0;
+        trueImageSize[1] = imageInfo.trueImageSize[0];
+        trueImageSize[2] = 0;
+        trueImageSize[3] = imageInfo.trueImageSize[1];
+        this.trueImgSize = trueImageSize;
+        this.fileName = imageInfo.fileName;
+        if (imageInfo.isStack && imageInfo.showStack) {
+            const images = [];
+            this.stackLoadingProgress$.next(0);
+            // One URL per slice — load them all (earlier `length-1` dropped the last).
+            for (let i = 0; i < urls.length; i++) {
+                console.log(`image stack ${i}`);
+                // do not keep with loading if filename is different (a new file has been selected)
+                // or if the stackLoading value is set to false
+                if (this.fileName === imageInfo.fileName && this.stackLoading$.value) {
+                    const image = await this.loadImage(urls[i]);
+                    if (isGrayscale) {
+                        const grey = image.grey();
+                        const imgData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);
+                        images.push(imgData);
+                    }
+                    else {
+                        const rgbData = image.getPixelsArray();
+                        const rgbMatrix = this.plotUtilities.arrayToMatrix(rgbData, image.width);
+                        images.push(rgbMatrix);
+                    }
+                    this.stackLoadingProgress$.next(Math.round((i * 100) / urls.length));
+                }
+                else {
+                    // break stack loading
+                    break;
+                }
+            }
+            // reset stackLoading progress to 0
+            this.stackLoadingProgress$.next(0);
+            return { data: images, ratios: [xRatio, yRatio],
+                sizes: [image.width, image.height],
+                filename: imageInfo.fileName };
+        }
+        else {
+            let imageData;
+            if (isGrayscale) {
+                const grey = image.grey();
+                imageData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);
+            }
+            else {
+                const rgbData = image.getPixelsArray();
+                imageData = this.plotUtilities.arrayToMatrix(rgbData, image.width);
+            }
+            return { data: [imageData],
+                ratios: [xRatio, yRatio],
+                sizes: [image.width, image.height],
+                filename: imageInfo.fileName };
+        }
+    }
+    /**
+     *
+     * @param plotDiv
+     * @param imageLoaded object with data, ratios and sizes key
+     * @param imageInfo ImageInfo object
+     * @param screenHeight size of the available screen height
+     * @param plotType type of plotting
+     */
+    /**
+     * @param inPlace when true, updates the existing plot via Plotly.react
+     *   instead of Plotly.purge + Plotly.newPlot. Used by the multi-tier
+     *   diagram swap (small → large) so the canvas doesn't briefly blank
+     *   between phases.
+     */
+    plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace = false) {
+        const trueImageSize = [];
+        this.zoomCoordinates = [];
+        // [x0, x1, y0, y1]
+        trueImageSize[0] = 0;
+        trueImageSize[1] = imageInfo.trueImageSize[0];
+        trueImageSize[2] = 0;
+        trueImageSize[3] = imageInfo.trueImageSize[1];
+        // Save the current image's regions and pull in any cached regions for the
+        // image we're about to display, before Plotly.newPlot reads `this.shapes`.
+        this.setActiveImage(imageInfo);
+        this.imageInfo = imageInfo;
+        this.plotType = plotType;
+        // Cache pixel matrices so the wand tool can sample them.
+        this.cachedImageFrames = imageLoaded.data;
+        this.cachedImageWidth = imageLoaded.sizes[0];
+        this.cachedImageHeight = imageLoaded.sizes[1];
+        this.cachedImageRatios = imageLoaded.ratios;
+        this.cachedFrameOrigin = [0, 0]; // full image — reset any prior zoom-crop origin
+        this.cachedIsGrayscale = !!imageInfo.isGrayscale;
+        // Pluggable plot types (contour, scatter, scatter3d, isosurface) render
+        // through the trace-builder registry. The original HEATMAP/SURFACE/RGB-image
+        // renderers keep their dedicated paths below (also reused by the high-def
+        // zoom re-fetch). Intensity profiles are no longer a plot type — they're
+        // Region-based line ROIs, available in HEATMAP/IMAGE mode.
+        const impl = PLOTLY_PLOT_TYPE_IMPLS[plotType];
+        if (impl) {
+            this.imageInfo.isGrayscale = !!imageInfo.isGrayscale;
+            return this.plotViaRegistry(plotDiv, impl, this.buildTraceInput(imageInfo, imageLoaded, trueImageSize), screenHeight, inPlace);
+        }
+        if (imageInfo.isGrayscale) {
+            if (plotType === PlotType.SURFACE) {
+                return this.plotSurface(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, screenHeight, inPlace);
+            }
+            return this.plotHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, screenHeight, inPlace);
+        }
+        return this.plotRGBHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, imageLoaded.sizes[0], imageLoaded.sizes[1], screenHeight, inPlace);
+    }
+    /**
+     * Function used to plot a grayscale heatmap
+     * @param plotDiv
+     * @param urls
+     * @param images
+     * @param trueImgSize array containing the following : [x0, x1, y0, y1]
+     * @param ratios
+     * @param screenHeight
+     * @return Promise true when plotting is finished
+     */
+    plotHeatmap(plotDiv, urls, images, trueImgSize, ratios, screenHeight, inPlace = false) {
+        if (!inPlace)
+            Plotly.purge(plotDiv);
+        this.plotDiv = plotDiv;
+        this.imageLength = images.length;
+        this.urls = urls;
+        this.screenHeight = screenHeight;
+        // plot
+        const traces = [];
+        images.forEach((dataset, index) => {
+            const trace = {
+                x0: trueImgSize[0],
+                dx: ratios[0],
+                y0: trueImgSize[2],
+                dy: ratios[0],
+                z: dataset,
+                type: 'heatmap',
+                // We remove the tooltip annotation for performances reasons
+                // text: dataset.map((row: any[], i: any) => row.map((item, j) => {
+                //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),
+                hoverinfo: 'none',
+                colorscale: this.store.currentColormap().data.value,
+                reversescale: this.store.currentReverseScale(),
+                name: `Slice ${index + 1}`,
+                visible: index === 0
+            };
+            traces.push(trace);
+        });
+        const render = inPlace ? Plotly.react : Plotly.newPlot;
+        return render(plotDiv, traces, this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3],
+            trueImgSize[2]]), CONFIG).then(() => {
+            // handle the relayout event for zoom / rois and the click event
+            this.setEvents(plotDiv, true, screenHeight);
+            return true;
+        });
+    }
+    /**
+     * Function used to plot a grayscale surface
+     * @param plotDiv
+     * @param urls
+     * @param images
+     * @param trueImgSize array containing the following : [x0, x1, y0, y1]
+     * @param ratios
+     * @param screenHeight
+     * @return Promise true when plotting is finished
+     */
+    plotSurface(plotDiv, urls, images, trueImgSize, ratios, screenHeight, inPlace = false) {
+        if (!inPlace)
+            Plotly.purge(plotDiv);
+        this.plotDiv = plotDiv;
+        this.imageLength = images.length;
+        this.urls = urls;
+        this.screenHeight = screenHeight;
+        // plot
+        const traces = [];
+        images.forEach((dataset, index) => {
+            const trace = {
+                z: dataset,
+                type: 'surface',
+                // hoverinfo: 'none',
+                colorscale: this.store.currentColormap().data.value,
+                reversescale: this.store.currentReverseScale(),
+                // name: `Slice ${index + 1}`,
+                // visible: index === 0
+            };
+            traces.push(trace);
+        });
+        const xrange = [trueImgSize[0], trueImgSize[1]];
+        const yrange = [trueImgSize[2], trueImgSize[3]];
+        const render = inPlace ? Plotly.react : Plotly.newPlot;
+        return render(plotDiv, traces, this.getSurfaceLayout(xrange, yrange, 0.4), CONFIG_SURFACE).then(() => {
+            // handle the relayout event for zoom / rois and the click event
+            this.setEvents(plotDiv, true, screenHeight);
+            return true;
+        });
+    }
+    /**
+     * Function used to plot an RGB heatmap
+     * @param plotDiv
+     * @param urls
+     * @param images
+     * @param trueImgSize
+     * @param width
+     * @param height
+     * @param ratios
+     * @param screenHeight
+     * @return Promise
+     */
+    plotRGBHeatmap(plotDiv, urls, images, trueImgSize, ratios, width, height, screenHeight, inPlace = false) {
+        // Plotly.react updates in place; Plotly.purge + Plotly.newPlot blanks
+        // the canvas for ~100ms which makes the multi-tier small→large swap
+        // look like a regression to "loading" before the sharper version
+        // appears.
+        if (!inPlace)
+            Plotly.purge(plotDiv);
+        this.plotDiv = plotDiv;
+        this.imageLength = images.length;
+        this.urls = urls;
+        this.screenHeight = screenHeight;
+        // as autorange is set to false, and not reversed we need to set the yrange correcly here
+        const layout = this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);
+        const traces = [];
+        images.forEach((dataset, index) => {
+            const trace = {
+                x0: trueImgSize[0],
+                dx: ratios[0],
+                y0: trueImgSize[2],
+                dy: ratios[0],
+                x: Array.from(Array(width).keys()),
+                y: Array.from(Array(height).keys()),
+                z: dataset,
+                // text: dataset.map((row: any[], i: any) => row.map((item, j) => {
+                //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),
+                hoverinfo: 'none',
+                type: 'image',
+                name: `Slice ${index + 1}`,
+                visible: index === 0
+            };
+            traces.push(trace);
+        });
+        const render = inPlace ? Plotly.react : Plotly.newPlot;
+        return render(plotDiv, traces, layout, CONFIG).then(() => {
+            // handle the relayout event
+            this.setEvents(plotDiv, false, screenHeight);
+            return true;
+        });
+    }
+    /**
+     * Assemble the normalised input the pluggable trace builders consume.
+     * Pure data only — no Plotly handles — so the builders stay backend-neutral.
+     */
+    buildTraceInput(imageInfo, imageLoaded, trueImageSize) {
+        // Measure the volume's real intensity range so the iso band can be clamped
+        // into it (the slider is a fixed 0–255 but a stack may occupy only part of
+        // that, which would otherwise leave the surfaces with nothing to cross).
+        if (this.plotType === PlotType.ISOSURFACE) {
+            this.isoDataRange = this.measureIntensityRange(imageLoaded.data, !!imageInfo.isGrayscale);
+        }
+        const [isoMin, isoMax] = this.mapIsoBand(this.isoMin, this.isoMax);
+        return {
+            frames: imageLoaded.data,
+            width: imageLoaded.sizes[0],
+            height: imageLoaded.sizes[1],
+            ratios: imageLoaded.ratios,
+            trueImageSize,
+            isGrayscale: !!imageInfo.isGrayscale,
+            colorscale: this.store.currentColormap().data.value,
+            reversescale: this.store.currentReverseScale(),
+            regions: this.getRegionPolygons(),
+            shapeColor: this.regionStore.getShapeColor(),
+            isoMin,
+            isoMax,
+        };
+    }
+    /** Min/max intensity over every voxel of the loaded frames (RGB → luminance),
+     *  used to keep the iso band inside the data. Returns null for empty input. */
+    measureIntensityRange(frames, isGrayscale) {
+        let min = Infinity, max = -Infinity;
+        for (const frame of frames || []) {
+            for (const row of frame || []) {
+                for (const cell of row || []) {
+                    const v = isGrayscale ? cell
+                        : 0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2];
+                    if (!Number.isFinite(v))
+                        continue;
+                    if (v < min)
+                        min = v;
+                    if (v > max)
+                        max = v;
+                }
+            }
+        }
+        return (Number.isFinite(min) && Number.isFinite(max) && max > min) ? [min, max] : null;
+    }
+    /** Map the 0–255 slider band onto the volume's actual intensity range. The
+     *  slider is fixed 0–255, but a stack often occupies only a narrow sub-range
+     *  (e.g. this EDOF volume is ~2–50 with structure near 6–10). Mapping spreads
+     *  the data across the whole slider so every intensity is easy to reach and
+     *  the band always lands inside the data — a small inset keeps the extreme
+     *  surfaces off the exact data edges, which are degenerate and draw nothing. */
+    mapIsoBand(isoMin, isoMax) {
+        let lo = Math.min(isoMin, isoMax);
+        let hi = Math.max(isoMin, isoMax);
+        if (this.isoDataRange) {
+            const [vMin, vMax] = this.isoDataRange;
+            const span = vMax - vMin;
+            const pad = 0.03 * span;
+            const usable = span - 2 * pad;
+            const SLIDER_MAX = 255; // toolbar slider domain (isoValueMax)
+            lo = vMin + pad + (lo / SLIDER_MAX) * usable;
+            hi = vMin + pad + (hi / SLIDER_MAX) * usable;
+            if (lo > hi) {
+                const t = lo;
+                lo = hi;
+                hi = t;
+            }
+        }
+        return [lo, hi];
+    }
+    /**
+     * Update the isosurface intensity bounds. When isosurface is on screen this
+     * restyles `isomin`/`isomax` in place for a live update (no volume rebuild).
+     * Slider values are mapped onto the volume's real range so the surfaces always
+     * have data to cross (matching the initial render).
+     */
+    setIsoRange(isoMin, isoMax) {
+        this.isoMin = isoMin;
+        this.isoMax = isoMax;
+        if (this.plotType === PlotType.ISOSURFACE && this.plotDiv) {
+            const [lo, hi] = this.mapIsoBand(isoMin, isoMax);
+            try {
+                Plotly.restyle(this.plotDiv, { isomin: [lo], isomax: [hi] });
+            }
+            catch { /* plot not ready */ }
+        }
+    }
+    /** Plotly renders isosurfaces, so it exposes the isosurface controls (itself). */
+    getIsosurfaceControls() { return this; }
+    /**
+     * Render a registry-backed plot type: build its traces from the input, pick
+     * the matching layout, render, and wire the usual relayout/click events.
+     * Mirrors the structure of the dedicated heatmap/surface renderers.
+     */
+    plotViaRegistry(plotDiv, impl, input, screenHeight, inPlace = false) {
+        if (!inPlace)
+            Plotly.purge(plotDiv);
+        this.plotDiv = plotDiv;
+        this.imageLength = input.frames.length;
+        this.urls = this.imageInfo?.urls ?? this.urls;
+        this.screenHeight = screenHeight;
+        const traces = impl.buildTraces(input);
+        const [x0, x1, y0, y1] = input.trueImageSize;
+        let layout;
+        switch (impl.layoutKind) {
+            case '3d-volume':
+                layout = this.getVolumeLayout();
+                break;
+            case '2d-chart':
+                layout = this.getChartLayout();
+                break;
+            case '2d-overlay':
+                layout = this.getOverlayLayout([x0, x1], [y1, y0]); // reversed y like the image
+                break;
+            default: // '2d-image'
+                layout = this.getHeatmapLayout([x0, x1], [y1, y0]);
+        }
+        const config = impl.threeD ? CONFIG_SURFACE : CONFIG;
+        const render = inPlace ? Plotly.react : Plotly.newPlot;
+        return render(plotDiv, traces, layout, config).then(() => {
+            this.setEvents(plotDiv, input.isGrayscale, screenHeight);
+            return true;
+        });
+    }
+    /** Plain 2D chart axes (intensity profile / line plots). */
+    getChartLayout() {
+        return {
+            margin: { t: 30, b: 45, l: 60, r: 20 },
+            height: this.screenHeight,
+            autosize: true,
+            xaxis: { title: 'Position (px)' },
+            yaxis: { title: 'Intensity' },
+            dragmode: false,
+        };
+    }
+    /** Image-aligned 2D axes without the z-plane slider (region scatter). */
+    getOverlayLayout(xRange, yRange) {
+        return {
+            xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },
+            yaxis: {
+                constrain: 'range', constraintoward: 'center', range: yRange, ticks: '',
+                ticksuffix: '  ', autorange: false, scaleanchor: this.scaleratio ? 'x' : false,
+            },
+            margin: { t: 30, b: 5, l: 55, r: 5 },
+            height: this.screenHeight,
+            autosize: true,
+            shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),
+            dragmode: this.dragMode ? this.dragMode : false,
+        };
+    }
+    /** 3D scene for volumetric plot types (scatter3d, isosurface). */
+    getVolumeLayout() {
+        return {
+            margin: { t: 0, b: 0, l: 0, r: 0 },
+            height: this.screenHeight,
+            autosize: true,
+            scene: {
+                xaxis: { title: 'X' },
+                yaxis: { title: 'Y' },
+                zaxis: { title: 'Z-plane' },
+                // 'cube' (not 'data'): a z-stack has far fewer planes than X/Y pixels,
+                // so 'data' squashes the volume into a near-flat slab that reads as
+                // empty edge-on. A cube gives the z dimension real height so the
+                // isosurface/voxels are actually visible.
+                aspectmode: 'cube',
+            },
+        };
+    }
+    /** Plot types this backend advertises (drives the UI selector). */
+    getPlotTypeDescriptors() {
+        return Object.values(PLOT_TYPE_DESCRIPTORS).filter((d) => !!d);
+    }
+    /** This backend's region renderer. Plotly draws shapes natively, so the
+     *  overlay is a thin adapter over this service's drag modes. */
+    getRegionOverlay() {
+        if (!this.regionOverlay)
+            this.regionOverlay = new PlotlyRegionOverlay(this);
+        return this.regionOverlay;
+    }
+    // ── Intensity profile (Region-based line ROIs) ──────────────────────
+    /** Emits the full set of intensity profiles (one per profile-line region)
+     *  whenever a profile line is added, moved, or removed. */
+    getIntensityProfile$() {
+        return this.intensityProfile$.asObservable();
+    }
+    /** Plotly renders the line ROIs + inset, so it exposes the intensity controls. */
+    getIntensityControls() { return this; }
+    /**
+     * Render the floating intensity-profile inset chart into `divId` — one line
+     * trace per ROI, each drawn in its ROI's colour. Kept here (not in the diagram
+     * component) so the consumer never touches Plotly directly.
+     */
+    renderIntensityInset(divId, profiles) {
+        const el = document.getElementById(divId);
+        if (!el)
+            return;
+        const traces = (profiles ?? []).map((p, i) => ({
+            x: p.positions,
+            y: p.values,
+            type: 'scatter',
+            mode: 'lines',
+            line: { color: p.color ?? '#FFD400', width: 2 },
+            name: `Line ${i + 1}`,
+            hoverinfo: 'x+y',
+        }));
+        // X axis is in microns when the image carries a physical pixel size (mpp),
+        // otherwise in pixels — driven by the unit the sampler tagged on the profile.
+        const unit = (profiles ?? []).find(p => p.unit)?.unit ?? 'px';
+        const xTitle = unit === 'µm' ? 'Position (µm)' : 'Position (px)';
+        Plotly.react(el, traces, {
+            margin: { t: 6, r: 8, b: 38, l: 40 },
+            xaxis: { title: xTitle, zeroline: false, color: '#ddd' },
+            yaxis: { title: 'Intensity', zeroline: false, color: '#ddd' },
+            showlegend: false,
+            paper_bgcolor: 'rgba(25,25,25,0.9)',
+            plot_bgcolor: 'rgba(25,25,25,0.9)',
+            font: { color: '#eee', size: 10 },
+        }, { displayModeBar: false, responsive: true });
+    }
+    /**
+     * Region shapes (filtered/redrawn for the current file). The profile-line ROIs
+     * are ordinary store regions (tagged `kind: 'profile'`), so they are already
+     * part of `this.shapes` — no separate append is needed.
+     */
+    currentRenderShapes(showLabel = this.regionStore.getShowShapeLabel()) {
+        return this.shapesToRedraw(showLabel);
+    }
+    /**
+     * IIntensityControls: add another intensity-profile line as a neutral Region
+     * (tagged `kind: 'profile'`). It is a horizontal open 2-point polyline spanning
+     * the image width, staggered vertically so successive lines stay distinct, in
+     * the next bright palette colour. Added to the shared store so both backends
+     * (Plotly + OpenSeadragon) render and drag it; excluded from the Regions tab
+     * and exports by its kind.
+     */
+    addProfileLine() {
+        if (!this.trueImgSize)
+            return null;
+        const count = this.getProfileRegions().length;
+        const imgX0 = this.trueImgSize[0], imgX1 = this.trueImgSize[1];
+        const imgTop = this.trueImgSize[2], imgBottom = this.trueImgSize[3];
+        // Place the line within the currently VISIBLE image area, so when zoomed in it
+        // lands on-screen instead of spanning the whole (mostly off-screen) image, at
+        // 2/3 of the visible width and horizontally centred. Falls back to the full
+        // image when no viewport ROI is known (Plotly heatmap) or a stale ROI no longer
+        // overlaps the image.
+        const roi = this.lastVisibleRoi;
+        const overlaps = !!roi && roi.width > 0 && roi.height > 0
+            && roi.x < imgX1 && roi.x + roi.width > imgX0
+            && roi.y < imgBottom && roi.y + roi.height > imgTop;
+        const x0v = overlaps ? Math.max(imgX0, roi.x) : imgX0;
+        const x1v = overlaps ? Math.min(imgX1, roi.x + roi.width) : imgX1;
+        const topV = overlaps ? Math.max(imgTop, roi.y) : imgTop;
+        const bottomV = overlaps ? Math.min(imgBottom, roi.y + roi.height) : imgBottom;
+        const cx = (x0v + x1v) / 2;
+        const half = ((x1v - x0v) * (2 / 3)) / 2; // line spans 2/3 of the visible width
+        const x0 = cx - half, x1 = cx + half;
+        const bandH = bottomV - topV;
+        const midY = (topV + bottomV) / 2;
+        // Stagger successive lines across the visible band so they stay distinct.
+        const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));
+        const poly = new Polygon();
+        poly.npoints = 2;
+        poly.xpoints = [x0, x1];
+        poly.ypoints = [y, y];
+        poly.coordinates = [[x0, y], [x1, y]];
+        poly.closed = false;
+        const region = new Region();
+        region.bounds = poly;
+        region.kind = 'profile';
+        region.color = this.PROFILE_PALETTE[this.profileColorSeq++ % this.PROFILE_PALETTE.length];
+        // Leave region.label undefined so applyClassificationColors won't recolor it.
+        this.regionStore.addRegion(region);
+        // If a Plotly plot is on screen, re-render shapes so the new line appears.
+        // (The OSD overlay renders automatically via its region-update subscription.)
+        if (this.plotDiv) {
+            this.syncShapesFromStore();
+            try {
+                Plotly.relayout(this.plotDiv, { shapes: this.currentRenderShapes() });
+            }
+            catch { /* div not a Plotly plot (OSD owns it) */ }
+        }
+        return region;
+    }
+    /** The profile-line ROIs currently in the store (kind === 'profile'). */
+    getProfileRegions() {
+        return this.regionStore.getRegions().filter(r => r.kind === 'profile');
+    }
+    /** Recompute and broadcast a profile for every profile-line region (id + colour
+     *  tagged so the inset trace matches its line). */
+    emitProfiles() {
+        this.intensityProfile$.next(this.getProfileRegions().map(r => ({
+            ...this.computeIntensityProfileForRegion(r),
+            id: r.id,
+            color: r.color,
+        })));
+    }
+    /**
+     * Sample the intensity profile for a profile-line region: extract its two
+     * polygon endpoints and reuse the shared `computeIntensityProfile` sampling.
+     */
+    computeIntensityProfileForRegion(region) {
+        // Duck-typed (not `instanceof Polygon`): after a drag round-trips through the
+        // store the bounds can be a plain object, so match on the point arrays.
+        const poly = region.bounds;
+        if (!poly || !Array.isArray(poly.xpoints) || !Array.isArray(poly.ypoints) ||
+            poly.xpoints.length < 2 || poly.ypoints.length < 2) {
+            return { positions: [], values: [] };
+        }
+        return this.computeIntensityProfile({
+            x0: poly.xpoints[0], y0: poly.ypoints[0],
+            x1: poly.xpoints[1], y1: poly.ypoints[1],
+        });
+    }
+    /**
+     * Supply pixel frames for intensity sampling (used by the OSD/image backend,
+     * whose cached frames may be empty). Optionally also sets the data/pixel ratios.
+     */
+    setSamplingFrames(frames, ratios, origin = [0, 0]) {
+        this.cachedImageFrames = frames;
+        if (ratios)
+            this.cachedImageRatios = ratios;
+        this.cachedFrameOrigin = origin;
+    }
+    /**
+     * Populate the sampling cache for the intensity profiles when OpenSeadragon is
+     * the active backend (the Image plot type). In OSD mode Plotly never rendered,
+     * so `cachedImageFrames`/`trueImgSize` are unset — fetch the current slice's
+     * preview (the same pixels the heatmap would sample) so the line ROIs have
+     * pixel data and a placement extent. Re-emits the profiles once loaded.
+     */
+    async ensureIntensitySampling(imageInfo, zIndex) {
+        if (!imageInfo?.urls?.length)
+            return;
+        // Sample just the displayed slice (showStack off → single frame); `load`
+        // also sets `this.trueImgSize`, which addProfileLine needs for placement.
+        const single = { ...imageInfo, showStack: false };
+        const loaded = await this.load(single, zIndex || 0);
+        this.cachedImageFrames = loaded.data;
+        this.cachedImageRatios = loaded.ratios;
+        this.cachedImageWidth = loaded.sizes?.[0] ?? this.cachedImageWidth;
+        this.cachedImageHeight = loaded.sizes?.[1] ?? this.cachedImageHeight;
+        this.cachedFrameOrigin = [0, 0]; // full preview
+        this.cachedIsGrayscale = !!imageInfo.isGrayscale;
+        this.emitProfiles();
+    }
+    /**
+     * {@link IIntensitySampling} stub — the viewport-change signal is OpenSeadragon's
+     * (it re-samples on OSD zoom/pan). Plotly's own high-def zoom updates the
+     * sampling cache inline, so it never emits here; returns EMPTY so a uniform
+     * `IVisualizer` consumer can subscribe regardless of the active backend.
+     */
+    getViewportChange$() {
+        return EMPTY;
+    }
+    /**
+     * Re-fetch the given image-pixel ROI at the display resolution and use it as
+     * the intensity-sampling source, so the profile reflects the data at the
+     * current zoom level. Shared by both backends: the OSD viewport-change hook
+     * calls it on zoom/pan; Plotly's own high-def zoom (triggerZoom) updates the
+     * same cache inline. `roi` is in full-image pixel coordinates.
+     */
+    refreshIntensitySamplingForRoi(x, y, width, height, zIndex) {
+        if (width <= 0 || height <= 0)
+            return;
+        // Remember the visible region so a new profile line is placed inside it.
+        this.lastVisibleRoi = { x, y, width, height };
+        const roi = new Rectangle();
+        roi.x = Math.round(x);
+        roi.y = Math.round(y);
+        roi.width = Math.round(width);
+        roi.height = Math.round(height);
+        const screen = this.plotUtilities.getDomRectangle('diagram');
+        // Snapshot the filename so a response that arrives after the user switched
+        // files is dropped (the request carried the file selected at call time).
+        const reqName = this.fileName;
+        this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({
+            next: (zoomData) => {
+                Image.load(Buffer.from(new Uint8Array(zoomData))).then((image) => {
+                    if (this.fileName !== reqName)
+                        return;
+                    const isGray = !!this.imageInfo?.isGrayscale;
+                    const frame = isGray
+                        ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)
+                        : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);
+                    this.setSamplingFrames([frame], [roi.width / image.width, roi.height / image.height], [roi.x, roi.y]);
+                    this.emitProfiles();
+                });
+            },
+            error: () => { },
+        });
+    }
+    /**
+     * Sample the active frame's intensity (grayscale value or RGB luminance)
+     * along the line ROI. Returns distance-along-line positions and values.
+     */
+    computeIntensityProfile(line) {
+        const empty = { positions: [], values: [] };
+        if (!this.cachedImageFrames?.length || !line)
+            return empty;
+        const frame = this.cachedImageFrames[this.activeFrameIndex()] ?? this.cachedImageFrames[0];
+        if (!frame?.length)
+            return empty;
+        const rx = this.cachedImageRatios[0] || 1;
+        const ry = this.cachedImageRatios[1] || rx;
+        const [ox, oy] = this.cachedFrameOrigin;
+        const x0 = +line.x0, y0 = +line.y0, x1 = +line.x1, y1 = +line.y1;
+        const dxData = x1 - x0, dyData = y1 - y0;
+        // Scale the along-line distance by the physical pixel size (microns/pixel)
+        // when the image carries one — anisotropic mppX/mppY are applied per axis so
+        // diagonal lines measure the true physical length. Falls back to pixels.
+        const { mppX, mppY } = this.currentMpp();
+        const useMicrons = mppX != null;
+        const lenData = useMicrons
+            ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX))
+            : Math.hypot(dxData, dyData);
+        const lenPx = Math.hypot(dxData / rx, dyData / ry);
+        const n = Math.max(2, Math.round(lenPx));
+        const h = frame.length;
+        const w = frame[0].length;
+        const positions = [];
+        const values = [];
+        for (let i = 0; i < n; i++) {
+            const t = i / (n - 1);
+            // Map data coords to the cached frame's pixel grid, offset by the frame's
+            // origin (non-zero when the frame is a zoomed crop).
+            const px = Math.round((x0 + t * dxData - ox) / rx);
+            const py = Math.round((y0 + t * dyData - oy) / ry);
+            let v = 0;
+            if (px >= 0 && px < w && py >= 0 && py < h) {
+                const cell = frame[py][px];
+                v = Array.isArray(cell) ? (0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2]) : cell;
+            }
+            positions.push(t * lenData);
+            values.push(v);
+        }
+        return { positions, values, unit: useMicrons ? 'µm' : 'px' };
+    }
+    /** Physical pixel size (microns/pixel) for the current image, if known.
+     *  mpp is constant across frames/channels, so the first metadata entry that
+     *  carries a positive mppX wins. Returns nulls when the image is unscaled. */
+    currentMpp() {
+        const meta = this.imageInfo?.imageMeta;
+        const m = Array.isArray(meta)
+            ? (meta.find(e => e && (e.mppX ?? 0) > 0) ?? meta[0])
+            : undefined;
+        const mppX = m && (m.mppX ?? 0) > 0 ? m.mppX : null;
+        const mppY = m && (m.mppY ?? 0) > 0 ? m.mppY : null;
+        return { mppX, mppY };
+    }
+    /**
+     * autoscale the plot
+     */
+    autoscale() {
+        if (this.plotDiv) {
+            this.zoomCoordinates = [];
+            Plotly.relayout(this.plotDiv, {
+                'xaxis.autorange': true,
+                'yaxis.autorange': false
+            });
+        }
+    }
+    /**
+     * relayout the plot
+     */
+    relayout(trueImageSize) {
+        let imgSize;
+        if (trueImageSize) {
+            imgSize = trueImageSize;
+        }
+        else {
+            imgSize = this.trueImgSize;
+        }
+        if (this.plotDiv) {
+            // Refresh height from current DOM so panel resizes are reflected
+            const plotEl = document.getElementById(this.plotDiv);
+            if (plotEl?.offsetHeight) {
+                this.screenHeight = plotEl.offsetHeight;
+            }
+            try {
+                if (this.zoomCoordinates.length > 0) {
+                    Plotly.relayout(this.plotDiv, this.getHeatmapLayout([this.zoomCoordinates[0], this.zoomCoordinates[1]], [this.zoomCoordinates[2], this.zoomCoordinates[3]])); // reverse the y range
+                }
+                else {
+                    // as autorange is set to false, and not reversed we need to set the yrange correcly here
+                    Plotly.relayout(this.plotDiv, this.getHeatmapLayout([imgSize[0], imgSize[1]], [imgSize[3], imgSize[2]]));
+                }
+            }
+            catch (err) {
+                const msg = err?.error?.message || err?.message || err?.statusText || String(err);
+                console.error('Error occured', err);
+                this.messageService.add({ key: 'center-toast', sticky: true, severity: 'error', summary: 'An error occured', detail: `The following
+                                  error occured: ${msg}. Please try to open the image again through the
+                                  file navigator.` });
+                // TODO correctly clear the plot
+                this.reset();
+            }
+        }
+    }
+    setEvents(plotDiv, isGrayscale, screenHeight) {
+        this.imageInfo.isGrayscale = isGrayscale;
+        this.screenHeight = screenHeight;
+        const plot = document.getElementById(plotDiv);
+        if (plot) {
+            // unbind previous event
+            plot.removeEventListener('plotly_relayout', this.onRelayoutEvent);
+            // bind new event
+            plot.on('plotly_relayout', this.onRelayoutEvent);
+            // Clicking on a shape activates it but Plotly doesn't fire a dedicated
+            // event — sample _activeShapeIndex on the next microtask so subscribers
+            // (Region Editor) can mirror the selection.
+            plot.removeEventListener('mousedown', this.onPlotMouseDown);
+            this.onPlotMouseDown = () => setTimeout(() => this.maybeEmitActiveShapeIndex(), 0);
+            plot.addEventListener('mousedown', this.onPlotMouseDown);
+        }
+    }
+    relayoutEventHandler(event) {
+        if (Object.keys(event).includes('dragmode')) {
+            this.dragMode = event.dragmode;
+        }
+        // when relayout event occurs
+        // update the region selection udpdates
+        const keys = Object.keys(event);
+        let shapesModified = false;
+        keys.forEach((key) => {
+            if (typeof key === 'string' && key.startsWith('shapes[')) {
+                const shapeNumber = +key.split('[')[1].split(']')[0];
+                const shapeChange = key.split('.')[1];
+                if (this.shapes && this.shapes[shapeNumber]) {
+                    if (shapeChange === 'path') {
+                        this.shapes[shapeNumber][shapeChange] = this.plotUtilities.roundPathCoordinates(event[key]);
+                    }
+                    else {
+                        this.shapes[shapeNumber][shapeChange] = Math.round(+event[key]);
+                    }
+                    shapesModified = true;
+                }
+            }
+        });
+        if (shapesModified) {
+            // Mirror the in-place edit into the shared store (syncs its cache + emits).
+            this.commitShapesToStore();
+        }
+        // manage high def zoom (not if we are showing a stack)
+        if (keys.length === 4 && this.isRealZoom) {
+            const coordinates = [];
+            keys.forEach(key => {
+                if (key.startsWith('xaxis.range[')) {
+                    coordinates.push(event[key]);
+                }
+                if (key.startsWith('yaxis.range[')) {
+                    coordinates.push(event[key]);
+                }
+            });
+            this.zoomCoordinates = coordinates;
+            if (!this.imageInfo.showStack) {
+                this.triggerZoom(coordinates);
+            }
+        }
+        // when shape is created
+        if (keys.length === 1 && 'shapes' in event) {
+            this.shapes = event.shapes;
+            for (let i = 0; i < this.shapes.length; i++) {
+                // A freshly Plotly-drawn shape has no id yet — give it a label object
+                // (when labels are on) before the store mints id + default name.
+                const isNew = this.shapes[i].id == null;
+                this.shapes[i].fileName = this.fileName;
+                this.shapes[i] = this.plotUtilities.snapRegion(this.shapes[i]);
+                if (isNew && this.regionStore.getShowShapeLabel()) {
+                    this.shapes[i].label = { text: this.shapes[i].label,
+                        texttemplate: this.shapes[i].label,
+                        font: { color: this.regionStore.getShapeColor() },
+                        textposition: 'top left'
+                    };
+                }
+            }
+            // Mint ids/names in the store, write them back onto the dicts, and emit.
+            this.commitShapesToStore();
+            if (this.isRegionSavedOn) {
+                this.previousShapes = this.shapes.slice();
+            }
+        }
+        // if autoscale
+        if (keys.includes('xaxis.autorange') && keys.includes('yaxis.autorange')) {
+            // trigger an autoscale event to reset the selected image mode dropdown
+            this.autoscaleEvent.next('an autoscale has happened');
+            // select display type to trigger a new plotting update with all the necessary plotting parameters set
+            this.tiles.selectDiagramDisplay();
+        }
+        // if showstack or aspectratio event
+        if (event.showstack !== undefined || event.aspectratio !== undefined) {
+            // Set new image info to trigger a plot update
+            this.setImageInfo(event.showstack, event.aspectratio);
+        }
+        // Plotly may have updated the active shape index as part of the relayout
+        // (e.g. clicking a shape's edit handle, or finishing a draw) — surface
+        // that change to the Region Editor.
+        this.maybeEmitActiveShapeIndex();
+    }
+    reloadAndPlot() {
+        this.setImageInfo();
+    }
+    // ── Tool delegations ────────────────────────────────────────────────
+    setWandMode(active, options = {}) {
+        // Re-bind to ourselves in case the OSD backend last used these singletons.
+        if (active)
+            this.wandTool.bindHost(this.wandHost);
+        this.wandTool.setMode(active, options);
+    }
+    setWandOptions(options) {
+        this.wandTool.setOptions(options);
+    }
+    clearActiveWandRegion() {
+        this.wandTool.clearActiveRegion();
+    }
+    setBrushMode(active, options = {}) {
+        // Re-bind to ourselves in case the OSD backend last used this singleton.
+        if (active)
+            this.brushTool.bindHost(this.wandHost);
+        this.brushTool.setMode(active, options);
+    }
+    setBrushOptions(options) {
+        if (options.size != null)
+            this.brushTool.setSize(options.size);
+    }
+    setVertexEraserMode(active) {
+        if (active)
+            this.vertexEraserTool.bindHost(this.eraserHost);
+        this.vertexEraserTool.setMode(active);
+    }
+    setVertexEraserRadius(radius) {
+        this.vertexEraserTool.setRadius(radius);
+    }
+    setZoomToBoxMode(active) {
+        // The zoom-to-box tool is a root singleton shared with the OSD backend,
+        // which rebinds it to its own host on activation. Rebind to ours when we
+        // activate so a prior OSD zoom-to-box doesn't leave the singleton pointing
+        // at OSD's coordinate/zoom handlers (which would break box-zoom on heatmaps).
+        if (active)
+            this.bindZoomToBoxHost();
+        this.zoomToBoxTool.setMode(active);
+    }
+    /** Bind the shared zoom-to-box tool to this (Plotly) backend's host. */
+    bindZoomToBoxHost() {
+        this.zoomToBoxTool.bindHost({
+            getPlotDiv: () => this.plotDiv,
+            pixelToData: (px, py) => this.zoomBoxPixelToData(px, py),
+            applyZoomToBox: (coords) => this.applyZoomToBox(coords),
+        });
+    }
+    /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the
+     *  wand host (cached frame + coordinate transform + region store). */
+    segmentRectangles() {
+        this.samTool.bindHost(this.wandHost);
+        return this.samTool.segmentBoxes();
+    }
+    segmentRectanglesCellpose() {
+        if (!this.cellSegmenter)
+            return Promise.resolve(0);
+        this.cellSegmentTool.bindHost(this.wandHost);
+        return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);
+    }
+    setSamModel(id) {
+        this.samTool.setModel(id);
+        this.samPointTool.setModel(id);
+    }
+    setSamPointMode(active) {
+        if (active)
+            this.samPointTool.bindHost(this.wandHost);
+        this.samPointTool.setMode(active);
+    }
+    commitSamPoints() { this.samPointTool.commit(); }
+    clearSamPoints() { this.samPointTool.clear(); }
+    /**
+     * Tool-host callback: apply the zoom-to-box selection. Stack mode does a
+     * pure axis-range relayout; non-stack mode goes through the high-def
+     * triggerZoom pipeline so the image is re-fetched at the new resolution.
+     */
+    /** Overlay-pixel -> Plotly data coords via the axis objects (subtracting the
+     *  plot margin offset). The zoom-to-box tool calls this through its host. */
+    zoomBoxPixelToData(px, py) {
+        const gd = document.getElementById(this.plotDiv);
+        const xaxis = gd._fullLayout.xaxis;
+        const yaxis = gd._fullLayout.yaxis;
+        return { x: xaxis.p2d(px - xaxis._offset), y: yaxis.p2d(py - yaxis._offset) };
+    }
+    applyZoomToBox(coordinates) {
+        this.zoomCoordinates = coordinates;
+        if (this.imageInfo?.showStack) {
+            Plotly.relayout(this.plotDiv, {
+                'xaxis.range[0]': coordinates[0],
+                'xaxis.range[1]': coordinates[1],
+                'yaxis.range[0]': coordinates[2],
+                'yaxis.range[1]': coordinates[3],
+            });
+        }
+        else {
+            this.triggerZoom(coordinates);
+        }
+    }
+    // ── IViewportHost implementation (for the on-canvas tools) ──────────
+    /** The plot element the tool canvas overlays attach to. */
+    getOverlayContainer() {
+        return this.plotDiv ? document.getElementById(this.plotDiv) : null;
+    }
+    /** Plotly coordinate transform (screen <-> data via the axis objects). */
+    getCoordinateTransform() {
+        return this.coordinateTransform;
+    }
+    // ── WandToolHost implementation ─────────────────────────────────────
+    /** Pixel data the wand needs for sampling. null = no image loaded. */
+    getCachedImageData() {
+        if (!this.cachedImageFrames || this.cachedImageFrames.length === 0)
+            return null;
+        return {
+            frames: this.cachedImageFrames,
+            width: this.cachedImageWidth,
+            height: this.cachedImageHeight,
+            ratios: this.cachedImageRatios,
+            isGrayscale: this.cachedIsGrayscale,
+        };
+    }
+    // ── shared-store sync helpers ──────────────────────────────────────────
+    //
+    // `this.shapes` is Plotly's own representation (the dict array Plotly.relayout
+    // consumes). The shared RegionStore is the single source of truth, holding the
+    // neutral Region model. These helpers bridge the two: writes mirror
+    // `this.shapes` INTO the store; image switches/external changes project the
+    // store back OUT to `this.shapes`.
+    /** Build Plotly shape dicts from the store's regions (the render projection). */
+    regionsToShapeDicts() {
+        const showLabel = this.regionStore.getShowShapeLabel();
+        return this.regionStore.getRegions().map(r => {
+            r.filename = this.fileName;
+            return { ...r.getShape(showLabel) };
+        });
+    }
+    /** Rebuild the dict working-set from the store (after an image switch, or when
+     *  regions changed while another backend was rendering). */
+    syncShapesFromStore() {
+        this.shapes = this.regionsToShapeDicts();
+    }
+    /**
+     * Make the shared store authoritative for the current dict working-set: convert
+     * `this.shapes` to neutral regions and replace the store's list (the store
+     * mints ids, applies class colours, syncs its per-image cache and emits the
+     * region-update event). Store-minted ids are written back onto the dicts so the
+     * two representations stay aligned. Profile-line ROIs are ordinary regions
+     * (tagged `kind: 'profile'`) and round-trip through here too.
+     */
+    commitShapesToStore() {
+        const regions = this.shapes
+            .map(s => Object.assign(new ShapeSelection(), s).getRegion());
+        this.regionStore.setRegions(regions, this.regionStore.getShowShapeLabel(), true, this.regionStore.getFillColor(), false);
+        const stored = this.regionStore.getRegions();
+        for (let i = 0; i < this.shapes.length && i < stored.length; i++) {
+            if (this.shapes[i].id == null)
+                this.shapes[i].id = stored[i].id;
+            if (this.shapes[i].name == null)
+                this.shapes[i].name = stored[i].name;
+        }
+    }
+    /**
+     * Push the current `this.shapes` to Plotly, mirror them into the shared store
+     * (which syncs its cache + emits the region-update event), and refresh the
+     * local previous-shapes buffer. The wand/eraser tools call this after mutating
+     * the shapes array directly.
+     */
+    applyShapesChange() {
+        if (this.isRegionSavedOn) {
+            this.previousShapes = this.shapes.slice();
+        }
+        this.commitShapesToStore();
+        if (this.plotDiv) {
+            const dictArray = this.shapes.map(s => ({ ...s }));
+            try {
+                Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray));
+            }
+            catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
+        }
+    }
+    /** Active frame index in the cached image stack. */
+    activeFrameIndex() {
+        if (!this.cachedImageFrames || this.cachedImageFrames.length <= 1)
+            return 0;
+        const gd = document.getElementById(this.plotDiv);
+        const sliderActive = gd?._fullLayout?.sliders?.[0]?.active;
+        if (typeof sliderActive === 'number')
+            return sliderActive;
+        return this.zIndex.value || 0;
+    }
+    /** Capability-gated 3D scene controls (Plotly renders the 3D plot types). */
+    getSurface3dControls() {
+        return {
+            setSurfaceDragMode: (mode) => this.setSurfaceDragMode(mode),
+            resetSurfaceCamera: () => this.resetSurfaceCamera(),
+        };
+    }
+    setSurfaceDragMode(mode) {
+        if (this.plotDiv) {
+            Plotly.relayout(this.plotDiv, { 'scene.dragmode': mode });
+        }
+    }
+    resetSurfaceCamera() {
+        if (this.plotDiv) {
+            Plotly.relayout(this.plotDiv, { 'scene.camera': {} });
+        }
+    }
+    triggerZoom(coordinates) {
+        if (coordinates.length === 0 || !this.trueImgSize)
+            return;
+        this.zoomCoordinates = coordinates;
+        const rect = this.plotUtilities.getRectangle(coordinates, this.trueImgSize);
+        if (this.plotUtilities.isZoomSameAsImgSize(rect, this.trueImgSize)) {
+            this.autoscale();
+            return;
+        }
+        // A brief "Caching image..." message for uncached files (large files take a
+        // moment to cache); just a spinner otherwise.
+        this.state.setImageLoadingMessage(this.imageCached ? '' : 'Caching image...');
+        const screen = this.plotUtilities.getDomRectangle('diagram');
+        const imageSize = [];
+        imageSize[0] = rect.x;
+        imageSize[1] = rect.x + rect.width;
+        imageSize[2] = rect.y;
+        imageSize[3] = rect.y + rect.height;
+        // Snapshot the filename so a response that arrives after the user switched
+        // files is dropped (the request carried the file selected at call time).
+        const reqName = this.fileName;
+        this.state.setImageLoading(true);
+        this.state.setZoom(true);
+        this.tiles.zoomOnRegion(rect, screen, this.zIndex.value).subscribe({ next: zoomData => {
+                const uint8Array = new Uint8Array(zoomData);
+                const buffer = Buffer.from(uint8Array);
+                Image.load(buffer).then((image) => {
+                    const xRatio = rect.width / image.width;
+                    const yRatio = rect.height / image.height;
+                    if (this.fileName === reqName) {
+                        const isGray = this.imageInfo.isGrayscale;
+                        const frame = isGray
+                            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)
+                            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);
+                        // Also sample the intensity profiles from this high-def crop so the
+                        // inset reflects the zoom-level resolution (origin = crop top-left).
+                        this.setSamplingFrames([frame], [xRatio, yRatio], [imageSize[0], imageSize[2]]);
+                        this.emitProfiles();
+                        // Re-render the high-def crop in the SAME plot type the user is
+                        // viewing. Without this the zoom re-fetch always fell back to a
+                        // heatmap, so zooming in contour (or any registry type) reverted
+                        // to heatmap.
+                        const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];
+                        const renderPromise = impl
+                            ? this.plotViaRegistry(this.plotDiv, impl, this.buildTraceInput(this.imageInfo, {
+                                data: [frame], ratios: [xRatio, yRatio],
+                                sizes: [image.width, image.height], filename: reqName,
+                            }, imageSize), this.screenHeight)
+                            : (isGray
+                                ? this.plotHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio], this.screenHeight)
+                                : this.plotRGBHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio], image.width, image.height, this.screenHeight));
+                        // plotViaRegistry already applies the type's own layout/range for
+                        // non-image layouts (chart/overlay); only re-apply the heatmap
+                        // range for the image-aligned paths.
+                        const reapplyRange = !impl || impl.layoutKind === '2d-image';
+                        renderPromise.then(() => {
+                            this.state.setImageCached(true);
+                            this.state.setImageLoading(false);
+                            image = null;
+                            if (reapplyRange)
+                                this.relayout(imageSize);
+                        });
+                    }
+                });
+            }, error: err => {
+                const msg = err?.error?.message || err?.message || err?.statusText || String(err);
+                console.error('Error occured when zooming', err);
+                this.messageService.add({ key: 'center-toast', sticky: true, severity: 'error', summary: 'An error occured',
+                    detail: `The following error occured while zooming: ${msg}.
+                          Please try to open the image again through the file navigator and
+                          zoom on the selected area once more.` });
+                this.state.setLoadingError(true);
+                this.state.setImageLoading(false);
+            }, complete: () => {
+                console.log('zooming complete');
+            } });
+    }
+    setPlotType(plotType) {
+        this.plotType = plotType;
+    }
+    setImageInfo(showStack, scaleratio) {
+        // Build a partial image descriptor and push it to the host via the port.
+        const imgInfo = {
+            isGrayscale: this.imageInfo.isGrayscale,
+            trueImageSize: [this.trueImgSize[1], this.trueImgSize[3]],
+            urls: this.urls,
+            isStack: this.urls.length > 1,
+            scaleRatio: scaleratio !== undefined ? scaleratio : this.scaleratio,
+        };
+        if (showStack !== undefined)
+            imgInfo.showStack = showStack;
+        if (this.fileName)
+            imgInfo.fileName = this.fileName;
+        this.state.setImageInfo(imgInfo);
+    }
+    getShapes() {
+        return this.shapes;
+    }
+    /**
+     * Framework-neutral view of the current regions — delegates to the shared
+     * RegionStore (the single source of truth). The canonical accessor on the
+     * `IVisualizer` contract; consumers should prefer this over `getShapes()`
+     * (which exposes Plotly-shaped dicts).
+     */
+    getRegions() {
+        return this.regionStore.getRegions();
+    }
+    /**
+     * Switch the active image. The shared RegionStore owns the per-image region
+     * cache (snapshot outgoing / restore incoming / clear selection / emit); we
+     * delegate to it, then re-project the store's regions into Plotly's dict
+     * working-set. Re-projecting unconditionally (even when the store no-ops for
+     * the same image) means Plotly also picks up regions another backend (OSD)
+     * added while it was off-screen. Called from `plot()` and from the router
+     * before any backend renders.
+     */
+    setActiveImage(imageInfo) {
+        this.regionStore.setActiveImage(imageInfo);
+        this.syncShapesFromStore();
+        this.previousShapes = this.shapes.slice();
+    }
+    /** Test/dev hook — drop the entire per-image cache (logout / project switch). */
+    clearRegionsByImageKey() {
+        this.regionStore.clearRegionsByImageKey();
+    }
+    /**
+     * Get all the selected regions as polygons. Open polylines (closed === false)
+     * are excluded — they're annotation-only and cannot be used as filled regions
+     * for image processing. Delegates to the shared store.
+     */
+    getRegionPolygons() {
+        return this.regionStore.getRegionPolygons();
+    }
+    isRectangle(bnds) {
+        return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;
+    }
+    isPolygon(bnds) {
+        return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;
+    }
+    /**
+     * Set plot regions. Delegates the state change to the shared RegionStore
+     * (id/name minting, classification colours, append de-duplication, per-image
+     * cache and the region-update event all live there), then re-projects the
+     * store's regions into Plotly's dict working-set and renders.
+     *
+     * When `isRegionSaveOn` is false the regions are shown transiently — rendered
+     * without altering the stored working-set (preserves the prior behaviour).
+     */
+    setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append = false) {
+        const showLabel = showRegionLabel === undefined ? this.regionStore.getShowShapeLabel() : showRegionLabel;
+        const save = isRegionSaveOn === undefined ? this.isRegionSavedOn : isRegionSaveOn;
+        this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
+        this.isRegionSavedOn = save;
+        if (save) {
+            // Re-project the authoritative regions into Plotly's working-set and render.
+            this.syncShapesFromStore();
+            this.renderShapes();
+        }
+        else {
+            // Transient display only — render the passed regions, don't touch the
+            // working-set (and the store didn't store them either).
+            const dicts = regions.map(r => { r.filename = this.fileName; return { ...r.getShape(showLabel) }; });
+            try {
+                Plotly.relayout(this.plotDiv, this.shapesRelayout(dicts));
+            }
+            catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
+        }
+    }
+    /** The shapes-relayout payload: region shapes (profile-line ROIs included, as
+     *  they are ordinary regions) plus the active-shape fill colour. */
+    shapesRelayout(shapeDicts) {
+        return {
+            shapes: shapeDicts,
+            activeshape: { fillcolor: this.regionStore.getFillColor() },
+        };
+    }
+    /** Push the current dict working-set to Plotly (no-op when another backend
+     *  owns the div). */
+    renderShapes() {
+        if (!this.plotDiv)
+            return;
+        const dictArray = this.shapes.map(s => ({ ...s }));
+        try {
+            Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray));
+        }
+        catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
+    }
+    getShowShapeLabel() {
+        return this.regionStore.getShowShapeLabel();
+    }
+    /**
+     * Set previous saved shapes
+     */
+    plotPreviousShapes() {
+        // convert to dict so that plotly recognises the shapes
+        const dictArray = this.previousShapes.map(s => ({ ...s }));
+        try {
+            Plotly.relayout(this.plotDiv, { shapes: dictArray });
+        }
+        catch { /* div owned by another backend (OSD) */ }
+    }
+    setPreviousShapes(shapes) {
+        this.previousShapes = shapes;
+    }
+    getPreviousShapes() {
+        return this.previousShapes;
+    }
+    // Undo (jit-ui#85): region history lives in the shared RegionStore, so the
+    // active backend's overlay re-renders off its regionUpdate$ on restore.
+    undo() { this.regionStore.undo(); }
+    redo() { this.regionStore.redo(); }
+    canUndo() { return this.regionStore.canUndo(); }
+    canRedo() { return this.regionStore.canRedo(); }
+    getCanUndo$() { return this.regionStore.getCanUndo$(); }
+    getCanRedo$() { return this.regionStore.getCanRedo$(); }
+    resetUndoHistory() { this.regionStore.resetUndoHistory(); }
+    // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────
+    enterStackMode(slices, initialZ, saveLayout) {
+        this.regionStore.enterStackMode(slices, initialZ, saveLayout);
+    }
+    exitStackMode() { this.regionStore.exitStackMode(); }
+    isStackMode() { return this.regionStore.isStackMode(); }
+    getStackSaveLayout() {
+        return this.regionStore.getStackSaveLayout();
+    }
+    setDisplaySlice(z) { this.regionStore.setDisplaySlice(z); }
+    getSliceRegions() { return this.regionStore.getSliceRegions(); }
+    getStackSaveSlices() { return this.regionStore.getStackSaveSlices(); }
+    getHeatmapLayout(xRange, yRange) {
+        return {
+            xaxis: {
+                constrain: 'range',
+                constraintoward: 'center',
+                side: 'top',
+                ticks: '',
+                range: xRange
+            },
+            yaxis: {
+                constrain: 'range',
+                constraintoward: 'center',
+                range: yRange,
+                ticks: '',
+                ticksuffix: '  ',
+                // set autorange to false so that plotly does not overwrite the range for the y axis
+                autorange: false,
+                scaleanchor: this.scaleratio ? 'x' : false
+            },
+            margin: { t: 30, b: 5, l: 55, r: 5 },
+            height: this.screenHeight,
+            sliders: [{
+                    pad: { t: 50 },
+                    currentvalue: {
+                        visible: true,
+                        prefix: 'Z-plane:',
+                        xanchor: 'right',
+                    },
+                    steps: this.getSteps()
+                }],
+            autosize: true,
+            shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),
+            activeshape: { fillcolor: this.regionStore.getFillColor() },
+            dragmode: this.dragMode ? this.dragMode : false,
+            newshape: { line: { color: this.regionStore.getShapeColor(), width: 3 } }
+        };
+    }
+    shapesToRedraw(showLabel) {
+        const shapesToRedraw = [];
+        for (const shape of this.shapes) {
+            if (JSON.stringify(shape.fileName) === JSON.stringify(this.fileName)) {
+                // Set label
+                if (showLabel) {
+                    shape.label = {
+                        text: `${shape.legend}`,
+                        texttemplate: `${shape.legend}`,
+                        textposition: 'top left',
+                        font: { color: `${shape.line.color}` }
+                    };
+                }
+                else {
+                    shape.label = {};
+                }
+                shapesToRedraw.push(shape);
+            }
+        }
+        // convert to dict so that plotly recognises the shapes
+        return shapesToRedraw.map(s => ({ ...s }));
+    }
+    /**
+     * Unused (will be used when surface plot is added)
+     * @param xRange
+     * @param yRange
+     * @param zRatio
+     * @private
+     */
+    getSurfaceLayout(xRange, yRange, zRatio) {
+        return {
+            margin: { t: 0, b: 0, l: 0, r: 0 },
+            scene: {
+                xaxis: {
+                    gridcolor: 'rgb(255, 255, 255)',
+                    zerolinecolor: 'rgb(255, 255, 255)',
+                    showbackground: true,
+                    backgroundcolor: 'rgb(230, 230,230)',
+                    // range: xRange
+                },
+                yaxis: {
+                    gridcolor: 'rgb(255, 255, 255)',
+                    zerolinecolor: 'rgb(255, 255, 255)',
+                    showbackground: true,
+                    backgroundcolor: 'rgb(230, 230, 230)',
+                    // autorange: 'reversed',
+                    // range: yRange,
+                    // scaleanchor: 'x'
+                },
+                zaxis: {
+                    gridcolor: 'rgb(255, 255, 255)',
+                    zerolinecolor: 'rgb(255, 255, 255)',
+                    showbackground: true,
+                    backgroundcolor: 'rgb(230, 230,230)'
+                },
+                aspectratio: { x: 1, y: 1, z: zRatio },
+                aspectmode: 'manual',
+                sliders: [{
+                        pad: { t: 50 },
+                        currentvalue: {
+                            visible: true,
+                            prefix: 'Z-plane:',
+                            xanchor: 'right',
+                        },
+                        steps: this.getSteps()
+                    }],
+            }
+        };
+    }
+    getSteps() {
+        const steps = [];
+        for (let i = 0; i < this.imageLength; i++) {
+            steps.push({
+                label: i + 1,
+                method: 'restyle',
+                args: ['visible', Array(this.imageLength).fill(false).fill(true, i, i + 1)],
+            });
+        }
+        return steps;
+    }
+    /**
+     * Fetch an image via Angular HttpClient so that auth interceptors (Bearer token)
+     * are applied, then decode it with image-js. This avoids raw browser fetch()
+     * calls that bypass the interceptor chain and fail behind an OAuth2 proxy.
+     */
+    async loadImage(url) {
+        const buffer = await firstValueFrom(this.http.get(url, { responseType: 'arraybuffer' }));
+        return Image.load(Buffer.from(buffer));
+    }
+    /**
+     * Get the currently displayed image as an image-js Image instance.
+     * Used by the processing pipeline to obtain the input image.
+     */
+    async getCurrentImage() {
+        if (!this.imageInfo || !this.imageInfo.urls || this.imageInfo.urls.length === 0) {
+            return null;
+        }
+        const zIdx = this.zIndex.value || 0;
+        const url = this.imageInfo.urls[zIdx] || this.imageInfo.urls[0];
+        return this.loadImage(url);
+    }
+    /**
+     * Get the currently displayed plot pixel data as a flat Uint8ClampedArray.
+     * This captures whatever is actually rendered — including zoomed regions.
+     * Returns { width, height, channels, data } or null if no plot is displayed.
+     */
+    getDisplayedPixelData() {
+        if (!this.plotDiv)
+            return null;
+        const gd = document.getElementById(this.plotDiv);
+        if (!gd?.data || gd.data.length === 0)
+            return null;
+        // Find the visible trace
+        const frameIdx = this.activeFrameIndex();
+        const trace = gd.data[frameIdx] || gd.data[0];
+        if (!trace || !trace.z)
+            return null;
+        const zData = trace.z;
+        const height = zData.length;
+        if (height === 0)
+            return null;
+        const width = zData[0].length;
+        if (trace.type === 'image') {
+            // RGB image: z[row][col] = [r, g, b] or [r, g, b, a]
+            const sample = zData[0][0];
+            const channels = Array.isArray(sample) ? sample.length : 3;
+            const data = new Uint8ClampedArray(width * height * channels);
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    const pixel = zData[y][x];
+                    const offset = (y * width + x) * channels;
+                    for (let c = 0; c < channels; c++) {
+                        data[offset + c] = pixel[c];
+                    }
+                }
+            }
+            return { width, height, channels, data };
+        }
+        else {
+            // Heatmap (grayscale): z[row][col] = scalar value
+            const data = new Uint8ClampedArray(width * height);
+            for (let y = 0; y < height; y++) {
+                for (let x = 0; x < width; x++) {
+                    data[y * width + x] = Math.round(zData[y][x]);
+                }
+            }
+            return { width, height, channels: 1, data };
+        }
+    }
+    /**
+     * Region of the original image that the displayed `z` grid covers, in
+     * full-image pixel coords. On a server zoom (`triggerZoom`) the trace `z` is
+     * replaced with the high-def crop and the axes are relaid out to the crop's
+     * original-image bounds (`imageSize`), so the live axis ranges ARE that
+     * rectangle; when the whole image is in view the ranges span `trueImgSize`.
+     * Reading the ranges therefore yields the crop origin + extent without
+     * tracking zoom state separately. Falls back to the full image, then `null`.
+     */
+    getDisplayedSourceRect() {
+        const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
+        const xr = gd?._fullLayout?.xaxis?.range;
+        const yr = gd?._fullLayout?.yaxis?.range;
+        if (xr && yr) {
+            const x0 = Math.min(xr[0], xr[1]);
+            const y0 = Math.min(yr[0], yr[1]); // y axis is reversed for image layouts
+            return { x: x0, y: y0, width: Math.abs(xr[1] - xr[0]), height: Math.abs(yr[1] - yr[0]) };
+        }
+        if (!this.trueImgSize)
+            return null;
+        return {
+            x: this.trueImgSize[0],
+            y: this.trueImgSize[2],
+            width: this.trueImgSize[1] - this.trueImgSize[0],
+            height: this.trueImgSize[3] - this.trueImgSize[2],
+        };
+    }
+    reset() {
+        if (this.plotDiv) {
+            Plotly.newPlot(this.plotDiv, [], this.getHeatmapLayout([0, 100], [100, 0]), CONFIG);
+        }
+    }
+    /**
+     * Fully remove Plotly's DOM from the plot div (axes included). Used when
+     * handing the div to another backend (OpenSeadragon) — unlike `reset()`,
+     * which re-renders an empty plot and would leave the Plotly axes showing.
+     */
+    purgePlot() {
+        if (this.plotDiv) {
+            Plotly.purge(this.plotDiv);
+        }
+    }
+    /** Export the heatmap as a PNG (the rendered plot already reflects the active
+     *  colormap/window). The full-res tile composite is OSD's job. */
+    exportComposite() {
+        this.downloadImage();
+    }
+    downloadImage() {
+        if (this.plotDiv) {
+            Plotly.downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });
+        }
+    }
+    resetAxes() {
+        this.zoomCoordinates = [];
+        this.relayout();
+    }
+    setDragMode(mode) {
+        this.dragMode = mode ? mode : '';
+        if (!this.plotDiv)
+            return;
+        // Only relayout a LIVE Plotly graph. When another backend (OSD / napari-js) owns the view the
+        // div id is still set but has no Plotly plot attached, and Plotly.relayout throws
+        // ("can't access property _guiEditing, n is undefined"). That throw aborted the caller
+        // (deactivateActiveTool → onSelectPlotType) before the re-plot ran, wedging the plot type
+        // (e.g. stuck switching napari volume ↔ isosurface). Guard on `_fullLayout` like the zoom
+        // helpers do so it safely no-ops when Plotly isn't the active renderer.
+        const gd = document.getElementById(this.plotDiv);
+        if (!gd?._fullLayout)
+            return;
+        Plotly.relayout(this.plotDiv, { dragmode: mode });
+    }
+    /** {@link IDataRenderer} stub — Plotly has no overview navigator (it's an
+     *  OpenSeadragon feature), so toggling it is a no-op here. */
+    setNavigatorVisible(_visible) {
+        /* no-op: navigator is OpenSeadragon-only */
+    }
+    /** {@link IDataRenderer} stub — image smoothing is an OpenSeadragon canvas-drawer
+     *  setting; the Plotly image/heatmap traces don't expose it, so it's a no-op. */
+    setImageSmoothingEnabled(_enabled) {
+        /* no-op: smoothing toggle is OpenSeadragon-only */
+    }
+    zoomIn() {
+        if (!this.plotDiv)
+            return;
+        const gd = document.getElementById(this.plotDiv);
+        if (!gd?._fullLayout)
+            return;
+        const xl = gd._fullLayout.xaxis;
+        const yl = gd._fullLayout.yaxis;
+        // 3D scenes have no 2D xaxis/yaxis (they live under `scene`); the step-zoom
+        // is meaningless there and would throw on `xl.range`. Plotly's scene handles
+        // scroll-zoom natively, so just bail.
+        if (!xl?.range || !yl?.range)
+            return;
+        const xc = (xl.range[0] + xl.range[1]) / 2;
+        const yc = (yl.range[0] + yl.range[1]) / 2;
+        const dx = (xl.range[1] - xl.range[0]) / 1.3;
+        const dy = (yl.range[1] - yl.range[0]) / 1.3;
+        const x0 = xc - dx / 2, x1 = xc + dx / 2;
+        const y0 = yc - dy / 2, y1 = yc + dy / 2;
+        this.zoomCoordinates = [x0, x1, y0, y1];
+        Plotly.relayout(this.plotDiv, {
+            'xaxis.range[0]': x0, 'xaxis.range[1]': x1,
+            'yaxis.range[0]': y0, 'yaxis.range[1]': y1
+        });
+    }
+    /**
+     * Delete every currently selected shape. Falls back to the single
+     * `_activeShapeIndex` when no multi-selection is active (covers the case
+     * where Plotly clicked a shape without going through the table).
+     */
+    deleteActiveShape() {
+        // Note: no `plotDiv` guard — when OpenSeadragon is the renderer, Plotly
+        // never plotted (plotDiv is unset), but deletion only needs the shape list
+        // + the current selection; the Plotly relayout below is guarded.
+        const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
+        // Resolve what to delete: the store's selection, else the shape Plotly
+        // tracks as clicked (when the user clicked a shape without going through the
+        // Region Editor table).
+        if (this.regionStore.getSelectedShapeIndices().length === 0) {
+            const activeIndex = gd?._fullLayout?._activeShapeIndex;
+            if (activeIndex === undefined || activeIndex < 0)
+                return;
+            this.regionStore.setSelectedShapeIndices([activeIndex]);
+        }
+        // The store removes the selected regions, clears the selection, syncs its
+        // cache and emits the region-update event.
+        this.regionStore.deleteActiveShape();
+        // Re-project the remaining regions and render on the Plotly plot (a no-op,
+        // caught, when another backend owns the div — its overlay re-renders via
+        // the store's update event).
+        if (gd?._fullLayout)
+            gd._fullLayout._activeShapeIndex = -1;
+        this.syncShapesFromStore();
+        const dictArray = this.shapes.map(s => ({ ...s }));
+        try {
+            Plotly.relayout(this.plotDiv, { shapes: dictArray }).then(() => {
+                if (gd?._fullLayout)
+                    Plotly.redraw(gd);
+            }, () => { });
+        }
+        catch { /* div owned by another backend */ }
+    }
+    zoomOut() {
+        if (!this.plotDiv)
+            return;
+        const gd = document.getElementById(this.plotDiv);
+        if (!gd?._fullLayout)
+            return;
+        const xl = gd._fullLayout.xaxis;
+        const yl = gd._fullLayout.yaxis;
+        // 3D scenes have no 2D xaxis/yaxis — see zoomIn().
+        if (!xl?.range || !yl?.range)
+            return;
+        const xc = (xl.range[0] + xl.range[1]) / 2;
+        const yc = (yl.range[0] + yl.range[1]) / 2;
+        const dx = (xl.range[1] - xl.range[0]) * 1.3;
+        const dy = (yl.range[1] - yl.range[0]) * 1.3;
+        const x0 = xc - dx / 2, x1 = xc + dx / 2;
+        const y0 = yc - dy / 2, y1 = yc + dy / 2;
+        this.zoomCoordinates = [x0, x1, y0, y1];
+        Plotly.relayout(this.plotDiv, {
+            'xaxis.range[0]': x0, 'xaxis.range[1]': x1,
+            'yaxis.range[0]': y0, 'yaxis.range[1]': y1
+        });
+    }
+    isStackLoading$() {
+        return this.stackLoading$.asObservable();
+    }
+    setStackLoading(stackLoading) {
+        this.stackLoading$.next(stackLoading);
+    }
+    getStackLoadingProgress$() {
+        return this.stackLoadingProgress$.asObservable();
+    }
+    // Colormap / reverse-scale / image metadata state lives in the shared
+    // VisualizerStore; these delegate, keeping only the Plotly-specific live
+    // restyle as render glue.
+    getColormapOptions() {
+        return this.store.getColormapOptions();
+    }
+    setColormap(colormap) {
+        this.store.setColormap(colormap);
+        try {
+            Plotly.restyle(this.plotDiv, { 'colorscale': [colormap.data.value] });
+        }
+        catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }
+    }
+    getColormap() {
+        return this.store.getColormap();
+    }
+    setReverseScale(reverscale) {
+        this.store.setReverseScale(reverscale);
+        try {
+            Plotly.restyle(this.plotDiv, { 'reversescale': reverscale });
+        }
+        catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }
+    }
+    getReverseScale() {
+        return this.store.getReverseScale();
+    }
+    setImageMeta(imageMeta) {
+        this.store.setImageMeta(imageMeta);
+    }
+    getImageMeta() {
+        return this.store.getImageMeta();
+    }
+    setShowStack(showstack) {
+        if (!showstack) {
+            this.zIndex.next(0);
+        }
+        this.imageInfo.showStack = showstack;
+        this.stackLoading$.next(showstack);
+        Plotly.relayout(this.plotDiv, { 'showstack': showstack });
+    }
+    getAutoscaleEvent() {
+        return this.autoscaleEvent.asObservable();
+    }
+    getRegionUpdateEvent() {
+        return this.regionStore.getRegionUpdateEvent();
+    }
+    /**
+     * Stream of the indices of currently selected regions — owned by the shared
+     * RegionStore so the selection is consistent across backends and the Region
+     * Editor table. Empty = nothing selected.
+     */
+    getSelectedShapeIndices$() {
+        return this.regionStore.getSelectedShapeIndices$();
+    }
+    /**
+     * Programmatically select regions (or clear with []). The shared store owns
+     * the selection state (validates/dedupes/emits); here we additionally point
+     * Plotly's `_activeShapeIndex` at the last selected shape so it gets the edit
+     * handles. No visual change to non-active shapes — Plotly's own active-shape
+     * rendering is the only highlight.
+     */
+    setSelectedShapeIndices(indices) {
+        const valid = (indices || [])
+            .filter(i => Number.isFinite(i) && i >= 0 && i < this.shapes.length);
+        const seen = new Set();
+        const cleaned = [];
+        for (const i of valid) {
+            if (!seen.has(i)) {
+                seen.add(i);
+                cleaned.push(i);
+            }
+        }
+        if (this.plotDiv) {
+            const gd = document.getElementById(this.plotDiv);
+            if (gd?._fullLayout) {
+                gd._fullLayout._activeShapeIndex = cleaned.length > 0 ? cleaned[cleaned.length - 1] : -1;
+                try {
+                    Plotly.redraw(gd);
+                }
+                catch { /* noop in tests */ }
+            }
+        }
+        this.regionStore.setSelectedShapeIndices(cleaned);
+    }
+    /**
+     * Select a specific region (IRegionStore.selectRegion). Sets the shared store
+     * selection by identity and points Plotly's active-shape at the matching
+     * rendered shape so its edit handles appear.
+     */
+    selectRegion(region) {
+        this.regionStore.selectRegion(region);
+        if (this.plotDiv) {
+            const idx = this.shapes.findIndex(s => s.id === region?.id);
+            const gd = document.getElementById(this.plotDiv);
+            if (gd?._fullLayout && idx >= 0) {
+                gd._fullLayout._activeShapeIndex = idx;
+                try {
+                    Plotly.redraw(gd);
+                }
+                catch { /* noop in tests */ }
+            }
+        }
+    }
+    /**
+     * Read Plotly's `_activeShapeIndex` and push it as the selection. Called from
+     * the relayout handler and the post-click tick — Plotly doesn't fire a
+     * dedicated active-shape event for clicks, so we sample. The store no-ops if
+     * the selection is unchanged.
+     */
+    maybeEmitActiveShapeIndex() {
+        if (!this.plotDiv)
+            return;
+        const gd = document.getElementById(this.plotDiv);
+        const raw = gd?._fullLayout?._activeShapeIndex;
+        const idx = (typeof raw === 'number' && raw >= 0 && raw < this.shapes.length) ? raw : -1;
+        this.regionStore.setSelectedShapeIndices(idx >= 0 ? [idx] : []);
+    }
+    setZIndex(zIndex) {
+        this.zIndex.next(zIndex);
+    }
+    getShapeColor() {
+        return this.regionStore.getShapeColor();
+    }
+    getFillColor() {
+        return this.regionStore.getFillColor();
+    }
+    getClassificationColors() {
+        return this.store.getClassificationColors();
+    }
+    setClassificationColor(label, color) {
+        this.store.setClassificationColor(label, color);
+    }
+    /**
+     * Unsubscribe Subscriptions
+     */
+    unsubscribe() {
+        if (this.imageCachedSubscription) {
+            this.imageCachedSubscription.unsubscribe();
+        }
+        if (this.filenameSubscription) {
+            this.filenameSubscription.unsubscribe();
+        }
+        if (this.regionUpdateSubscription) {
+            this.regionUpdateSubscription.unsubscribe();
+        }
+        if (this.regionLiveEditSubscription) {
+            this.regionLiveEditSubscription.unsubscribe();
+        }
+        if (this.channelSub) {
+            this.channelSub.unsubscribe();
+        }
+    }
+    /** Live-apply the channel display window (zmin/zmax) + reverse/invert to the
+     *  heatmap. No-op when no Plotly plot is mounted (OSD owns the div). */
+    applyChannelDisplay(channels, rev, inv) {
+        if (!this.plotDiv)
+            return;
+        const ch = channels?.[0];
+        const colorscale = this.store.currentColormap()?.data?.value;
+        // reverse-scale and invert each flip the ramp; both together cancel.
+        const update = { reversescale: rev !== inv };
+        if (colorscale != null)
+            update.colorscale = colorscale; // live colormap recolor
+        if (ch) {
+            // Surface/isosurface/scatter3d colour-map via cmin/cmax; heatmap/contour via zmin/zmax.
+            const threeD = this.plotType === PlotType.ISOSURFACE ||
+                this.plotType === PlotType.SURFACE ||
+                this.plotType === PlotType.SCATTER3D;
+            if (threeD) {
+                update.cmin = ch.min;
+                update.cmax = ch.max;
+                update.cauto = false;
+            }
+            else {
+                update.zmin = ch.min;
+                update.zmax = ch.max;
+                update.zauto = false;
+            }
+        }
+        try {
+            Plotly.restyle(this.plotDiv, update);
+        }
+        catch {
+            /* not a colour-mapped trace, or OSD owns the div */
+        }
+    }
+    /** Binned intensity histogram for a channel from the cached source frames
+     *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]. */
+    getHistogram(channelIndex, _bins) {
+        const frames = this.cachedImageFrames;
+        if (!frames?.length)
+            return null;
+        const frame = frames[this.activeFrameIndex()] ?? frames[0];
+        if (!frame?.length)
+            return null;
+        const counts = new Array(256).fill(0);
+        for (const row of frame) {
+            if (!row)
+                continue;
+            for (const cell of row) {
+                let v;
+                if (Array.isArray(cell)) {
+                    v = channelIndex >= 0 && channelIndex < cell.length
+                        ? cell[channelIndex]
+                        : Math.round(bt601Luminance(cell[0], cell[1], cell[2]));
+                }
+                else {
+                    v = cell;
+                }
+                v = v | 0;
+                if (v < 0)
+                    v = 0;
+                else if (v > 255)
+                    v = 255;
+                counts[v]++;
+            }
+        }
+        return histogram256(counts);
+    }
+    /** Async histogram stream — Plotly renders heatmap frame data (already in
+     *  memory, 8-bit luminance), so this just wraps the synchronous 8-bit
+     *  histogram. Native 16-bit histograms only apply to the OSD tile path. */
+    getHistogram$(channelIndex, bins) {
+        return of(this.getHistogram(channelIndex, bins));
+    }
+    /** Data export (16-bit TIFF) is an OSD-tile-path feature backed by the server.
+     *  Plotly renders heatmaps from frame data, so there's nothing to export here. */
+    exportData() {
+        console.warn('[plotly] 16-bit data export is not available for the heatmap backend.');
+    }
+    importRegions(geoJsonStr) {
+        return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);
+    }
+    exportRegions(regions) {
+        const jsonString = this.plotUtilities.exportROIsToGeoJson(regions);
+        this.plotUtilities.saveToFile(jsonString, this.fileName);
+    }
+    getGeoJsonString(regions) {
+        return this.plotUtilities.exportROIsToGeoJson(regions);
+    }
+    getStackLoadingProgress() {
+        return this.getStackLoadingProgress$();
+    }
+    isStackLoading() {
+        return this.isStackLoading$();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, deps: [{ token: TILE_ACCESS_PORT }, { token: IMAGE_STATE_PORT }, { token: i1.MessageService }, { token: i2.HttpClient }, { token: i3.WandService }, { token: i4.WandToolService }, { token: i5.BrushToolService }, { token: i6.SamToolService }, { token: i7.SamPointToolService }, { token: i8.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i9.VertexEraserToolService }, { token: i10.ZoomToBoxToolService }, { token: i11.VisualizerStore }, { token: i12.RegionStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TILE_ACCESS_PORT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [IMAGE_STATE_PORT]
+                }] }, { type: i1.MessageService }, { type: i2.HttpClient }, { type: i3.WandService }, { type: i4.WandToolService }, { type: i5.BrushToolService }, { type: i6.SamToolService }, { type: i7.SamPointToolService }, { type: i8.CellSegmentToolService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CELL_SEGMENTER]
+                }] }, { type: i9.VertexEraserToolService }, { type: i10.ZoomToBoxToolService }, { type: i11.VisualizerStore }, { type: i12.RegionStore }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, Optional } from '@angular/core';\n\nimport * as Plotly from 'plotly.js-dist-min';\nimport { Image } from 'image-js';\nimport { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\n\nimport { Polygon, Rectangle, Region } from '../../models/region';\nimport { Buffer } from 'buffer';\nimport { IImageInfo, IImageMetadata } from '../../contracts/image.contract';\nimport { TileAccessPort, TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';\nimport { ImageStatePort, IMAGE_STATE_PORT } from '../../contracts/ports/image-state.port';\nimport { BehaviorSubject, EMPTY, Observable, Subject, Subscription, combineLatest, of } from 'rxjs';\nimport { MessageService } from 'primeng/api';\nimport { ShapeSelection } from '../../models/shape';\nimport { CONFIG, CONFIG_SURFACE, PlotUtilities } from '../../plot.utilities';\nimport { WandService, WandOptions } from '../../toolbar/wand/wand.service';\nimport { CachedImageData, WandToolService, WandToolHost } from '../../toolbar/wand/wand-tool.service';\nimport { BrushToolService, BrushOptions } from '../../toolbar/brush/brush-tool.service';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { ICellSegmenter, CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';\nimport { VertexEraserToolService, VertexEraserToolHost } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';\nimport { ZoomToBoxToolService } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';\nimport {\n  parseSvgPathPolygon,\n  verticesToSvgPath,\n} from '../../models/geometry';\nimport { PlotType, PLOT_TYPE_DESCRIPTORS, PlotTypeDescriptor } from '../../contracts/plot-type';\nimport {\n  PLOTLY_PLOT_TYPE_IMPLS,\n  PlotlyPlotTypeImpl,\n  TraceBuildInput,\n} from './plotly-trace-builders';\nimport { IVisualizer, IntensityProfile, IIsosurfaceControls, IIntensityControls } from '../../contracts/visualizer.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { bt601Luminance, histogram256 } from '../../contracts/intensity';\nimport { ViewerCapabilities, ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';\nimport { IRegionOverlay } from '../../contracts/region-overlay.contract';\nimport { PlotlyRegionOverlay } from './plotly-region-overlay';\nimport { ICoordinateTransform } from '../../contracts/coordinate-transform.contract';\nimport { PlotlyCoordinateTransform } from './plotly-coordinate-transform';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\n\n// Re-exported so existing consumers can keep importing PlotType from this\n// module while it physically lives in the backend-neutral contracts/ dir.\n// TODO(plotting-abstraction): once all consumers import from\n// './contracts/plot-type' directly, drop this re-export.\nexport { PlotType } from '../../contracts/plot-type';\n\n\n(window as any).Buffer = Buffer;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PlotlyService implements IVisualizer {\n\n  /**\n   * Plotly is the full-featured data backend: it supports every feature,\n   * including 3D scenes, live scalar colormaps, pixel readback and the\n   * server-side high-def zoom re-fetch. (OpenSeadragon's stub advertises only\n   * image display.)\n   */\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([\n    ViewerFeature.ImageDisplay,\n    ViewerFeature.Surface3D,\n    ViewerFeature.ScalarColormap,\n    ViewerFeature.PixelReadback,\n    ViewerFeature.HighDefZoom,\n    ViewerFeature.StackSlider,\n    ViewerFeature.Isosurface,\n  ]);\n\n  private shapes: any[] = [];\n  private previousShapes: ShapeSelection[] = [];\n  private isRegionSavedOn = true;\n  private imageLength!: number;\n  private screenHeight!: number;\n  private plotDiv!: string;\n  private isRealZoom = true;\n  private scaleratio = true;\n  private trueImgSize!: number[];\n  private zoomCoordinates: number[] = [];\n  private fileName!: string | undefined;\n\n  private dragMode!: string;\n  // Region data (the list + per-image cache), selection, id minting, the region\n  // update event and the shape colour/label prefs now live in the shared\n  // RegionStore (injected as `this.regionStore`) — the single source of truth\n  // both backends delegate to. `this.shapes` below is kept as Plotly's *render\n  // projection* of those regions (the dict array Plotly.relayout consumes) and\n  // is mirrored into the store on every write. Colormap, reverse-scale, image\n  // metadata and classification colours live in the shared VisualizerStore\n  // (injected as `this.store`).\n  private urls!: string[];\n  imageInfo!: IImageInfo;\n  private plotUtilities = new PlotUtilities();\n  private plotType!: PlotType;\n\n  private onPlotMouseDown: (() => void) | null = null;\n\n  // The per-image region cache (regionsByImageKey/currentImageKey) now lives in\n  // the shared RegionStore; setActiveImage() delegates to it and re-projects\n  // `this.shapes` from the store afterwards.\n\n  /** Pixel data cached for wand sampling. data[zIndex] is a 2-D matrix. */\n  private cachedImageFrames?: any[];\n  private cachedImageWidth = 0;\n  private cachedImageHeight = 0;\n  private cachedImageRatios: number[] = [1, 1];\n  private cachedIsGrayscale = false;\n  /** Data-space coordinate of the cached frame's pixel (0,0). [0,0] for the full\n   *  image; a crop's top-left when zoomed (so the intensity profile samples the\n   *  zoom-level pixels at the right offset/resolution). */\n  private cachedFrameOrigin: [number, number] = [0, 0];\n  /** Last visible image-pixel rectangle from the active backend's viewport (set by\n   *  the OSD viewport-change hook via refreshIntensitySamplingForRoi). New profile lines are\n   *  placed within it so they land on-screen when zoomed in; null → use full image. */\n  private lastVisibleRoi: { x: number; y: number; width: number; height: number } | null = null;\n\n  /** events */\n  private onRelayoutEvent: any;\n\n  private stackLoading$ = new BehaviorSubject<boolean>(false);\n  private stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  // current index of image in stack (if stack), 0 if single image\n  private zIndex = new BehaviorSubject<number>(0);\n  private autoscaleEvent = new Subject<any>();\n  // The region update event and selection stream are owned by the shared\n  // RegionStore; getRegionUpdateEvent()/getSelectedShapeIndices$() delegate to\n  // it so every consumer (and the OSD backend) sees one stream.\n  /** Bright, well-separated colours cycled as the user adds profile-line ROIs.\n   *  The matching inset trace is drawn in the same colour. */\n  private readonly PROFILE_PALETTE = [\n    '#FFD400', // yellow\n    '#00E5FF', // cyan\n    '#FF2D95', // magenta\n    '#39FF14', // green\n    '#FF9500', // orange\n    '#7C4DFF', // violet\n    '#FF3B30', // red\n    '#18FFFF', // aqua\n  ];\n  /** Palette cursor for profile lines (never reset on delete, so colours keep\n   *  cycling across the session). */\n  private profileColorSeq = 0;\n  private intensityProfile$ = new Subject<IntensityProfile[]>();\n  /** ISOSURFACE band as a 0–255 slider position, mapped onto the volume's real\n   *  intensity range at render time (see mapIsoBand). Defaults to the full range\n   *  so the first render shows the whole structure regardless of how bright or\n   *  dark the volume is; the user then narrows the band to isolate intensities. */\n  private isoMin = 0;\n  private isoMax = 255;\n  /** Actual intensity range of the volume on screen ([min,max] over the loaded\n   *  frames). The slider spans 0–255, but a given stack often occupies only a\n   *  sub-range, so we clamp the iso band into this range (with a small margin)\n   *  to guarantee non-degenerate surfaces — both on first render and on live\n   *  slider moves. Null until an isosurface volume has been measured. */\n  private isoDataRange: [number, number] | null = null;\n  // Id minting and the selection index stream are owned by the shared\n  // RegionStore. Selection still drives Plotly's `_activeShapeIndex` (so a\n  // single shape gets the edit handles) — see setSelectedShapeIndices().\n  private imageCached = false;\n  private imageCachedSubscription: Subscription;\n  private filenameSubscription: Subscription;\n  /** Drives the intensity inset off region adds/drags/deletes (both backends). */\n  private regionUpdateSubscription?: Subscription;\n  /** Live (per-frame, non-coalesced) region edits — so the inset tracks an OSD\n   *  line ROI live during a drag (OSD batches regionUpdate$ until release). */\n  private regionLiveEditSubscription?: Subscription;\n  private channelSub?: Subscription;\n\n  private wandHost!: WandToolHost;\n  private eraserHost!: VertexEraserToolHost;\n  /** This backend's region renderer (lazily created in getRegionOverlay). */\n  private regionOverlay?: IRegionOverlay;\n  private readonly coordinateTransform: ICoordinateTransform =\n    new PlotlyCoordinateTransform(\n      () => document.getElementById(this.plotDiv),\n      () => this.getOverlayContainer());\n\n  constructor(@Inject(TILE_ACCESS_PORT) private tiles: TileAccessPort,\n              @Inject(IMAGE_STATE_PORT) private state: ImageStatePort,\n              public messageService: MessageService, private http: HttpClient,\n              private wandService: WandService,\n              private wandTool: WandToolService,\n              private brushTool: BrushToolService,\n              private samTool: SamToolService,\n              private samPointTool: SamPointToolService,\n              private cellSegmentTool: CellSegmentToolService,\n              @Optional() @Inject(CELL_SEGMENTER) private cellSegmenter: ICellSegmenter | null,\n              private vertexEraserTool: VertexEraserToolService,\n              private zoomToBoxTool: ZoomToBoxToolService,\n              private store: VisualizerStore,\n              private regionStore: RegionStore) {\n    // relayout event router\n    this.onRelayoutEvent = (event: any) => { this.relayoutEventHandler(event); };\n\n    // Tool services read/mutate our state via small *Host interfaces. Stored\n    // so we can re-bind them to ourselves whenever a Plotly tool is activated\n    // (the OpenSeadragon backend re-binds the same singleton tools to itself).\n    this.wandHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.setRegions(regions),\n      getCachedImageData: () => this.getCachedImageData(),\n      getActiveFrameIndex: () => this.activeFrameIndex(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.getCoordinateTransform(),\n      getFileName: () => this.fileName,\n      getShapeColor: () => this.regionStore.getShapeColor(),\n    };\n    this.eraserHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.setRegions(regions),\n      invalidateWandRegion: () => this.wandTool.clearActiveRegion(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.getCoordinateTransform(),\n      getCachedImageRatio: () => this.cachedImageRatios[0] || 1,\n    };\n    this.wandTool.bindHost(this.wandHost);\n    // The brush reuses the wand host (same coordinate frame + region access).\n    this.brushTool.bindHost(this.wandHost);\n    this.vertexEraserTool.bindHost(this.eraserHost);\n    this.bindZoomToBoxHost();\n\n    this.imageCachedSubscription = this.state.isImageCached$().subscribe(imageCached => {\n      this.imageCached = imageCached;\n    });\n    this.filenameSubscription = this.state.getFilename$().subscribe(filename => {\n      this.fileName = filename;\n    });\n    // Live recolor from the Channels & Histogram pane: restyle the display window (zmin/zmax for\n    // a heatmap, cmin/cmax for isosurface/surface), the colorscale (colormap), and reverse/invert\n    // when the channel state OR the colormap changes. (Gamma is applied by the OSD image view; the\n    // Plotly colorscale window covers the common contrast case.)\n    this.channelSub = combineLatest([\n      this.store.getChannelStates(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getColormap(),\n    ]).subscribe(([channels, rev, inv]) => this.applyChannelDisplay(channels, rev, inv));\n    // Profile lines are store regions; any region change (add/drag/delete, on\n    // either backend) should refresh the inset traces. The live-edit stream\n    // fires per frame during a drag (OSD coalesces regionUpdate$ until release),\n    // so the inset tracks an OSD line ROI live as it's moved.\n    this.regionUpdateSubscription = this.regionStore.getRegionUpdateEvent().subscribe(() => {\n      this.emitProfiles();\n    });\n    this.regionLiveEditSubscription = this.regionStore.getRegionLiveEdit$().subscribe(() => {\n      this.emitProfiles();\n    });\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n     if (!this.trueImgSize) return null;\n     return {\n       width: this.trueImgSize[1] - this.trueImgSize[0],\n       height: this.trueImgSize[3] - this.trueImgSize[2],\n     };\n  }\n\n  /**\n   * Load image\n   * @param imageInfo\n   * @param zIndex index of the image to load\n   * @return an object with data and ratio keys\n   */\n  public async load(imageInfo: IImageInfo, zIndex: number) {\n    const urls = imageInfo.urls;\n    // use zIndex provided if any, 0 otherwise\n    let imageUrl;\n    if (zIndex) {\n      imageUrl = urls[zIndex];\n    } else {\n      imageUrl = urls[0];\n    }\n    const isGrayscale = imageInfo.isGrayscale;\n    const image = await this.loadImage(imageUrl);\n    const xRatio = imageInfo.trueImageSize[0] / image.width;\n    const yRatio = imageInfo.trueImageSize[1] / image.height;\n\n    const trueImageSize = [];\n    // [x0, x1, y0, y1]\n    trueImageSize[0] = 0;\n    trueImageSize[1] = imageInfo.trueImageSize[0];\n    trueImageSize[2] = 0;\n    trueImageSize[3] = imageInfo.trueImageSize[1];\n    this.trueImgSize = trueImageSize;\n    this.fileName = imageInfo.fileName;\n    if (imageInfo.isStack && imageInfo.showStack) {\n      const images: any[] = [];\n      this.stackLoadingProgress$.next(0);\n      // One URL per slice — load them all (earlier `length-1` dropped the last).\n      for (let i = 0; i < urls.length; i++) {\n        console.log(`image stack ${i}`);\n        // do not keep with loading if filename is different (a new file has been selected)\n        // or if the stackLoading value is set to false\n        if (this.fileName === imageInfo.fileName && this.stackLoading$.value) {\n          const image = await this.loadImage(urls[i]);\n          if (isGrayscale) {\n            const grey = image.grey();\n            const imgData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);\n            images.push(imgData);\n          } else {\n            const rgbData = image.getPixelsArray();\n            const rgbMatrix = this.plotUtilities.arrayToMatrix(rgbData, image.width);\n            images.push(rgbMatrix);\n          }\n          this.stackLoadingProgress$.next(Math.round((i * 100) / urls.length));\n        } else {\n          // break stack loading\n          break;\n        }\n      }\n      // reset stackLoading progress to 0\n      this.stackLoadingProgress$.next(0);\n      return { data: images, ratios: [xRatio, yRatio],\n               sizes: [image.width, image.height],\n               filename: imageInfo.fileName };\n    } else {\n      let imageData;\n      if (isGrayscale) {\n        const grey = image.grey();\n        imageData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);\n      } else {\n        const rgbData = image.getPixelsArray();\n        imageData = this.plotUtilities.arrayToMatrix(rgbData, image.width);\n      }\n      return { data: [imageData],\n        ratios: [xRatio, yRatio],\n        sizes: [image.width, image.height],\n        filename: imageInfo.fileName };\n    }\n  }\n\n  /**\n   *\n   * @param plotDiv\n   * @param imageLoaded object with data, ratios and sizes key\n   * @param imageInfo ImageInfo object\n   * @param screenHeight size of the available screen height\n   * @param plotType type of plotting\n   */\n  /**\n   * @param inPlace when true, updates the existing plot via Plotly.react\n   *   instead of Plotly.purge + Plotly.newPlot. Used by the multi-tier\n   *   diagram swap (small → large) so the canvas doesn't briefly blank\n   *   between phases.\n   */\n  public plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number,\n              plotType: PlotType, inPlace: boolean = false) {\n    const trueImageSize: number[] = [];\n    this.zoomCoordinates = [];\n    // [x0, x1, y0, y1]\n    trueImageSize[0] = 0;\n    trueImageSize[1] = imageInfo.trueImageSize[0];\n    trueImageSize[2] = 0;\n    trueImageSize[3] = imageInfo.trueImageSize[1];\n    // Save the current image's regions and pull in any cached regions for the\n    // image we're about to display, before Plotly.newPlot reads `this.shapes`.\n    this.setActiveImage(imageInfo);\n    this.imageInfo = imageInfo;\n    this.plotType = plotType;\n    // Cache pixel matrices so the wand tool can sample them.\n    this.cachedImageFrames = imageLoaded.data;\n    this.cachedImageWidth = imageLoaded.sizes[0];\n    this.cachedImageHeight = imageLoaded.sizes[1];\n    this.cachedImageRatios = imageLoaded.ratios;\n    this.cachedFrameOrigin = [0, 0]; // full image — reset any prior zoom-crop origin\n    this.cachedIsGrayscale = !!imageInfo.isGrayscale;\n\n    // Pluggable plot types (contour, scatter, scatter3d, isosurface) render\n    // through the trace-builder registry. The original HEATMAP/SURFACE/RGB-image\n    // renderers keep their dedicated paths below (also reused by the high-def\n    // zoom re-fetch). Intensity profiles are no longer a plot type — they're\n    // Region-based line ROIs, available in HEATMAP/IMAGE mode.\n    const impl = PLOTLY_PLOT_TYPE_IMPLS[plotType];\n    if (impl) {\n      this.imageInfo.isGrayscale = !!imageInfo.isGrayscale;\n      return this.plotViaRegistry(\n        plotDiv, impl, this.buildTraceInput(imageInfo, imageLoaded, trueImageSize),\n        screenHeight, inPlace);\n    }\n\n    if (imageInfo.isGrayscale) {\n      if (plotType === PlotType.SURFACE) {\n        return this.plotSurface(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n          imageLoaded.ratios, screenHeight, inPlace);\n      }\n      return this.plotHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n        imageLoaded.ratios, screenHeight, inPlace);\n    }\n    return this.plotRGBHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n      imageLoaded.ratios, imageLoaded.sizes[0], imageLoaded.sizes[1], screenHeight, inPlace);\n  }\n\n  /**\n   * Function used to plot a grayscale heatmap\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize array containing the following : [x0, x1, y0, y1]\n   * @param ratios\n   * @param screenHeight\n   * @return Promise true when plotting is finished\n   */\n  private plotHeatmap(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                     ratios: number[], screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n    // plot\n    const traces: { z: any; type: string; name: string; visible: boolean; }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        x0: trueImgSize[0],\n        dx: ratios[0],\n        y0: trueImgSize[2],\n        dy: ratios[0],\n        z: dataset,\n        type: 'heatmap',\n        // We remove the tooltip annotation for performances reasons\n        // text: dataset.map((row: any[], i: any) => row.map((item, j) => {\n        //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),\n        hoverinfo: 'none',\n        colorscale: this.store.currentColormap().data.value,\n        reversescale: this.store.currentReverseScale(),\n        name: `Slice ${index + 1}`,\n        visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any,\n      this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3],\n        trueImgSize[2]]), CONFIG as any).then(() => {\n      // handle the relayout event for zoom / rois and the click event\n      this.setEvents(plotDiv, true, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Function used to plot a grayscale surface\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize array containing the following : [x0, x1, y0, y1]\n   * @param ratios\n   * @param screenHeight\n   * @return Promise true when plotting is finished\n   */\n  private plotSurface(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                      ratios: number[], screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n    // plot\n    const traces: { z: any; type: string;  }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        z: dataset,\n        type: 'surface',\n        // hoverinfo: 'none',\n        colorscale: this.store.currentColormap().data.value,\n        reversescale: this.store.currentReverseScale(),\n        // name: `Slice ${index + 1}`,\n        // visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const xrange = [trueImgSize[0], trueImgSize[1]];\n    const yrange = [trueImgSize[2], trueImgSize[3]];\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any,\n      this.getSurfaceLayout(xrange, yrange, 0.4), CONFIG_SURFACE as any).then(() => {\n      // handle the relayout event for zoom / rois and the click event\n      this.setEvents(plotDiv, true, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Function used to plot an RGB heatmap\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize\n   * @param width\n   * @param height\n   * @param ratios\n   * @param screenHeight\n   * @return Promise\n   */\n  private plotRGBHeatmap(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                         ratios: number[], width: number, height: number,\n                         screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    // Plotly.react updates in place; Plotly.purge + Plotly.newPlot blanks\n    // the canvas for ~100ms which makes the multi-tier small→large swap\n    // look like a regression to \"loading\" before the sharper version\n    // appears.\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n\n    // as autorange is set to false, and not reversed we need to set the yrange correcly here\n    const layout = this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]],\n      [trueImgSize[3], trueImgSize[2]]);\n    const traces: { z: any; type: string; name: string; visible: boolean; }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        x0: trueImgSize[0],\n        dx: ratios[0],\n        y0: trueImgSize[2],\n        dy: ratios[0],\n        x: Array.from(Array(width).keys()),\n        y: Array.from(Array(height).keys()),\n        z: dataset,\n        // text: dataset.map((row: any[], i: any) => row.map((item, j) => {\n        //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),\n        hoverinfo: 'none',\n        type: 'image',\n        name: `Slice ${index + 1}`,\n        visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any, layout, CONFIG as any).then(() => {\n      // handle the relayout event\n      this.setEvents(plotDiv, false, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Assemble the normalised input the pluggable trace builders consume.\n   * Pure data only — no Plotly handles — so the builders stay backend-neutral.\n   */\n  private buildTraceInput(imageInfo: IImageInfo, imageLoaded: any,\n                          trueImageSize: number[]): TraceBuildInput {\n    // Measure the volume's real intensity range so the iso band can be clamped\n    // into it (the slider is a fixed 0–255 but a stack may occupy only part of\n    // that, which would otherwise leave the surfaces with nothing to cross).\n    if (this.plotType === PlotType.ISOSURFACE) {\n      this.isoDataRange = this.measureIntensityRange(imageLoaded.data, !!imageInfo.isGrayscale);\n    }\n    const [isoMin, isoMax] = this.mapIsoBand(this.isoMin, this.isoMax);\n    return {\n      frames: imageLoaded.data,\n      width: imageLoaded.sizes[0],\n      height: imageLoaded.sizes[1],\n      ratios: imageLoaded.ratios,\n      trueImageSize,\n      isGrayscale: !!imageInfo.isGrayscale,\n      colorscale: this.store.currentColormap().data.value,\n      reversescale: this.store.currentReverseScale(),\n      regions: this.getRegionPolygons(),\n      shapeColor: this.regionStore.getShapeColor(),\n      isoMin,\n      isoMax,\n    };\n  }\n\n  /** Min/max intensity over every voxel of the loaded frames (RGB → luminance),\n   *  used to keep the iso band inside the data. Returns null for empty input. */\n  private measureIntensityRange(frames: any[], isGrayscale: boolean): [number, number] | null {\n    let min = Infinity, max = -Infinity;\n    for (const frame of frames || []) {\n      for (const row of frame || []) {\n        for (const cell of row || []) {\n          const v = isGrayscale ? cell\n            : 0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2];\n          if (!Number.isFinite(v)) continue;\n          if (v < min) min = v;\n          if (v > max) max = v;\n        }\n      }\n    }\n    return (Number.isFinite(min) && Number.isFinite(max) && max > min) ? [min, max] : null;\n  }\n\n  /** Map the 0–255 slider band onto the volume's actual intensity range. The\n   *  slider is fixed 0–255, but a stack often occupies only a narrow sub-range\n   *  (e.g. this EDOF volume is ~2–50 with structure near 6–10). Mapping spreads\n   *  the data across the whole slider so every intensity is easy to reach and\n   *  the band always lands inside the data — a small inset keeps the extreme\n   *  surfaces off the exact data edges, which are degenerate and draw nothing. */\n  private mapIsoBand(isoMin: number, isoMax: number): [number, number] {\n    let lo = Math.min(isoMin, isoMax);\n    let hi = Math.max(isoMin, isoMax);\n    if (this.isoDataRange) {\n      const [vMin, vMax] = this.isoDataRange;\n      const span = vMax - vMin;\n      const pad = 0.03 * span;\n      const usable = span - 2 * pad;\n      const SLIDER_MAX = 255; // toolbar slider domain (isoValueMax)\n      lo = vMin + pad + (lo / SLIDER_MAX) * usable;\n      hi = vMin + pad + (hi / SLIDER_MAX) * usable;\n      if (lo > hi) { const t = lo; lo = hi; hi = t; }\n    }\n    return [lo, hi];\n  }\n\n  /**\n   * Update the isosurface intensity bounds. When isosurface is on screen this\n   * restyles `isomin`/`isomax` in place for a live update (no volume rebuild).\n   * Slider values are mapped onto the volume's real range so the surfaces always\n   * have data to cross (matching the initial render).\n   */\n  public setIsoRange(isoMin: number, isoMax: number): void {\n    this.isoMin = isoMin;\n    this.isoMax = isoMax;\n    if (this.plotType === PlotType.ISOSURFACE && this.plotDiv) {\n      const [lo, hi] = this.mapIsoBand(isoMin, isoMax);\n      try {\n        Plotly.restyle(this.plotDiv, { isomin: [lo], isomax: [hi] } as any);\n      } catch { /* plot not ready */ }\n    }\n  }\n\n  /** Plotly renders isosurfaces, so it exposes the isosurface controls (itself). */\n  public getIsosurfaceControls(): IIsosurfaceControls | null { return this; }\n\n  /**\n   * Render a registry-backed plot type: build its traces from the input, pick\n   * the matching layout, render, and wire the usual relayout/click events.\n   * Mirrors the structure of the dedicated heatmap/surface renderers.\n   */\n  private plotViaRegistry(plotDiv: string, impl: PlotlyPlotTypeImpl, input: TraceBuildInput,\n                          screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = input.frames.length;\n    this.urls = this.imageInfo?.urls ?? this.urls;\n    this.screenHeight = screenHeight;\n\n    const traces = impl.buildTraces(input);\n    const [x0, x1, y0, y1] = input.trueImageSize;\n    let layout: any;\n    switch (impl.layoutKind) {\n      case '3d-volume':\n        layout = this.getVolumeLayout();\n        break;\n      case '2d-chart':\n        layout = this.getChartLayout();\n        break;\n      case '2d-overlay':\n        layout = this.getOverlayLayout([x0, x1], [y1, y0]); // reversed y like the image\n        break;\n      default: // '2d-image'\n        layout = this.getHeatmapLayout([x0, x1], [y1, y0]);\n    }\n    const config = impl.threeD ? CONFIG_SURFACE : CONFIG;\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any, layout, config as any).then(() => {\n      this.setEvents(plotDiv, input.isGrayscale, screenHeight);\n      return true;\n    });\n  }\n\n  /** Plain 2D chart axes (intensity profile / line plots). */\n  private getChartLayout(): any {\n    return {\n      margin: { t: 30, b: 45, l: 60, r: 20 },\n      height: this.screenHeight,\n      autosize: true,\n      xaxis: { title: 'Position (px)' },\n      yaxis: { title: 'Intensity' },\n      dragmode: false,\n    };\n  }\n\n  /** Image-aligned 2D axes without the z-plane slider (region scatter). */\n  private getOverlayLayout(xRange: number[], yRange: number[]): any {\n    return {\n      xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },\n      yaxis: {\n        constrain: 'range', constraintoward: 'center', range: yRange, ticks: '',\n        ticksuffix: '  ', autorange: false, scaleanchor: this.scaleratio ? 'x' : false,\n      },\n      margin: { t: 30, b: 5, l: 55, r: 5 },\n      height: this.screenHeight,\n      autosize: true,\n      shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),\n      dragmode: this.dragMode ? this.dragMode : false,\n    };\n  }\n\n  /** 3D scene for volumetric plot types (scatter3d, isosurface). */\n  private getVolumeLayout(): any {\n    return {\n      margin: { t: 0, b: 0, l: 0, r: 0 },\n      height: this.screenHeight,\n      autosize: true,\n      scene: {\n        xaxis: { title: 'X' },\n        yaxis: { title: 'Y' },\n        zaxis: { title: 'Z-plane' },\n        // 'cube' (not 'data'): a z-stack has far fewer planes than X/Y pixels,\n        // so 'data' squashes the volume into a near-flat slab that reads as\n        // empty edge-on. A cube gives the z dimension real height so the\n        // isosurface/voxels are actually visible.\n        aspectmode: 'cube',\n      },\n    };\n  }\n\n  /** Plot types this backend advertises (drives the UI selector). */\n  public getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    return Object.values(PLOT_TYPE_DESCRIPTORS).filter((d): d is PlotTypeDescriptor => !!d);\n  }\n\n  /** This backend's region renderer. Plotly draws shapes natively, so the\n   *  overlay is a thin adapter over this service's drag modes. */\n  public getRegionOverlay(): IRegionOverlay {\n    if (!this.regionOverlay) this.regionOverlay = new PlotlyRegionOverlay(this);\n    return this.regionOverlay;\n  }\n\n  // ── Intensity profile (Region-based line ROIs) ──────────────────────\n\n  /** Emits the full set of intensity profiles (one per profile-line region)\n   *  whenever a profile line is added, moved, or removed. */\n  public getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensityProfile$.asObservable();\n  }\n\n  /** Plotly renders the line ROIs + inset, so it exposes the intensity controls. */\n  public getIntensityControls(): IIntensityControls | null { return this; }\n\n  /**\n   * Render the floating intensity-profile inset chart into `divId` — one line\n   * trace per ROI, each drawn in its ROI's colour. Kept here (not in the diagram\n   * component) so the consumer never touches Plotly directly.\n   */\n  public renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    const el = document.getElementById(divId);\n    if (!el) return;\n    const traces = (profiles ?? []).map((p, i) => ({\n      x: p.positions,\n      y: p.values,\n      type: 'scatter',\n      mode: 'lines',\n      line: { color: p.color ?? '#FFD400', width: 2 },\n      name: `Line ${i + 1}`,\n      hoverinfo: 'x+y',\n    }));\n    // X axis is in microns when the image carries a physical pixel size (mpp),\n    // otherwise in pixels — driven by the unit the sampler tagged on the profile.\n    const unit = (profiles ?? []).find(p => p.unit)?.unit ?? 'px';\n    const xTitle = unit === 'µm' ? 'Position (µm)' : 'Position (px)';\n    Plotly.react(el, traces as any, {\n      margin: { t: 6, r: 8, b: 38, l: 40 },\n      xaxis: { title: xTitle, zeroline: false, color: '#ddd' },\n      yaxis: { title: 'Intensity', zeroline: false, color: '#ddd' },\n      showlegend: false,\n      paper_bgcolor: 'rgba(25,25,25,0.9)',\n      plot_bgcolor: 'rgba(25,25,25,0.9)',\n      font: { color: '#eee', size: 10 },\n    } as any, { displayModeBar: false, responsive: true } as any);\n  }\n\n  /**\n   * Region shapes (filtered/redrawn for the current file). The profile-line ROIs\n   * are ordinary store regions (tagged `kind: 'profile'`), so they are already\n   * part of `this.shapes` — no separate append is needed.\n   */\n  private currentRenderShapes(showLabel = this.regionStore.getShowShapeLabel()): any[] {\n    return this.shapesToRedraw(showLabel);\n  }\n\n  /**\n   * IIntensityControls: add another intensity-profile line as a neutral Region\n   * (tagged `kind: 'profile'`). It is a horizontal open 2-point polyline spanning\n   * the image width, staggered vertically so successive lines stay distinct, in\n   * the next bright palette colour. Added to the shared store so both backends\n   * (Plotly + OpenSeadragon) render and drag it; excluded from the Regions tab\n   * and exports by its kind.\n   */\n  public addProfileLine(): Region | null {\n    if (!this.trueImgSize) return null;\n    const count = this.getProfileRegions().length;\n    const imgX0 = this.trueImgSize[0], imgX1 = this.trueImgSize[1];\n    const imgTop = this.trueImgSize[2], imgBottom = this.trueImgSize[3];\n\n    // Place the line within the currently VISIBLE image area, so when zoomed in it\n    // lands on-screen instead of spanning the whole (mostly off-screen) image, at\n    // 2/3 of the visible width and horizontally centred. Falls back to the full\n    // image when no viewport ROI is known (Plotly heatmap) or a stale ROI no longer\n    // overlaps the image.\n    const roi = this.lastVisibleRoi;\n    const overlaps = !!roi && roi.width > 0 && roi.height > 0\n      && roi.x < imgX1 && roi.x + roi.width > imgX0\n      && roi.y < imgBottom && roi.y + roi.height > imgTop;\n    const x0v = overlaps ? Math.max(imgX0, roi!.x) : imgX0;\n    const x1v = overlaps ? Math.min(imgX1, roi!.x + roi!.width) : imgX1;\n    const topV = overlaps ? Math.max(imgTop, roi!.y) : imgTop;\n    const bottomV = overlaps ? Math.min(imgBottom, roi!.y + roi!.height) : imgBottom;\n\n    const cx = (x0v + x1v) / 2;\n    const half = ((x1v - x0v) * (2 / 3)) / 2; // line spans 2/3 of the visible width\n    const x0 = cx - half, x1 = cx + half;\n\n    const bandH = bottomV - topV;\n    const midY = (topV + bottomV) / 2;\n    // Stagger successive lines across the visible band so they stay distinct.\n    const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));\n\n    const poly = new Polygon();\n    poly.npoints = 2;\n    poly.xpoints = [x0, x1];\n    poly.ypoints = [y, y];\n    poly.coordinates = [[x0, y], [x1, y]];\n    poly.closed = false;\n\n    const region = new Region();\n    region.bounds = poly;\n    region.kind = 'profile';\n    region.color = this.PROFILE_PALETTE[this.profileColorSeq++ % this.PROFILE_PALETTE.length];\n    // Leave region.label undefined so applyClassificationColors won't recolor it.\n\n    this.regionStore.addRegion(region);\n\n    // If a Plotly plot is on screen, re-render shapes so the new line appears.\n    // (The OSD overlay renders automatically via its region-update subscription.)\n    if (this.plotDiv) {\n      this.syncShapesFromStore();\n      try {\n        Plotly.relayout(this.plotDiv, { shapes: this.currentRenderShapes() } as any);\n      } catch { /* div not a Plotly plot (OSD owns it) */ }\n    }\n    return region;\n  }\n\n  /** The profile-line ROIs currently in the store (kind === 'profile'). */\n  private getProfileRegions(): Region[] {\n    return this.regionStore.getRegions().filter(r => (r as any).kind === 'profile');\n  }\n\n  /** Recompute and broadcast a profile for every profile-line region (id + colour\n   *  tagged so the inset trace matches its line). */\n  private emitProfiles(): void {\n    this.intensityProfile$.next(this.getProfileRegions().map(r => ({\n      ...this.computeIntensityProfileForRegion(r),\n      id: r.id,\n      color: r.color,\n    })));\n  }\n\n  /**\n   * Sample the intensity profile for a profile-line region: extract its two\n   * polygon endpoints and reuse the shared `computeIntensityProfile` sampling.\n   */\n  private computeIntensityProfileForRegion(region: Region): IntensityProfile {\n    // Duck-typed (not `instanceof Polygon`): after a drag round-trips through the\n    // store the bounds can be a plain object, so match on the point arrays.\n    const poly: any = region.bounds;\n    if (!poly || !Array.isArray(poly.xpoints) || !Array.isArray(poly.ypoints) ||\n        poly.xpoints.length < 2 || poly.ypoints.length < 2) {\n      return { positions: [], values: [] };\n    }\n    return this.computeIntensityProfile({\n      x0: poly.xpoints[0], y0: poly.ypoints[0],\n      x1: poly.xpoints[1], y1: poly.ypoints[1],\n    });\n  }\n\n  /**\n   * Supply pixel frames for intensity sampling (used by the OSD/image backend,\n   * whose cached frames may be empty). Optionally also sets the data/pixel ratios.\n   */\n  public setSamplingFrames(frames: any[], ratios: number[], origin: [number, number] = [0, 0]): void {\n    this.cachedImageFrames = frames;\n    if (ratios) this.cachedImageRatios = ratios;\n    this.cachedFrameOrigin = origin;\n  }\n\n  /**\n   * Populate the sampling cache for the intensity profiles when OpenSeadragon is\n   * the active backend (the Image plot type). In OSD mode Plotly never rendered,\n   * so `cachedImageFrames`/`trueImgSize` are unset — fetch the current slice's\n   * preview (the same pixels the heatmap would sample) so the line ROIs have\n   * pixel data and a placement extent. Re-emits the profiles once loaded.\n   */\n  public async ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    if (!imageInfo?.urls?.length) return;\n    // Sample just the displayed slice (showStack off → single frame); `load`\n    // also sets `this.trueImgSize`, which addProfileLine needs for placement.\n    const single = { ...imageInfo, showStack: false } as IImageInfo;\n    const loaded = await this.load(single, zIndex || 0);\n    this.cachedImageFrames = loaded.data;\n    this.cachedImageRatios = loaded.ratios;\n    this.cachedImageWidth = loaded.sizes?.[0] ?? this.cachedImageWidth;\n    this.cachedImageHeight = loaded.sizes?.[1] ?? this.cachedImageHeight;\n    this.cachedFrameOrigin = [0, 0]; // full preview\n    this.cachedIsGrayscale = !!imageInfo.isGrayscale;\n    this.emitProfiles();\n  }\n\n  /**\n   * {@link IIntensitySampling} stub — the viewport-change signal is OpenSeadragon's\n   * (it re-samples on OSD zoom/pan). Plotly's own high-def zoom updates the\n   * sampling cache inline, so it never emits here; returns EMPTY so a uniform\n   * `IVisualizer` consumer can subscribe regardless of the active backend.\n   */\n  public getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return EMPTY;\n  }\n\n  /**\n   * Re-fetch the given image-pixel ROI at the display resolution and use it as\n   * the intensity-sampling source, so the profile reflects the data at the\n   * current zoom level. Shared by both backends: the OSD viewport-change hook\n   * calls it on zoom/pan; Plotly's own high-def zoom (triggerZoom) updates the\n   * same cache inline. `roi` is in full-image pixel coordinates.\n   */\n  public refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number,\n                                        zIndex: number): void {\n    if (width <= 0 || height <= 0) return;\n    // Remember the visible region so a new profile line is placed inside it.\n    this.lastVisibleRoi = { x, y, width, height };\n    const roi = new Rectangle();\n    roi.x = Math.round(x); roi.y = Math.round(y);\n    roi.width = Math.round(width); roi.height = Math.round(height);\n    const screen = this.plotUtilities.getDomRectangle('diagram');\n    // Snapshot the filename so a response that arrives after the user switched\n    // files is dropped (the request carried the file selected at call time).\n    const reqName = this.fileName;\n    this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({\n      next: (zoomData) => {\n        Image.load(Buffer.from(new Uint8Array(zoomData))).then((image: any) => {\n          if (this.fileName !== reqName) return;\n          const isGray = !!this.imageInfo?.isGrayscale;\n          const frame = isGray\n            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)\n            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);\n          this.setSamplingFrames([frame], [roi.width / image.width, roi.height / image.height],\n            [roi.x, roi.y]);\n          this.emitProfiles();\n        });\n      },\n      error: () => { /* keep the previous sampling frame on a failed crop fetch */ },\n    });\n  }\n\n  /**\n   * Sample the active frame's intensity (grayscale value or RGB luminance)\n   * along the line ROI. Returns distance-along-line positions and values.\n   */\n  private computeIntensityProfile(line: any): IntensityProfile {\n    const empty: IntensityProfile = { positions: [], values: [] };\n    if (!this.cachedImageFrames?.length || !line) return empty;\n    const frame = this.cachedImageFrames[this.activeFrameIndex()] ?? this.cachedImageFrames[0];\n    if (!frame?.length) return empty;\n    const rx = this.cachedImageRatios[0] || 1;\n    const ry = this.cachedImageRatios[1] || rx;\n    const [ox, oy] = this.cachedFrameOrigin;\n    const x0 = +line.x0, y0 = +line.y0, x1 = +line.x1, y1 = +line.y1;\n    const dxData = x1 - x0, dyData = y1 - y0;\n    // Scale the along-line distance by the physical pixel size (microns/pixel)\n    // when the image carries one — anisotropic mppX/mppY are applied per axis so\n    // diagonal lines measure the true physical length. Falls back to pixels.\n    const { mppX, mppY } = this.currentMpp();\n    const useMicrons = mppX != null;\n    const lenData = useMicrons\n      ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX))\n      : Math.hypot(dxData, dyData);\n    const lenPx = Math.hypot(dxData / rx, dyData / ry);\n    const n = Math.max(2, Math.round(lenPx));\n    const h = frame.length;\n    const w = frame[0].length;\n    const positions: number[] = [];\n    const values: number[] = [];\n    for (let i = 0; i < n; i++) {\n      const t = i / (n - 1);\n      // Map data coords to the cached frame's pixel grid, offset by the frame's\n      // origin (non-zero when the frame is a zoomed crop).\n      const px = Math.round((x0 + t * dxData - ox) / rx);\n      const py = Math.round((y0 + t * dyData - oy) / ry);\n      let v = 0;\n      if (px >= 0 && px < w && py >= 0 && py < h) {\n        const cell = frame[py][px];\n        v = Array.isArray(cell) ? (0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2]) : cell;\n      }\n      positions.push(t * lenData);\n      values.push(v);\n    }\n    return { positions, values, unit: useMicrons ? 'µm' : 'px' };\n  }\n\n  /** Physical pixel size (microns/pixel) for the current image, if known.\n   *  mpp is constant across frames/channels, so the first metadata entry that\n   *  carries a positive mppX wins. Returns nulls when the image is unscaled. */\n  private currentMpp(): { mppX: number | null; mppY: number | null } {\n    const meta = this.imageInfo?.imageMeta;\n    const m = Array.isArray(meta)\n      ? (meta.find(e => e && (e.mppX ?? 0) > 0) ?? meta[0])\n      : undefined;\n    const mppX = m && (m.mppX ?? 0) > 0 ? (m.mppX as number) : null;\n    const mppY = m && (m.mppY ?? 0) > 0 ? (m.mppY as number) : null;\n    return { mppX, mppY };\n  }\n\n  /**\n   * autoscale the plot\n   */\n  public autoscale() {\n    if (this.plotDiv) {\n      this.zoomCoordinates = [];\n      Plotly.relayout(this.plotDiv, {\n        'xaxis.autorange': true,\n        'yaxis.autorange': false }\n      );\n    }\n  }\n\n  /**\n   * relayout the plot\n   */\n  public relayout(trueImageSize?: number[]) {\n    let imgSize;\n    if (trueImageSize) {\n      imgSize = trueImageSize;\n    } else {\n      imgSize = this.trueImgSize;\n    }\n    if (this.plotDiv) {\n      // Refresh height from current DOM so panel resizes are reflected\n      const plotEl = document.getElementById(this.plotDiv);\n      if (plotEl?.offsetHeight) {\n        this.screenHeight = plotEl.offsetHeight;\n      }\n      try {\n        if (this.zoomCoordinates.length > 0) {\n          Plotly.relayout(this.plotDiv, this.getHeatmapLayout(\n            [this.zoomCoordinates[0], this.zoomCoordinates[1]],\n            [this.zoomCoordinates[2], this.zoomCoordinates[3]]));    // reverse the y range\n        } else {\n          // as autorange is set to false, and not reversed we need to set the yrange correcly here\n          Plotly.relayout(this.plotDiv, this.getHeatmapLayout(\n            [imgSize[0], imgSize[1]], [imgSize[3], imgSize[2]]));\n        }\n      } catch (err: any) {\n        const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n        console.error('Error occured', err);\n        this.messageService.add({ key: 'center-toast', sticky: true, severity:'error', summary:'An error occured', detail:`The following\n                                  error occured: ${msg}. Please try to open the image again through the\n                                  file navigator.` });\n        // TODO correctly clear the plot\n        this.reset();\n      }\n    }\n  }\n\n  private setEvents(plotDiv: string, isGrayscale: boolean, screenHeight: number) {\n    this.imageInfo.isGrayscale = isGrayscale;\n    this.screenHeight = screenHeight;\n    const plot: any = document.getElementById(plotDiv);\n    if (plot) {\n      // unbind previous event\n      plot.removeEventListener('plotly_relayout', this.onRelayoutEvent);\n      // bind new event\n      plot.on('plotly_relayout', this.onRelayoutEvent);\n\n      // Clicking on a shape activates it but Plotly doesn't fire a dedicated\n      // event — sample _activeShapeIndex on the next microtask so subscribers\n      // (Region Editor) can mirror the selection.\n      plot.removeEventListener('mousedown', this.onPlotMouseDown);\n      this.onPlotMouseDown = () => setTimeout(() => this.maybeEmitActiveShapeIndex(), 0);\n      plot.addEventListener('mousedown', this.onPlotMouseDown);\n    }\n  }\n\n  private relayoutEventHandler(event: any) {\n    if (Object.keys(event).includes('dragmode')) {\n      this.dragMode = event.dragmode;\n    }\n    // when relayout event occurs\n    // update the region selection udpdates\n    const keys = Object.keys(event);\n    let shapesModified = false;\n    keys.forEach((key: any) => {\n      if (typeof key === 'string' && key.startsWith('shapes[')) {\n        const shapeNumber = +key.split('[')[1].split(']')[0];\n        const shapeChange = key.split('.')[1];\n        if (this.shapes && this.shapes[shapeNumber]) {\n          if (shapeChange === 'path') {\n            this.shapes[shapeNumber][shapeChange] = this.plotUtilities.roundPathCoordinates(event[key]);\n          } else {\n            this.shapes[shapeNumber][shapeChange] = Math.round(+event[key]);\n          }\n          shapesModified = true;\n        }\n      }\n    });\n    if (shapesModified) {\n      // Mirror the in-place edit into the shared store (syncs its cache + emits).\n      this.commitShapesToStore();\n    }\n    // manage high def zoom (not if we are showing a stack)\n    if (keys.length === 4 && this.isRealZoom) {\n      const coordinates: any[] = [];\n      keys.forEach(key => {\n        if (key.startsWith('xaxis.range[')) {\n          coordinates.push(event[key]);\n        }\n        if (key.startsWith('yaxis.range[')) {\n          coordinates.push(event[key]);\n        }\n      });\n      this.zoomCoordinates = coordinates;\n      if (!this.imageInfo.showStack) {\n        this.triggerZoom(coordinates);\n      }\n    }\n    // when shape is created\n    if (keys.length === 1 && 'shapes' in event) {\n      this.shapes = event.shapes as any[];\n      for (let i = 0; i < this.shapes.length; i++) {\n        // A freshly Plotly-drawn shape has no id yet — give it a label object\n        // (when labels are on) before the store mints id + default name.\n        const isNew = this.shapes[i].id == null;\n        this.shapes[i].fileName = this.fileName;\n        this.shapes[i] = this.plotUtilities.snapRegion(this.shapes[i]);\n        if (isNew && this.regionStore.getShowShapeLabel()) {\n          this.shapes[i].label = { text: this.shapes[i].label,\n            texttemplate: this.shapes[i].label,\n            font: { color: this.regionStore.getShapeColor() },\n            textposition: 'top left'\n          };\n        }\n      }\n      // Mint ids/names in the store, write them back onto the dicts, and emit.\n      this.commitShapesToStore();\n      if (this.isRegionSavedOn) {\n        this.previousShapes = this.shapes.slice();\n      }\n    }\n    // if autoscale\n    if (keys.includes('xaxis.autorange') && keys.includes('yaxis.autorange')) {\n      // trigger an autoscale event to reset the selected image mode dropdown\n      this.autoscaleEvent.next('an autoscale has happened');\n      // select display type to trigger a new plotting update with all the necessary plotting parameters set\n      this.tiles.selectDiagramDisplay();\n    }\n    // if showstack or aspectratio event\n    if (event.showstack !== undefined || event.aspectratio !== undefined) {\n      // Set new image info to trigger a plot update\n      this.setImageInfo(event.showstack, event.aspectratio);\n    }\n\n    // Plotly may have updated the active shape index as part of the relayout\n    // (e.g. clicking a shape's edit handle, or finishing a draw) — surface\n    // that change to the Region Editor.\n    this.maybeEmitActiveShapeIndex();\n  }\n\n  public reloadAndPlot() {\n    this.setImageInfo();\n  }\n\n\n  // ── Tool delegations ────────────────────────────────────────────────\n\n  public setWandMode(active: boolean, options: WandOptions = {}) {\n    // Re-bind to ourselves in case the OSD backend last used these singletons.\n    if (active) this.wandTool.bindHost(this.wandHost);\n    this.wandTool.setMode(active, options);\n  }\n\n  public setWandOptions(options: WandOptions) {\n    this.wandTool.setOptions(options);\n  }\n\n  public clearActiveWandRegion() {\n    this.wandTool.clearActiveRegion();\n  }\n\n  public setBrushMode(active: boolean, options: BrushOptions = {}) {\n    // Re-bind to ourselves in case the OSD backend last used this singleton.\n    if (active) this.brushTool.bindHost(this.wandHost);\n    this.brushTool.setMode(active, options);\n  }\n\n  public setBrushOptions(options: BrushOptions) {\n    if (options.size != null) this.brushTool.setSize(options.size);\n  }\n\n  public setVertexEraserMode(active: boolean) {\n    if (active) this.vertexEraserTool.bindHost(this.eraserHost);\n    this.vertexEraserTool.setMode(active);\n  }\n\n  public setVertexEraserRadius(radius: number) {\n    this.vertexEraserTool.setRadius(radius);\n  }\n\n  public setZoomToBoxMode(active: boolean) {\n    // The zoom-to-box tool is a root singleton shared with the OSD backend,\n    // which rebinds it to its own host on activation. Rebind to ours when we\n    // activate so a prior OSD zoom-to-box doesn't leave the singleton pointing\n    // at OSD's coordinate/zoom handlers (which would break box-zoom on heatmaps).\n    if (active) this.bindZoomToBoxHost();\n    this.zoomToBoxTool.setMode(active);\n  }\n\n  /** Bind the shared zoom-to-box tool to this (Plotly) backend's host. */\n  private bindZoomToBoxHost() {\n    this.zoomToBoxTool.bindHost({\n      getPlotDiv: () => this.plotDiv,\n      pixelToData: (px, py) => this.zoomBoxPixelToData(px, py),\n      applyZoomToBox: (coords) => this.applyZoomToBox(coords),\n    });\n  }\n\n  /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the\n   *  wand host (cached frame + coordinate transform + region store). */\n  public segmentRectangles(): Promise<number> {\n    this.samTool.bindHost(this.wandHost);\n    return this.samTool.segmentBoxes();\n  }\n  public segmentRectanglesCellpose(): Promise<number> {\n    if (!this.cellSegmenter) return Promise.resolve(0);\n    this.cellSegmentTool.bindHost(this.wandHost);\n    return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);\n  }\n  public setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\n  }\n  public setSamPointMode(active: boolean): void {\n    if (active) this.samPointTool.bindHost(this.wandHost);\n    this.samPointTool.setMode(active);\n  }\n  public commitSamPoints(): void { this.samPointTool.commit(); }\n  public clearSamPoints(): void { this.samPointTool.clear(); }\n\n  /**\n   * Tool-host callback: apply the zoom-to-box selection. Stack mode does a\n   * pure axis-range relayout; non-stack mode goes through the high-def\n   * triggerZoom pipeline so the image is re-fetched at the new resolution.\n   */\n  /** Overlay-pixel -> Plotly data coords via the axis objects (subtracting the\n   *  plot margin offset). The zoom-to-box tool calls this through its host. */\n  private zoomBoxPixelToData(px: number, py: number): { x: number; y: number } {\n    const gd: any = document.getElementById(this.plotDiv);\n    const xaxis = gd._fullLayout.xaxis;\n    const yaxis = gd._fullLayout.yaxis;\n    return { x: xaxis.p2d(px - xaxis._offset), y: yaxis.p2d(py - yaxis._offset) };\n  }\n\n  private applyZoomToBox(coordinates: number[]) {\n    this.zoomCoordinates = coordinates;\n    if (this.imageInfo?.showStack) {\n      Plotly.relayout(this.plotDiv, {\n        'xaxis.range[0]': coordinates[0],\n        'xaxis.range[1]': coordinates[1],\n        'yaxis.range[0]': coordinates[2],\n        'yaxis.range[1]': coordinates[3],\n      } as any);\n    } else {\n      this.triggerZoom(coordinates);\n    }\n  }\n\n  // ── IViewportHost implementation (for the on-canvas tools) ──────────\n\n  /** The plot element the tool canvas overlays attach to. */\n  public getOverlayContainer(): HTMLElement | null {\n    return this.plotDiv ? document.getElementById(this.plotDiv) : null;\n  }\n\n  /** Plotly coordinate transform (screen <-> data via the axis objects). */\n  public getCoordinateTransform(): ICoordinateTransform {\n    return this.coordinateTransform;\n  }\n\n  // ── WandToolHost implementation ─────────────────────────────────────\n\n  /** Pixel data the wand needs for sampling. null = no image loaded. */\n  private getCachedImageData(): CachedImageData | null {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length === 0) return null;\n    return {\n      frames: this.cachedImageFrames,\n      width: this.cachedImageWidth,\n      height: this.cachedImageHeight,\n      ratios: this.cachedImageRatios,\n      isGrayscale: this.cachedIsGrayscale,\n    };\n  }\n\n  // ── shared-store sync helpers ──────────────────────────────────────────\n  //\n  // `this.shapes` is Plotly's own representation (the dict array Plotly.relayout\n  // consumes). The shared RegionStore is the single source of truth, holding the\n  // neutral Region model. These helpers bridge the two: writes mirror\n  // `this.shapes` INTO the store; image switches/external changes project the\n  // store back OUT to `this.shapes`.\n\n  /** Build Plotly shape dicts from the store's regions (the render projection). */\n  private regionsToShapeDicts(): any[] {\n    const showLabel = this.regionStore.getShowShapeLabel();\n    return this.regionStore.getRegions().map(r => {\n      r.filename = this.fileName;\n      return { ...r.getShape(showLabel) };\n    });\n  }\n\n  /** Rebuild the dict working-set from the store (after an image switch, or when\n   *  regions changed while another backend was rendering). */\n  private syncShapesFromStore(): void {\n    this.shapes = this.regionsToShapeDicts();\n  }\n\n  /**\n   * Make the shared store authoritative for the current dict working-set: convert\n   * `this.shapes` to neutral regions and replace the store's list (the store\n   * mints ids, applies class colours, syncs its per-image cache and emits the\n   * region-update event). Store-minted ids are written back onto the dicts so the\n   * two representations stay aligned. Profile-line ROIs are ordinary regions\n   * (tagged `kind: 'profile'`) and round-trip through here too.\n   */\n  private commitShapesToStore(): void {\n    const regions = this.shapes\n      .map(s => Object.assign(new ShapeSelection(), s).getRegion());\n    this.regionStore.setRegions(regions, this.regionStore.getShowShapeLabel(), true,\n      this.regionStore.getFillColor(), false);\n    const stored = this.regionStore.getRegions();\n    for (let i = 0; i < this.shapes.length && i < stored.length; i++) {\n      if (this.shapes[i].id == null) this.shapes[i].id = stored[i].id;\n      if (this.shapes[i].name == null) this.shapes[i].name = stored[i].name;\n    }\n  }\n\n  /**\n   * Push the current `this.shapes` to Plotly, mirror them into the shared store\n   * (which syncs its cache + emits the region-update event), and refresh the\n   * local previous-shapes buffer. The wand/eraser tools call this after mutating\n   * the shapes array directly.\n   */\n  public applyShapesChange() {\n    if (this.isRegionSavedOn) {\n      this.previousShapes = this.shapes.slice();\n    }\n    this.commitShapesToStore();\n    if (this.plotDiv) {\n      const dictArray = this.shapes.map(s => ({ ...s }));\n      try {\n        Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray) as any);\n      } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n    }\n  }\n\n  /** Active frame index in the cached image stack. */\n  private activeFrameIndex(): number {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length <= 1) return 0;\n    const gd: any = document.getElementById(this.plotDiv);\n    const sliderActive = gd?._fullLayout?.sliders?.[0]?.active;\n    if (typeof sliderActive === 'number') return sliderActive;\n    return this.zIndex.value || 0;\n  }\n\n  /** Capability-gated 3D scene controls (Plotly renders the 3D plot types). */\n  getSurface3dControls() {\n    return {\n      setSurfaceDragMode: (mode: string) => this.setSurfaceDragMode(mode),\n      resetSurfaceCamera: () => this.resetSurfaceCamera(),\n    };\n  }\n\n  public setSurfaceDragMode(mode: string) {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.dragmode': mode } as any);\n    }\n  }\n\n  public resetSurfaceCamera() {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.camera': {} } as any);\n    }\n  }\n\n  private triggerZoom(coordinates: number[]) {\n    if (coordinates.length === 0 || !this.trueImgSize) return;\n    this.zoomCoordinates = coordinates;\n    const rect = this.plotUtilities.getRectangle(coordinates, this.trueImgSize);\n    if (this.plotUtilities.isZoomSameAsImgSize(rect, this.trueImgSize)) {\n      this.autoscale();\n      return;\n    }\n    // A brief \"Caching image...\" message for uncached files (large files take a\n    // moment to cache); just a spinner otherwise.\n    this.state.setImageLoadingMessage(this.imageCached ? '' : 'Caching image...');\n    const screen = this.plotUtilities.getDomRectangle('diagram');\n    const imageSize: any[] = [];\n    imageSize[0] = rect.x;\n    imageSize[1] = rect.x + rect.width;\n    imageSize[2] = rect.y;\n    imageSize[3] = rect.y + rect.height;\n    // Snapshot the filename so a response that arrives after the user switched\n    // files is dropped (the request carried the file selected at call time).\n    const reqName = this.fileName;\n    this.state.setImageLoading(true);\n    this.state.setZoom(true);\n    this.tiles.zoomOnRegion(rect, screen, this.zIndex.value).subscribe({ next: zoomData => {\n      const uint8Array = new Uint8Array(zoomData);\n      const buffer = Buffer.from(uint8Array);\n      Image.load(buffer).then((image: any) => {\n        const xRatio = rect.width / image.width;\n        const yRatio = rect.height / image.height;\n        if (this.fileName === reqName) {\n          const isGray = this.imageInfo.isGrayscale;\n          const frame = isGray\n            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)\n            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);\n          // Also sample the intensity profiles from this high-def crop so the\n          // inset reflects the zoom-level resolution (origin = crop top-left).\n          this.setSamplingFrames([frame], [xRatio, yRatio], [imageSize[0], imageSize[2]]);\n          this.emitProfiles();\n          // Re-render the high-def crop in the SAME plot type the user is\n          // viewing. Without this the zoom re-fetch always fell back to a\n          // heatmap, so zooming in contour (or any registry type) reverted\n          // to heatmap.\n          const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];\n          const renderPromise = impl\n            ? this.plotViaRegistry(this.plotDiv, impl,\n                this.buildTraceInput(this.imageInfo, {\n                  data: [frame], ratios: [xRatio, yRatio],\n                  sizes: [image.width, image.height], filename: reqName,\n                }, imageSize), this.screenHeight)\n            : (isGray\n                ? this.plotHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio],\n                    this.screenHeight)\n                : this.plotRGBHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio],\n                    image.width, image.height, this.screenHeight));\n          // plotViaRegistry already applies the type's own layout/range for\n          // non-image layouts (chart/overlay); only re-apply the heatmap\n          // range for the image-aligned paths.\n          const reapplyRange = !impl || impl.layoutKind === '2d-image';\n          renderPromise.then(() => {\n            this.state.setImageCached(true);\n            this.state.setImageLoading(false);\n            image = null;\n            if (reapplyRange) this.relayout(imageSize);\n          });\n        }\n      });\n    }, error: err => {\n      const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n      console.error('Error occured when zooming', err);\n      this.messageService.add({ key: 'center-toast', sticky: true, severity:'error', summary:'An error occured',\n        detail:`The following error occured while zooming: ${msg}.\n                          Please try to open the image again through the file navigator and\n                          zoom on the selected area once more.` });\n      this.state.setLoadingError(true);\n      this.state.setImageLoading(false);\n    }, complete: () => {\n      console.log('zooming complete');\n    } });\n  }\n\n  public setPlotType(plotType: PlotType) {\n    this.plotType = plotType;\n  }\n\n  private setImageInfo(showStack?: boolean, scaleratio?: boolean) {\n    // Build a partial image descriptor and push it to the host via the port.\n    const imgInfo: Partial<IImageInfo> = {\n      isGrayscale: this.imageInfo.isGrayscale,\n      trueImageSize: [this.trueImgSize[1], this.trueImgSize[3]],\n      urls: this.urls,\n      isStack: this.urls.length > 1,\n      scaleRatio: scaleratio !== undefined ? scaleratio : this.scaleratio,\n    };\n    if (showStack !== undefined) imgInfo.showStack = showStack;\n    if (this.fileName) imgInfo.fileName = this.fileName;\n    this.state.setImageInfo(imgInfo);\n  }\n\n  public getShapes() {\n    return this.shapes;\n  }\n\n  /**\n   * Framework-neutral view of the current regions — delegates to the shared\n   * RegionStore (the single source of truth). The canonical accessor on the\n   * `IVisualizer` contract; consumers should prefer this over `getShapes()`\n   * (which exposes Plotly-shaped dicts).\n   */\n  public getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n\n  /**\n   * Switch the active image. The shared RegionStore owns the per-image region\n   * cache (snapshot outgoing / restore incoming / clear selection / emit); we\n   * delegate to it, then re-project the store's regions into Plotly's dict\n   * working-set. Re-projecting unconditionally (even when the store no-ops for\n   * the same image) means Plotly also picks up regions another backend (OSD)\n   * added while it was off-screen. Called from `plot()` and from the router\n   * before any backend renders.\n   */\n  public setActiveImage(imageInfo: IImageInfo) {\n    this.regionStore.setActiveImage(imageInfo);\n    this.syncShapesFromStore();\n    this.previousShapes = this.shapes.slice();\n  }\n\n  /** Test/dev hook — drop the entire per-image cache (logout / project switch). */\n  public clearRegionsByImageKey() {\n    this.regionStore.clearRegionsByImageKey();\n  }\n\n  /**\n   * Get all the selected regions as polygons. Open polylines (closed === false)\n   * are excluded — they're annotation-only and cannot be used as filled regions\n   * for image processing. Delegates to the shared store.\n   */\n  public getRegionPolygons(): any[] {\n    return this.regionStore.getRegionPolygons();\n  }\n\n  isRectangle(bnds: any): bnds is Rectangle {\n    return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;\n  }\n\n  isPolygon(bnds: any): bnds is Polygon {\n    return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;\n  }\n\n  /**\n   * Set plot regions. Delegates the state change to the shared RegionStore\n   * (id/name minting, classification colours, append de-duplication, per-image\n   * cache and the region-update event all live there), then re-projects the\n   * store's regions into Plotly's dict working-set and renders.\n   *\n   * When `isRegionSaveOn` is false the regions are shown transiently — rendered\n   * without altering the stored working-set (preserves the prior behaviour).\n   */\n  public setRegions(regions: Region[], showRegionLabel?: boolean,\n                    isRegionSaveOn?: boolean, fillColor?: string,\n                    append: boolean = false) {\n    const showLabel = showRegionLabel === undefined ? this.regionStore.getShowShapeLabel() : showRegionLabel;\n    const save = isRegionSaveOn === undefined ? this.isRegionSavedOn : isRegionSaveOn;\n\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n    this.isRegionSavedOn = save;\n\n    if (save) {\n      // Re-project the authoritative regions into Plotly's working-set and render.\n      this.syncShapesFromStore();\n      this.renderShapes();\n    } else {\n      // Transient display only — render the passed regions, don't touch the\n      // working-set (and the store didn't store them either).\n      const dicts = regions.map(r => { r.filename = this.fileName; return { ...r.getShape(showLabel) }; });\n      try {\n        Plotly.relayout(this.plotDiv, this.shapesRelayout(dicts) as any);\n      } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n    }\n  }\n\n  /** The shapes-relayout payload: region shapes (profile-line ROIs included, as\n   *  they are ordinary regions) plus the active-shape fill colour. */\n  private shapesRelayout(shapeDicts: any[]): any {\n    return {\n      shapes: shapeDicts,\n      activeshape: { fillcolor: this.regionStore.getFillColor() },\n    };\n  }\n\n  /** Push the current dict working-set to Plotly (no-op when another backend\n   *  owns the div). */\n  private renderShapes(): void {\n    if (!this.plotDiv) return;\n    const dictArray = this.shapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray) as any);\n    } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n  }\n\n  getShowShapeLabel() {\n    return this.regionStore.getShowShapeLabel();\n  }\n\n  /**\n   * Set previous saved shapes\n   */\n  public plotPreviousShapes() {\n    // convert to dict so that plotly recognises the shapes\n    const dictArray = this.previousShapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, { shapes: dictArray });\n    } catch { /* div owned by another backend (OSD) */ }\n  }\n\n  setPreviousShapes(shapes: ShapeSelection[]) {\n    this.previousShapes = shapes;\n  }\n\n  getPreviousShapes() {\n    return this.previousShapes;\n  }\n\n  // Undo (jit-ui#85): region history lives in the shared RegionStore, so the\n  // active backend's overlay re-renders off its regionUpdate$ on restore.\n  public undo(): void { this.regionStore.undo(); }\n  public redo(): void { this.regionStore.redo(); }\n  public canUndo(): boolean { return this.regionStore.canUndo(); }\n  public canRedo(): boolean { return this.regionStore.canRedo(); }\n  public getCanUndo$(): Observable<boolean> { return this.regionStore.getCanUndo$(); }\n  public getCanRedo$(): Observable<boolean> { return this.regionStore.getCanRedo$(); }\n  public resetUndoHistory(): void { this.regionStore.resetUndoHistory(); }\n\n  // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────\n  public enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                        saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  public exitStackMode(): void { this.regionStore.exitStackMode(); }\n  public isStackMode(): boolean { return this.regionStore.isStackMode(); }\n  public getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  public setDisplaySlice(z: number): void { this.regionStore.setDisplaySlice(z); }\n  public getSliceRegions(): Region[] { return this.regionStore.getSliceRegions(); }\n  public getStackSaveSlices(): Map<number, Region[]> { return this.regionStore.getStackSaveSlices(); }\n\n  private getHeatmapLayout(xRange: number[], yRange: number[]): any {\n    return {\n      xaxis: {\n        constrain: 'range',\n        constraintoward: 'center',\n        side: 'top',\n        ticks: '',\n        range: xRange\n      },\n      yaxis: {\n        constrain: 'range',\n        constraintoward: 'center',\n        range: yRange,\n        ticks: '',\n        ticksuffix: '  ',\n\t\t\t\t// set autorange to false so that plotly does not overwrite the range for the y axis\n\t\t\t\tautorange: false,\n        scaleanchor: this.scaleratio ? 'x' : false\n     },\n      margin: { t: 30, b: 5, l: 55, r: 5 },\n      height: this.screenHeight,\n      sliders: [{\n        pad: { t: 50 },\n        currentvalue: {\n          visible: true,\n          prefix: 'Z-plane:',\n          xanchor: 'right',\n        },\n        steps: this.getSteps()\n      }],\n      autosize: true,\n      shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),\n      activeshape: { fillcolor: this.regionStore.getFillColor() },\n      dragmode: this.dragMode ? this.dragMode : false,\n      newshape: { line: { color: this.regionStore.getShapeColor(), width: 3 } }\n    };\n  }\n\n  private shapesToRedraw(showLabel: boolean) {\n    const shapesToRedraw: ShapeSelection[] = [];\n    for (const shape of this.shapes) {\n      if (JSON.stringify(shape.fileName) === JSON.stringify(this.fileName)) {\n        // Set label\n        if (showLabel) {\n          shape.label = {\n            text: `${shape.legend}`,\n            texttemplate: `${shape.legend}`,\n            textposition: 'top left',\n            font: { color: `${shape.line.color}` }\n          };\n        } else {\n          shape.label = {};\n        }\n        shapesToRedraw.push(shape);\n      }\n    }\n    // convert to dict so that plotly recognises the shapes\n    return shapesToRedraw.map(s => ({ ...s }));\n  }\n  /**\n   * Unused (will be used when surface plot is added)\n   * @param xRange\n   * @param yRange\n   * @param zRatio\n   * @private\n   */\n  private getSurfaceLayout(xRange: number[], yRange: number[], zRatio: number): any {\n    return {\n      margin: { t: 0, b: 0, l: 0, r: 0 },\n      scene: {\n        xaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230,230)',\n          // range: xRange\n        },\n        yaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230, 230)',\n          // autorange: 'reversed',\n          // range: yRange,\n          // scaleanchor: 'x'\n        },\n        zaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230,230)'\n        },\n        aspectratio: { x: 1, y: 1, z: zRatio },\n        aspectmode: 'manual',\n        sliders: [{\n          pad: { t: 50 },\n          currentvalue: {\n            visible: true,\n            prefix: 'Z-plane:',\n            xanchor: 'right',\n          },\n          steps: this.getSteps()\n        }],\n      }\n    };\n  }\n\n  private getSteps() {\n    const steps = [];\n    for (let i = 0; i < this.imageLength; i++) {\n      steps.push({\n        label: i + 1,\n        method: 'restyle',\n        args: ['visible', Array(this.imageLength).fill(false).fill(true, i, i + 1)],\n      });\n    }\n    return steps;\n  }\n\n  /**\n   * Fetch an image via Angular HttpClient so that auth interceptors (Bearer token)\n   * are applied, then decode it with image-js. This avoids raw browser fetch()\n   * calls that bypass the interceptor chain and fail behind an OAuth2 proxy.\n   */\n  private async loadImage(url: string): Promise<Image> {\n    const buffer = await firstValueFrom(\n      this.http.get(url, { responseType: 'arraybuffer' })\n    );\n    return Image.load(Buffer.from(buffer));\n  }\n\n  /**\n   * Get the currently displayed image as an image-js Image instance.\n   * Used by the processing pipeline to obtain the input image.\n   */\n  public async getCurrentImage(): Promise<Image | null> {\n    if (!this.imageInfo || !this.imageInfo.urls || this.imageInfo.urls.length === 0) {\n      return null;\n    }\n    const zIdx = this.zIndex.value || 0;\n    const url = this.imageInfo.urls[zIdx] || this.imageInfo.urls[0];\n    return this.loadImage(url);\n  }\n\n  /**\n   * Get the currently displayed plot pixel data as a flat Uint8ClampedArray.\n   * This captures whatever is actually rendered — including zoomed regions.\n   * Returns { width, height, channels, data } or null if no plot is displayed.\n   */\n  public getDisplayedPixelData(): { width: number; height: number; channels: number;\n    data: Uint8ClampedArray } | null {\n    if (!this.plotDiv) return null;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?.data || gd.data.length === 0) return null;\n\n    // Find the visible trace\n    const frameIdx = this.activeFrameIndex();\n    const trace = gd.data[frameIdx] || gd.data[0];\n    if (!trace || !trace.z) return null;\n\n    const zData: any[][] = trace.z;\n    const height = zData.length;\n    if (height === 0) return null;\n    const width = zData[0].length;\n\n    if (trace.type === 'image') {\n      // RGB image: z[row][col] = [r, g, b] or [r, g, b, a]\n      const sample = zData[0][0];\n      const channels = Array.isArray(sample) ? sample.length : 3;\n      const data = new Uint8ClampedArray(width * height * channels);\n      for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n          const pixel = zData[y][x];\n          const offset = (y * width + x) * channels;\n          for (let c = 0; c < channels; c++) {\n            data[offset + c] = pixel[c];\n          }\n        }\n      }\n      return { width, height, channels, data };\n    } else {\n      // Heatmap (grayscale): z[row][col] = scalar value\n      const data = new Uint8ClampedArray(width * height);\n      for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n          data[y * width + x] = Math.round(zData[y][x]);\n        }\n      }\n      return { width, height, channels: 1, data };\n    }\n  }\n\n  /**\n   * Region of the original image that the displayed `z` grid covers, in\n   * full-image pixel coords. On a server zoom (`triggerZoom`) the trace `z` is\n   * replaced with the high-def crop and the axes are relaid out to the crop's\n   * original-image bounds (`imageSize`), so the live axis ranges ARE that\n   * rectangle; when the whole image is in view the ranges span `trueImgSize`.\n   * Reading the ranges therefore yields the crop origin + extent without\n   * tracking zoom state separately. Falls back to the full image, then `null`.\n   */\n  public getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    const xr: number[] | undefined = gd?._fullLayout?.xaxis?.range;\n    const yr: number[] | undefined = gd?._fullLayout?.yaxis?.range;\n    if (xr && yr) {\n      const x0 = Math.min(xr[0], xr[1]);\n      const y0 = Math.min(yr[0], yr[1]); // y axis is reversed for image layouts\n      return { x: x0, y: y0, width: Math.abs(xr[1] - xr[0]), height: Math.abs(yr[1] - yr[0]) };\n    }\n    if (!this.trueImgSize) return null;\n    return {\n      x: this.trueImgSize[0],\n      y: this.trueImgSize[2],\n      width: this.trueImgSize[1] - this.trueImgSize[0],\n      height: this.trueImgSize[3] - this.trueImgSize[2],\n    };\n  }\n\n  public reset() {\n    if (this.plotDiv) {\n      Plotly.newPlot(this.plotDiv, [],\n        this.getHeatmapLayout([0, 100], [100, 0]), CONFIG as any);\n    }\n  }\n\n  /**\n   * Fully remove Plotly's DOM from the plot div (axes included). Used when\n   * handing the div to another backend (OpenSeadragon) — unlike `reset()`,\n   * which re-renders an empty plot and would leave the Plotly axes showing.\n   */\n  public purgePlot() {\n    if (this.plotDiv) {\n      Plotly.purge(this.plotDiv);\n    }\n  }\n\n  /** Export the heatmap as a PNG (the rendered plot already reflects the active\n   *  colormap/window). The full-res tile composite is OSD's job. */\n  public exportComposite(): void {\n    this.downloadImage();\n  }\n\n  public downloadImage() {\n    if (this.plotDiv) {\n      (Plotly as any).downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });\n    }\n  }\n\n  public resetAxes() {\n    this.zoomCoordinates = [];\n    this.relayout();\n  }\n\n  public setDragMode(mode: string | false) {\n    this.dragMode = mode ? (mode as string) : '';\n    if (!this.plotDiv) return;\n    // Only relayout a LIVE Plotly graph. When another backend (OSD / napari-js) owns the view the\n    // div id is still set but has no Plotly plot attached, and Plotly.relayout throws\n    // (\"can't access property _guiEditing, n is undefined\"). That throw aborted the caller\n    // (deactivateActiveTool → onSelectPlotType) before the re-plot ran, wedging the plot type\n    // (e.g. stuck switching napari volume ↔ isosurface). Guard on `_fullLayout` like the zoom\n    // helpers do so it safely no-ops when Plotly isn't the active renderer.\n    const gd = document.getElementById(this.plotDiv) as unknown as { _fullLayout?: unknown } | null;\n    if (!gd?._fullLayout) return;\n    Plotly.relayout(this.plotDiv, { dragmode: mode } as any);\n  }\n\n  /** {@link IDataRenderer} stub — Plotly has no overview navigator (it's an\n   *  OpenSeadragon feature), so toggling it is a no-op here. */\n  public setNavigatorVisible(_visible: boolean): void {\n    /* no-op: navigator is OpenSeadragon-only */\n  }\n\n  /** {@link IDataRenderer} stub — image smoothing is an OpenSeadragon canvas-drawer\n   *  setting; the Plotly image/heatmap traces don't expose it, so it's a no-op. */\n  public setImageSmoothingEnabled(_enabled: boolean): void {\n    /* no-op: smoothing toggle is OpenSeadragon-only */\n  }\n\n  public zoomIn() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?._fullLayout) return;\n    const xl = gd._fullLayout.xaxis;\n    const yl = gd._fullLayout.yaxis;\n    // 3D scenes have no 2D xaxis/yaxis (they live under `scene`); the step-zoom\n    // is meaningless there and would throw on `xl.range`. Plotly's scene handles\n    // scroll-zoom natively, so just bail.\n    if (!xl?.range || !yl?.range) return;\n    const xc = (xl.range[0] + xl.range[1]) / 2;\n    const yc = (yl.range[0] + yl.range[1]) / 2;\n    const dx = (xl.range[1] - xl.range[0]) / 1.3;\n    const dy = (yl.range[1] - yl.range[0]) / 1.3;\n    const x0 = xc - dx / 2, x1 = xc + dx / 2;\n    const y0 = yc - dy / 2, y1 = yc + dy / 2;\n    this.zoomCoordinates = [x0, x1, y0, y1];\n    Plotly.relayout(this.plotDiv, {\n      'xaxis.range[0]': x0, 'xaxis.range[1]': x1,\n      'yaxis.range[0]': y0, 'yaxis.range[1]': y1\n    } as any);\n  }\n\n  /**\n   * Delete every currently selected shape. Falls back to the single\n   * `_activeShapeIndex` when no multi-selection is active (covers the case\n   * where Plotly clicked a shape without going through the table).\n   */\n  public deleteActiveShape() {\n    // Note: no `plotDiv` guard — when OpenSeadragon is the renderer, Plotly\n    // never plotted (plotDiv is unset), but deletion only needs the shape list\n    // + the current selection; the Plotly relayout below is guarded.\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n\n    // Resolve what to delete: the store's selection, else the shape Plotly\n    // tracks as clicked (when the user clicked a shape without going through the\n    // Region Editor table).\n    if (this.regionStore.getSelectedShapeIndices().length === 0) {\n      const activeIndex: number = gd?._fullLayout?._activeShapeIndex;\n      if (activeIndex === undefined || activeIndex < 0) return;\n      this.regionStore.setSelectedShapeIndices([activeIndex]);\n    }\n    // The store removes the selected regions, clears the selection, syncs its\n    // cache and emits the region-update event.\n    this.regionStore.deleteActiveShape();\n\n    // Re-project the remaining regions and render on the Plotly plot (a no-op,\n    // caught, when another backend owns the div — its overlay re-renders via\n    // the store's update event).\n    if (gd?._fullLayout) gd._fullLayout._activeShapeIndex = -1;\n    this.syncShapesFromStore();\n    const dictArray = this.shapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, { shapes: dictArray } as any).then(() => {\n        if (gd?._fullLayout) (Plotly as any).redraw(gd);\n      }, () => { /* div not a Plotly plot */ });\n    } catch { /* div owned by another backend */ }\n  }\n\n  public zoomOut() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?._fullLayout) return;\n    const xl = gd._fullLayout.xaxis;\n    const yl = gd._fullLayout.yaxis;\n    // 3D scenes have no 2D xaxis/yaxis — see zoomIn().\n    if (!xl?.range || !yl?.range) return;\n    const xc = (xl.range[0] + xl.range[1]) / 2;\n    const yc = (yl.range[0] + yl.range[1]) / 2;\n    const dx = (xl.range[1] - xl.range[0]) * 1.3;\n    const dy = (yl.range[1] - yl.range[0]) * 1.3;\n    const x0 = xc - dx / 2, x1 = xc + dx / 2;\n    const y0 = yc - dy / 2, y1 = yc + dy / 2;\n    this.zoomCoordinates = [x0, x1, y0, y1];\n    Plotly.relayout(this.plotDiv, {\n      'xaxis.range[0]': x0, 'xaxis.range[1]': x1,\n      'yaxis.range[0]': y0, 'yaxis.range[1]': y1\n    } as any);\n  }\n\n  public isStackLoading$(): Observable<boolean> {\n    return this.stackLoading$.asObservable();\n  }\n  public setStackLoading(stackLoading: boolean) {\n    this.stackLoading$.next(stackLoading);\n  }\n  public getStackLoadingProgress$(): Observable<number> {\n    return this.stackLoadingProgress$.asObservable();\n  }\n\n  // Colormap / reverse-scale / image metadata state lives in the shared\n  // VisualizerStore; these delegate, keeping only the Plotly-specific live\n  // restyle as render glue.\n  getColormapOptions() {\n    return this.store.getColormapOptions();\n  }\n  setColormap(colormap: any) {\n    this.store.setColormap(colormap);\n    try {\n      Plotly.restyle(this.plotDiv, { 'colorscale': [colormap.data.value] });\n    } catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }\n  }\n  getColormap() {\n    return this.store.getColormap();\n  }\n\n  setReverseScale(reverscale: any) {\n    this.store.setReverseScale(reverscale);\n    try {\n      Plotly.restyle(this.plotDiv, { 'reversescale': reverscale });\n    } catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }\n  }\n\n  getReverseScale() {\n    return this.store.getReverseScale();\n  }\n\n  setImageMeta(imageMeta: IImageMetadata[]) {\n    this.store.setImageMeta(imageMeta);\n  }\n\n  getImageMeta() {\n    return this.store.getImageMeta();\n  }\n\n  setShowStack(showstack: boolean) {\n    if (!showstack) {\n      this.zIndex.next(0);\n    }\n    this.imageInfo.showStack = showstack;\n    this.stackLoading$.next(showstack);\n    Plotly.relayout(this.plotDiv, { 'showstack': showstack } as any);\n  }\n\n  getAutoscaleEvent() {\n    return this.autoscaleEvent.asObservable();\n  }\n\n  getRegionUpdateEvent() {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n\n  /**\n   * Stream of the indices of currently selected regions — owned by the shared\n   * RegionStore so the selection is consistent across backends and the Region\n   * Editor table. Empty = nothing selected.\n   */\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n\n  /**\n   * Programmatically select regions (or clear with []). The shared store owns\n   * the selection state (validates/dedupes/emits); here we additionally point\n   * Plotly's `_activeShapeIndex` at the last selected shape so it gets the edit\n   * handles. No visual change to non-active shapes — Plotly's own active-shape\n   * rendering is the only highlight.\n   */\n  public setSelectedShapeIndices(indices: number[]) {\n    const valid = (indices || [])\n      .filter(i => Number.isFinite(i) && i >= 0 && i < this.shapes.length);\n    const seen = new Set<number>();\n    const cleaned: number[] = [];\n    for (const i of valid) {\n      if (!seen.has(i)) { seen.add(i); cleaned.push(i); }\n    }\n    if (this.plotDiv) {\n      const gd: any = document.getElementById(this.plotDiv);\n      if (gd?._fullLayout) {\n        gd._fullLayout._activeShapeIndex = cleaned.length > 0 ? cleaned[cleaned.length - 1] : -1;\n        try { (Plotly as any).redraw(gd); } catch { /* noop in tests */ }\n      }\n    }\n    this.regionStore.setSelectedShapeIndices(cleaned);\n  }\n\n  /**\n   * Select a specific region (IRegionStore.selectRegion). Sets the shared store\n   * selection by identity and points Plotly's active-shape at the matching\n   * rendered shape so its edit handles appear.\n   */\n  public selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n    if (this.plotDiv) {\n      const idx = this.shapes.findIndex(s => s.id === region?.id);\n      const gd: any = document.getElementById(this.plotDiv);\n      if (gd?._fullLayout && idx >= 0) {\n        gd._fullLayout._activeShapeIndex = idx;\n        try { (Plotly as any).redraw(gd); } catch { /* noop in tests */ }\n      }\n    }\n  }\n\n  /**\n   * Read Plotly's `_activeShapeIndex` and push it as the selection. Called from\n   * the relayout handler and the post-click tick — Plotly doesn't fire a\n   * dedicated active-shape event for clicks, so we sample. The store no-ops if\n   * the selection is unchanged.\n   */\n  private maybeEmitActiveShapeIndex() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    const raw = gd?._fullLayout?._activeShapeIndex;\n    const idx = (typeof raw === 'number' && raw >= 0 && raw < this.shapes.length) ? raw : -1;\n    this.regionStore.setSelectedShapeIndices(idx >= 0 ? [idx] : []);\n  }\n  setZIndex(zIndex: number) {\n    this.zIndex.next(zIndex);\n  }\n\n  getShapeColor() {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor() {\n    return this.regionStore.getFillColor();\n  }\n\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n\n  setClassificationColor(label: string, color: string) {\n    this.store.setClassificationColor(label, color);\n  }\n\n  /**\n   * Unsubscribe Subscriptions\n   */\n  unsubscribe() {\n    if (this.imageCachedSubscription) {\n      this.imageCachedSubscription.unsubscribe();\n    }\n    if (this.filenameSubscription) {\n      this.filenameSubscription.unsubscribe();\n    }\n    if (this.regionUpdateSubscription) {\n      this.regionUpdateSubscription.unsubscribe();\n    }\n    if (this.regionLiveEditSubscription) {\n      this.regionLiveEditSubscription.unsubscribe();\n    }\n    if (this.channelSub) {\n      this.channelSub.unsubscribe();\n    }\n  }\n\n  /** Live-apply the channel display window (zmin/zmax) + reverse/invert to the\n   *  heatmap. No-op when no Plotly plot is mounted (OSD owns the div). */\n  private applyChannelDisplay(channels: any[], rev: boolean, inv: boolean): void {\n    if (!this.plotDiv) return;\n    const ch = channels?.[0];\n    const colorscale = this.store.currentColormap()?.data?.value;\n    // reverse-scale and invert each flip the ramp; both together cancel.\n    const update: any = { reversescale: rev !== inv };\n    if (colorscale != null) update.colorscale = colorscale; // live colormap recolor\n    if (ch) {\n      // Surface/isosurface/scatter3d colour-map via cmin/cmax; heatmap/contour via zmin/zmax.\n      const threeD =\n        this.plotType === PlotType.ISOSURFACE ||\n        this.plotType === PlotType.SURFACE ||\n        this.plotType === PlotType.SCATTER3D;\n      if (threeD) {\n        update.cmin = ch.min;\n        update.cmax = ch.max;\n        update.cauto = false;\n      } else {\n        update.zmin = ch.min;\n        update.zmax = ch.max;\n        update.zauto = false;\n      }\n    }\n    try {\n      Plotly.restyle(this.plotDiv, update);\n    } catch {\n      /* not a colour-mapped trace, or OSD owns the div */\n    }\n  }\n\n  /** Binned intensity histogram for a channel from the cached source frames\n   *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]. */\n  getHistogram(channelIndex: number, _bins: number): IHistogram | null {\n    const frames = this.cachedImageFrames;\n    if (!frames?.length) return null;\n    const frame = frames[this.activeFrameIndex()] ?? frames[0];\n    if (!frame?.length) return null;\n    const counts = new Array(256).fill(0);\n    for (const row of frame) {\n      if (!row) continue;\n      for (const cell of row) {\n        let v: number;\n        if (Array.isArray(cell)) {\n          v = channelIndex >= 0 && channelIndex < cell.length\n            ? cell[channelIndex]\n            : Math.round(bt601Luminance(cell[0], cell[1], cell[2]));\n        } else {\n          v = cell;\n        }\n        v = v | 0;\n        if (v < 0) v = 0; else if (v > 255) v = 255;\n        counts[v]++;\n      }\n    }\n    return histogram256(counts);\n  }\n\n  /** Async histogram stream — Plotly renders heatmap frame data (already in\n   *  memory, 8-bit luminance), so this just wraps the synchronous 8-bit\n   *  histogram. Native 16-bit histograms only apply to the OSD tile path. */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return of(this.getHistogram(channelIndex, bins));\n  }\n\n  /** Data export (16-bit TIFF) is an OSD-tile-path feature backed by the server.\n   *  Plotly renders heatmaps from frame data, so there's nothing to export here. */\n  exportData(): void {\n    console.warn('[plotly] 16-bit data export is not available for the heatmap backend.');\n  }\n\n  importRegions(geoJsonStr: string): Region[] {\n    return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);\n  }\n\n  exportRegions(regions: Region[]) {\n    const jsonString = this.plotUtilities.exportROIsToGeoJson(regions);\n    this.plotUtilities.saveToFile(jsonString, this.fileName);\n  }\n\n  getGeoJsonString(regions: Region[]): string {\n    return this.plotUtilities.exportROIsToGeoJson(regions);\n  }\n\n  getStackLoadingProgress() {\n    return this.getStackLoadingProgress$();\n  }\n\n  isStackLoading() {\n    return this.isStackLoading$();\n  }\n\n}\n"]}