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

package/esm2022/lib/implementations/plotly/plotly-layouts.mjs

@@ -0,0 +1,121 @@
+/**
+ * Plotly layout builders for every plot type the Plotly backend renders. Pure:
+ * the live service state they need (screen height, aspect lock, drag mode, the
+ * current region shapes and colours) comes in through {@link ImageLayoutContext}.
+ */
+/** One slider step per z-plane, each showing only its own trace. */
+export function sliderSteps(sliceCount) {
+    const steps = [];
+    for (let i = 0; i < sliceCount; i++) {
+        steps.push({
+            label: i + 1,
+            method: 'restyle',
+            args: [
+                'visible',
+                Array(sliceCount)
+                    .fill(false)
+                    .fill(true, i, i + 1),
+            ],
+        });
+    }
+    return steps;
+}
+/** Image axes over `xRange`/`yRange` (pass the y range reversed for an image). */
+function imageAxes(ctx, xRange, yRange) {
+    return {
+        xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },
+        yaxis: {
+            constrain: 'range',
+            constraintoward: 'center',
+            range: yRange,
+            ticks: '',
+            ticksuffix: '  ',
+            // autorange off so that Plotly does not overwrite the range for the y axis
+            autorange: false,
+            scaleanchor: ctx.scaleratio ? 'x' : false,
+        },
+    };
+}
+/** The heatmap / RGB image layout: image axes, the z-plane slider, the region shapes. */
+export function heatmapLayout(ctx, xRange, yRange, sliceCount) {
+    return {
+        ...imageAxes(ctx, xRange, yRange),
+        margin: { t: 30, b: 5, l: 55, r: 5 },
+        height: ctx.screenHeight,
+        sliders: [
+            {
+                pad: { t: 50 },
+                currentvalue: { visible: true, prefix: 'Z-plane:', xanchor: 'right' },
+                steps: sliderSteps(sliceCount),
+            },
+        ],
+        autosize: true,
+        shapes: ctx.shapes,
+        activeshape: { fillcolor: ctx.fillColor },
+        dragmode: ctx.dragMode ? ctx.dragMode : false,
+        newshape: { line: { color: ctx.shapeColor, width: 3 } },
+    };
+}
+/** Image-aligned 2D axes without the z-plane slider (region scatter). */
+export function overlayLayout(ctx, xRange, yRange) {
+    return {
+        ...imageAxes(ctx, xRange, yRange),
+        margin: { t: 30, b: 5, l: 55, r: 5 },
+        height: ctx.screenHeight,
+        autosize: true,
+        shapes: ctx.shapes,
+        dragmode: ctx.dragMode ? ctx.dragMode : false,
+    };
+}
+/** Plain 2D chart axes (intensity profile / line plots). */
+export function chartLayout(screenHeight) {
+    return {
+        margin: { t: 30, b: 45, l: 60, r: 20 },
+        height: screenHeight,
+        autosize: true,
+        xaxis: { title: 'Position (px)' },
+        yaxis: { title: 'Intensity' },
+        dragmode: false,
+    };
+}
+/** 3D scene for volumetric plot types (scatter3d, isosurface). */
+export function volumeLayout(screenHeight) {
+    return {
+        margin: { t: 0, b: 0, l: 0, r: 0 },
+        height: 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',
+        },
+    };
+}
+/**
+ * Scene layout for the surface plot: light-grey axis planes and a manual
+ * aspect ratio whose z extent is `zRatio` of the x/y extent.
+ */
+export function surfaceLayout(zRatio) {
+    const plane = {
+        gridcolor: 'rgb(255, 255, 255)',
+        zerolinecolor: 'rgb(255, 255, 255)',
+        showbackground: true,
+        backgroundcolor: 'rgb(230, 230,230)',
+    };
+    return {
+        margin: { t: 0, b: 0, l: 0, r: 0 },
+        scene: {
+            xaxis: { ...plane },
+            yaxis: { ...plane, backgroundcolor: 'rgb(230, 230, 230)' },
+            zaxis: { ...plane },
+            aspectratio: { x: 1, y: 1, z: zRatio },
+            aspectmode: 'manual',
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-layouts.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-layouts.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Plotly layout builders for every plot type the Plotly backend renders. Pure:\n * the live service state they need (screen height, aspect lock, drag mode, the\n * current region shapes and colours) comes in through {@link ImageLayoutContext}.\n */\n\n/** Plotly shape dicts, as `layout.shapes` takes them. */\nexport type PlotlyShapeDict = Record<string, unknown>;\n\n/** The service state an image-aligned layout depends on. */\nexport interface ImageLayoutContext {\n  screenHeight: number;\n  /** Lock the y axis to x (square image pixels). */\n  scaleratio: boolean;\n  /** The active Plotly drag mode, or '' for none. */\n  dragMode: string;\n  /** The region shapes to draw over the image. */\n  shapes: PlotlyShapeDict[];\n  /** The active (selected) shape's fill colour. */\n  fillColor: string;\n  /** The outline colour of a newly drawn shape. */\n  shapeColor: string;\n}\n\n/** One slider step per z-plane, each showing only its own trace. */\nexport function sliderSteps(sliceCount: number): Array<{ label: number; method: string; args: unknown[] }> {\n  const steps = [];\n  for (let i = 0; i < sliceCount; i++) {\n    steps.push({\n      label: i + 1,\n      method: 'restyle',\n      args: [\n        'visible',\n        Array(sliceCount)\n          .fill(false)\n          .fill(true, i, i + 1),\n      ],\n    });\n  }\n  return steps;\n}\n\n/** Image axes over `xRange`/`yRange` (pass the y range reversed for an image). */\nfunction imageAxes(ctx: ImageLayoutContext, xRange: number[], yRange: number[]) {\n  return {\n    xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },\n    yaxis: {\n      constrain: 'range',\n      constraintoward: 'center',\n      range: yRange,\n      ticks: '',\n      ticksuffix: '  ',\n      // autorange off so that Plotly does not overwrite the range for the y axis\n      autorange: false,\n      scaleanchor: ctx.scaleratio ? 'x' : false,\n    },\n  };\n}\n\n/** The heatmap / RGB image layout: image axes, the z-plane slider, the region shapes. */\nexport function heatmapLayout(ctx: ImageLayoutContext, xRange: number[], yRange: number[], sliceCount: number) {\n  return {\n    ...imageAxes(ctx, xRange, yRange),\n    margin: { t: 30, b: 5, l: 55, r: 5 },\n    height: ctx.screenHeight,\n    sliders: [\n      {\n        pad: { t: 50 },\n        currentvalue: { visible: true, prefix: 'Z-plane:', xanchor: 'right' },\n        steps: sliderSteps(sliceCount),\n      },\n    ],\n    autosize: true,\n    shapes: ctx.shapes,\n    activeshape: { fillcolor: ctx.fillColor },\n    dragmode: ctx.dragMode ? ctx.dragMode : false,\n    newshape: { line: { color: ctx.shapeColor, width: 3 } },\n  };\n}\n\n/** Image-aligned 2D axes without the z-plane slider (region scatter). */\nexport function overlayLayout(ctx: ImageLayoutContext, xRange: number[], yRange: number[]) {\n  return {\n    ...imageAxes(ctx, xRange, yRange),\n    margin: { t: 30, b: 5, l: 55, r: 5 },\n    height: ctx.screenHeight,\n    autosize: true,\n    shapes: ctx.shapes,\n    dragmode: ctx.dragMode ? ctx.dragMode : false,\n  };\n}\n\n/** Plain 2D chart axes (intensity profile / line plots). */\nexport function chartLayout(screenHeight: number) {\n  return {\n    margin: { t: 30, b: 45, l: 60, r: 20 },\n    height: screenHeight,\n    autosize: true,\n    xaxis: { title: 'Position (px)' },\n    yaxis: { title: 'Intensity' },\n    dragmode: false,\n  };\n}\n\n/** 3D scene for volumetric plot types (scatter3d, isosurface). */\nexport function volumeLayout(screenHeight: number) {\n  return {\n    margin: { t: 0, b: 0, l: 0, r: 0 },\n    height: 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/**\n * Scene layout for the surface plot: light-grey axis planes and a manual\n * aspect ratio whose z extent is `zRatio` of the x/y extent.\n */\nexport function surfaceLayout(zRatio: number) {\n  const plane = {\n    gridcolor: 'rgb(255, 255, 255)',\n    zerolinecolor: 'rgb(255, 255, 255)',\n    showbackground: true,\n    backgroundcolor: 'rgb(230, 230,230)',\n  };\n  return {\n    margin: { t: 0, b: 0, l: 0, r: 0 },\n    scene: {\n      xaxis: { ...plane },\n      yaxis: { ...plane, backgroundcolor: 'rgb(230, 230, 230)' },\n      zaxis: { ...plane },\n      aspectratio: { x: 1, y: 1, z: zRatio },\n      aspectmode: 'manual',\n    },\n  };\n}\n"]}

package/esm2022/lib/implementations/plotly/plotly-readback.mjs

@@ -0,0 +1,117 @@
+import { bt601Luminance, histogram256 } from '../../contracts/intensity';
+import { PlotType } from '../../contracts/plot-type';
+/**
+ * Pure reads of what the Plotly backend has on screen or in memory: a trace's
+ * pixels, a frame's histogram, the image rect the axes show, and the restyle
+ * that applies the channel display state.
+ */
+/** A plotted trace's `z` grid as flat pixels: an RGB `image` trace keeps its
+ *  channels (3 or 4), a heatmap is one rounded channel. Null when empty. */
+export function tracePixels(trace) {
+    const zData = trace?.z;
+    if (!zData)
+        return null;
+    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 };
+    }
+    // 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 };
+}
+/** 256-bin histogram of one channel of a frame (raw, pre-LUT). Grayscale cells
+ *  are numbers; RGB cells `[r,g,b]` give channel `channelIndex`, or the BT.601
+ *  luminance for an index past their channels. */
+export function frameHistogram(frame, channelIndex) {
+    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);
+}
+/** 256-bin histogram of a one-byte-per-pixel plane (a channel's raw pixels). */
+export function planeHistogram(plane) {
+    const counts = new Array(256).fill(0);
+    for (let i = 0; i < plane.length; i++)
+        counts[plane[i]]++;
+    return histogram256(counts);
+}
+/**
+ * The image rect the plot shows, from the live axis ranges — after a high-def
+ * zoom the axes are relaid out to the crop's bounds, so the ranges ARE the
+ * crop — else the whole image `[x0, x1, y0, y1]`, else null.
+ */
+export function axesSourceRect(xr, yr, trueImgSize) {
+    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 (!trueImgSize)
+        return null;
+    return {
+        x: trueImgSize[0],
+        y: trueImgSize[2],
+        width: trueImgSize[1] - trueImgSize[0],
+        height: trueImgSize[3] - trueImgSize[2],
+    };
+}
+/**
+ * The restyle that live-applies the channel display: the colour scale, reverse
+ * (reverse-scale and invert each flip the ramp; both together cancel) and the
+ * Intensity channel's window — cmin/cmax for the 3D plot types, zmin/zmax for
+ * heatmap/contour. A trace without a colour scale ignores these attributes.
+ */
+export function channelDisplayRestyle(channels, reverse, invert, colorscale, plotType) {
+    const update = { reversescale: reverse !== invert };
+    if (colorscale != null)
+        update['colorscale'] = colorscale;
+    const ch = channels?.[0];
+    if (ch) {
+        const threeD = plotType === PlotType.ISOSURFACE || plotType === PlotType.SURFACE || plotType === PlotType.SCATTER3D;
+        if (threeD)
+            Object.assign(update, { cmin: ch.min, cmax: ch.max, cauto: false });
+        else
+            Object.assign(update, { zmin: ch.min, zmax: ch.max, zauto: false });
+    }
+    return update;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-readback.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-readback.ts"],"names":[],"mappings":"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","sourcesContent":["import { bt601Luminance, histogram256 } from '../../contracts/intensity';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { PixelData } from '../../contracts/visualizer.contract';\nimport { PlotType } from '../../contracts/plot-type';\nimport { IChannelState } from '../../contracts/channel-histogram-api.contract';\n\n/**\n * Pure reads of what the Plotly backend has on screen or in memory: a trace's\n * pixels, a frame's histogram, the image rect the axes show, and the restyle\n * that applies the channel display state.\n */\n\n/** A plotted trace's `z` grid as flat pixels: an RGB `image` trace keeps its\n *  channels (3 or 4), a heatmap is one rounded channel. Null when empty. */\nexport function tracePixels(trace: { type?: string; z?: any[][] } | undefined): PixelData | null {\n  const zData = trace?.z;\n  if (!zData) return null;\n  const height = zData.length;\n  if (height === 0) return null;\n  const width = zData[0].length;\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++) data[offset + c] = pixel[c];\n      }\n    }\n    return { width, height, channels, data };\n  }\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++) data[y * width + x] = Math.round(zData[y][x]);\n  }\n  return { width, height, channels: 1, data };\n}\n\n/** 256-bin histogram of one channel of a frame (raw, pre-LUT). Grayscale cells\n *  are numbers; RGB cells `[r,g,b]` give channel `channelIndex`, or the BT.601\n *  luminance for an index past their channels. */\nexport function frameHistogram(frame: any[], channelIndex: number): IHistogram {\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 =\n          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;\n      else if (v > 255) v = 255;\n      counts[v]++;\n    }\n  }\n  return histogram256(counts);\n}\n\n/** 256-bin histogram of a one-byte-per-pixel plane (a channel's raw pixels). */\nexport function planeHistogram(plane: ArrayLike<number>): IHistogram {\n  const counts = new Array(256).fill(0);\n  for (let i = 0; i < plane.length; i++) counts[plane[i]]++;\n  return histogram256(counts);\n}\n\ntype Rect = { x: number; y: number; width: number; height: number };\n\n/**\n * The image rect the plot shows, from the live axis ranges — after a high-def\n * zoom the axes are relaid out to the crop's bounds, so the ranges ARE the\n * crop — else the whole image `[x0, x1, y0, y1]`, else null.\n */\nexport function axesSourceRect(\n  xr: number[] | undefined,\n  yr: number[] | undefined,\n  trueImgSize: number[] | undefined,\n): Rect | null {\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 (!trueImgSize) return null;\n  return {\n    x: trueImgSize[0],\n    y: trueImgSize[2],\n    width: trueImgSize[1] - trueImgSize[0],\n    height: trueImgSize[3] - trueImgSize[2],\n  };\n}\n\n/**\n * The restyle that live-applies the channel display: the colour scale, reverse\n * (reverse-scale and invert each flip the ramp; both together cancel) and the\n * Intensity channel's window — cmin/cmax for the 3D plot types, zmin/zmax for\n * heatmap/contour. A trace without a colour scale ignores these attributes.\n */\nexport function channelDisplayRestyle(\n  channels: IChannelState[],\n  reverse: boolean,\n  invert: boolean,\n  colorscale: unknown,\n  plotType: PlotType,\n): Record<string, unknown> {\n  const update: Record<string, unknown> = { reversescale: reverse !== invert };\n  if (colorscale != null) update['colorscale'] = colorscale;\n  const ch = channels?.[0];\n  if (ch) {\n    const threeD =\n      plotType === PlotType.ISOSURFACE || plotType === PlotType.SURFACE || plotType === PlotType.SCATTER3D;\n    if (threeD) Object.assign(update, { cmin: ch.min, cmax: ch.max, cauto: false });\n    else Object.assign(update, { zmin: ch.min, zmax: ch.max, zauto: false });\n  }\n  return update;\n}\n"]}

package/esm2022/lib/implementations/plotly/plotly-region-overlay.mjs

@@ -16,16 +16,25 @@ export class PlotlyRegionOverlay {
     setMode(mode) {
         // 'select' is a neutral mode for Plotly (no drag mode); region selection is
         // driven by the table / active-shape sampling, so just clear the drag mode.
-        const dragMode = mode === 'drawrect' ? 'drawrect' :
-            mode === 'drawclosedpath' ? 'drawclosedpath' :
-                mode === 'drawopenpath' ? 'drawopenpath' :
-                    false;
+        const dragMode = mode === 'drawrect'
+            ? 'drawrect'
+            : mode === 'drawclosedpath'
+                ? 'drawclosedpath'
+                : mode === 'drawopenpath'
+                    ? 'drawopenpath'
+                    : false;
         this.plotly.setDragMode(dragMode);
     }
-    redraw() { }
-    /** Bezier regions are an OpenSeadragon-only feature (Plotly has no native
-     *  curved-shape rendering), so this is a no-op here. */
-    setSelectedBezier(_bezier) { }
-    destroy() { }
+    redraw() {
+        /* Plotly re-renders its shapes natively on relayout */
+    }
+    /** Bezier regions are drawn by the SVG overlays (OpenSeadragon, napari-js);
+     *  Plotly has no native curved-shape rendering, so this is a no-op here. */
+    setSelectedBezier(_bezier) {
+        /* not rendered by Plotly */
+    }
+    destroy() {
+        /* nothing to tear down — shapes live in the Plotly layout */
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/plotly/plotly-shape-projection.mjs

@@ -0,0 +1,223 @@
+import * as Plotly from 'plotly.js-dist-min';
+import { Subscription } from 'rxjs';
+import { ShapeSelection } from '../../models/shape';
+import { PlotUtilities } from '../../plot.utilities';
+/**
+ * Plotly's render projection of the shared RegionStore: `shapes` is the dict
+ * array `Plotly.relayout` consumes, kept beside the store. Shapes edited or
+ * drawn on the Plotly canvas are mirrored INTO the store ({@link commitToStore});
+ * every other change — wherever it was made — arrives as a store update event
+ * and is projected back OUT and redrawn ({@link connect}). Also maps the store's
+ * selection onto Plotly's `_activeShapeIndex` (the shape with the edit handles)
+ * and back.
+ */
+export class PlotlyShapeProjection {
+    constructor(host, regionStore) {
+        this.host = host;
+        this.regionStore = regionStore;
+        /** The render projection: one Plotly shape dict per store region. */
+        this.shapes = [];
+        /** Nesting depth of {@link quietly}: region updates are not redrawn while > 0. */
+        this.muted = 0;
+        this.utils = new PlotUtilities();
+    }
+    /** The plot div, live Plotly graph or not (null when none is set). */
+    gd() {
+        const id = this.host.plotDiv();
+        return id ? document.getElementById(id) : null;
+    }
+    /** The plot div while it hosts a live Plotly graph, else null: the div stays
+     *  set after it was handed to another backend, and Plotly throws on it then. */
+    liveGd() {
+        const gd = this.gd();
+        return gd?._fullLayout ? gd : null;
+    }
+    /** Rebuild the dict working-set from the store (after an image switch, or when
+     *  regions changed while another backend was rendering). */
+    syncFromStore() {
+        const showLabel = this.regionStore.getShowShapeLabel();
+        this.shapes = this.regionStore.getRegions().map((r) => {
+            r.filename = this.host.fileName();
+            return { ...r.getShape(showLabel) };
+        });
+    }
+    /**
+     * Make the shared store authoritative for the current dict working-set: convert
+     * the dicts 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.
+     */
+    commitToStore() {
+        const regions = this.shapes.map((s) => Object.assign(new ShapeSelection(), s).getRegion());
+        // The canvas already shows these shapes: don't redraw them from the update.
+        this.quietly(() => 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;
+        }
+    }
+    /**
+     * Apply a `plotly_relayout` event's shape part: in-place edits
+     * (`shapes[i].x0`, `shapes[i].path`, …, rounded to whole pixels) and a shape
+     * drawn natively on the canvas (a lone `shapes` key — snapped, tagged with
+     * the file and, when labels are on, a label object), mirrored into the store.
+     */
+    applyRelayout(event) {
+        let shapesModified = false;
+        for (const key of Object.keys(event)) {
+            if (!key.startsWith('shapes['))
+                continue;
+            const shapeNumber = +key.split('[')[1].split(']')[0];
+            const shapeChange = key.split('.')[1];
+            if (this.shapes && this.shapes[shapeNumber]) {
+                this.shapes[shapeNumber][shapeChange] =
+                    shapeChange === 'path' ? this.utils.roundPathCoordinates(event[key]) : Math.round(+event[key]);
+                shapesModified = true;
+            }
+        }
+        if (shapesModified)
+            this.commitToStore();
+        if (Object.keys(event).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.host.fileName();
+                this.shapes[i] = this.utils.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.commitToStore();
+        }
+    }
+    /** Push the dict working-set to Plotly (a no-op when another backend owns the div). */
+    render() {
+        const gd = this.liveGd();
+        if (!gd)
+            return;
+        void Plotly.relayout(gd, this.relayoutPayload(this.shapes.map((s) => ({ ...s }))));
+    }
+    /** The shapes of the image on screen, labelled (or not) for display, as fresh dicts. */
+    shapesToRedraw(showLabel = this.regionStore.getShowShapeLabel()) {
+        const shapesToRedraw = [];
+        for (const shape of this.shapes) {
+            if (JSON.stringify(shape.fileName) === JSON.stringify(this.host.fileName())) {
+                shape.label = showLabel
+                    ? {
+                        text: `${shape.legend}`,
+                        texttemplate: `${shape.legend}`,
+                        textposition: 'top left',
+                        font: { color: `${shape.line.color}` },
+                    }
+                    : {};
+                shapesToRedraw.push(shape);
+            }
+        }
+        // convert to dict so that plotly recognises the shapes
+        return shapesToRedraw.map((s) => ({ ...s }));
+    }
+    /**
+     * Follow the shared store: redraw the shapes on every region update and move
+     * the edit handles on every selection change, whoever made the change (the
+     * router, an undo, the Region Editor, another backend's overlay, a canvas
+     * tool). Plotly is not on the store's write path any more — it listens, like
+     * the OpenSeadragon and napari-js overlays do. Service-lifetime: both
+     * callbacks no-op while no live Plotly graph holds the div.
+     */
+    connect() {
+        const subs = new Subscription();
+        subs.add(this.regionStore.getRegionUpdateEvent().subscribe((regions) => this.onRegionUpdate(regions)));
+        subs.add(this.regionStore.getSelectedShapeIndices$().subscribe((indices) => this.onSelection(indices)));
+        return subs;
+    }
+    /**
+     * Run `write` — a store write this projection already reflects (a shape edited
+     * on the canvas, an image switch the next plot draws) — without redrawing from
+     * the update event it causes.
+     */
+    quietly(write) {
+        this.muted++;
+        try {
+            write();
+        }
+        finally {
+            this.muted--;
+        }
+    }
+    /**
+     * A region update. The stored set re-projects and redraws; a transient set
+     * (`setRegions(…, isRegionSaveOn = false)`, which the store emits without
+     * storing) is drawn as-is and leaves the working-set alone.
+     */
+    onRegionUpdate(regions) {
+        if (this.muted > 0)
+            return;
+        const stored = this.regionStore.getRegions();
+        const isStored = regions.length === stored.length && regions.every((r, i) => r === stored[i]);
+        if (isStored) {
+            this.syncFromStore();
+            this.render();
+            return;
+        }
+        const gd = this.liveGd();
+        if (!gd)
+            return;
+        const showLabel = this.regionStore.getShowShapeLabel();
+        const dicts = regions.map((r) => {
+            r.filename = this.host.fileName();
+            return { ...r.getShape(showLabel) };
+        });
+        void Plotly.relayout(gd, this.relayoutPayload(dicts));
+    }
+    /**
+     * A selection change: Plotly's `_activeShapeIndex` points at the last selected
+     * shape so it gets the edit handles (Plotly's own active-shape rendering is the
+     * only highlight). Skipped when the plot already shows it — the change came
+     * from a click on the plot ({@link syncSelectionFromPlot}).
+     */
+    onSelection(indices) {
+        const gd = this.liveGd();
+        if (!gd)
+            return;
+        const active = indices.length > 0 ? indices[indices.length - 1] : -1;
+        if ((gd._fullLayout._activeShapeIndex ?? -1) === active)
+            return;
+        gd._fullLayout._activeShapeIndex = active;
+        try {
+            void Plotly.redraw(gd);
+        }
+        catch {
+            /* noop in tests */
+        }
+    }
+    /**
+     * Read Plotly's `_activeShapeIndex` and push it as the selection. Plotly fires
+     * no dedicated active-shape event for clicks, so this is sampled after a
+     * relayout and a click. The store no-ops when the selection is unchanged.
+     */
+    syncSelectionFromPlot() {
+        if (!this.host.plotDiv())
+            return;
+        const raw = this.gd()?._fullLayout?._activeShapeIndex;
+        const idx = typeof raw === 'number' && raw >= 0 && raw < this.shapes.length ? raw : -1;
+        this.regionStore.setSelectedShapeIndices(idx >= 0 ? [idx] : []);
+    }
+    /** The shapes-relayout payload: the shapes plus the active-shape fill colour. */
+    relayoutPayload(shapeDicts) {
+        return { shapes: shapeDicts, activeshape: { fillcolor: this.regionStore.getFillColor() } };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-shape-projection.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-shape-projection.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Plotly from 'plotly.js-dist-min';\nimport { Subscription } from 'rxjs';\n\nimport { Region } from '../../models/region';\nimport { ShapeSelection } from '../../models/shape';\nimport { RegionStore } from '../../store/region-store.service';\nimport { PlotUtilities } from '../../plot.utilities';\n\n/** A Plotly graph div, as far as the projection reads it. */\ntype GraphDiv = HTMLElement & { _fullLayout?: { _activeShapeIndex?: number } };\n\n/** The service state the projection reads. */\nexport interface ShapeProjectionHost {\n  /** The plot div's id ('' before the first plot); it may be another backend's now. */\n  plotDiv(): string;\n  /** The image on screen (shapes are tagged with it). */\n  fileName(): string | undefined;\n}\n\n/**\n * Plotly's render projection of the shared RegionStore: `shapes` is the dict\n * array `Plotly.relayout` consumes, kept beside the store. Shapes edited or\n * drawn on the Plotly canvas are mirrored INTO the store ({@link commitToStore});\n * every other change — wherever it was made — arrives as a store update event\n * and is projected back OUT and redrawn ({@link connect}). Also maps the store's\n * selection onto Plotly's `_activeShapeIndex` (the shape with the edit handles)\n * and back.\n */\nexport class PlotlyShapeProjection {\n  /** The render projection: one Plotly shape dict per store region. */\n  shapes: any[] = [];\n  /** Nesting depth of {@link quietly}: region updates are not redrawn while > 0. */\n  private muted = 0;\n  private readonly utils = new PlotUtilities();\n\n  constructor(\n    private readonly host: ShapeProjectionHost,\n    private readonly regionStore: RegionStore,\n  ) {}\n\n  /** The plot div, live Plotly graph or not (null when none is set). */\n  private gd(): GraphDiv | null {\n    const id = this.host.plotDiv();\n    return id ? (document.getElementById(id) as GraphDiv | null) : null;\n  }\n\n  /** The plot div while it hosts a live Plotly graph, else null: the div stays\n   *  set after it was handed to another backend, and Plotly throws on it then. */\n  private liveGd(): GraphDiv | null {\n    const gd = this.gd();\n    return gd?._fullLayout ? gd : null;\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  syncFromStore(): void {\n    const showLabel = this.regionStore.getShowShapeLabel();\n    this.shapes = this.regionStore.getRegions().map((r) => {\n      r.filename = this.host.fileName();\n      return { ...r.getShape(showLabel) };\n    });\n  }\n\n  /**\n   * Make the shared store authoritative for the current dict working-set: convert\n   * the dicts to neutral regions and replace the store's list (the store mints\n   * 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  commitToStore(): void {\n    const regions = this.shapes.map((s) => Object.assign(new ShapeSelection(), s).getRegion());\n    // The canvas already shows these shapes: don't redraw them from the update.\n    this.quietly(() =>\n      this.regionStore.setRegions(\n        regions,\n        this.regionStore.getShowShapeLabel(),\n        true,\n        this.regionStore.getFillColor(),\n        false,\n      ),\n    );\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   * Apply a `plotly_relayout` event's shape part: in-place edits\n   * (`shapes[i].x0`, `shapes[i].path`, …, rounded to whole pixels) and a shape\n   * drawn natively on the canvas (a lone `shapes` key — snapped, tagged with\n   * the file and, when labels are on, a label object), mirrored into the store.\n   */\n  applyRelayout(event: Record<string, any>): void {\n    let shapesModified = false;\n    for (const key of Object.keys(event)) {\n      if (!key.startsWith('shapes[')) continue;\n      const shapeNumber = +key.split('[')[1].split(']')[0];\n      const shapeChange = key.split('.')[1];\n      if (this.shapes && this.shapes[shapeNumber]) {\n        this.shapes[shapeNumber][shapeChange] =\n          shapeChange === 'path' ? this.utils.roundPathCoordinates(event[key]) : Math.round(+event[key]);\n        shapesModified = true;\n      }\n    }\n    if (shapesModified) this.commitToStore();\n    if (Object.keys(event).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.host.fileName();\n        this.shapes[i] = this.utils.snapRegion(this.shapes[i]);\n        if (isNew && this.regionStore.getShowShapeLabel()) {\n          this.shapes[i].label = {\n            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.commitToStore();\n    }\n  }\n\n  /** Push the dict working-set to Plotly (a no-op when another backend owns the div). */\n  render(): void {\n    const gd = this.liveGd();\n    if (!gd) return;\n    void Plotly.relayout(gd, this.relayoutPayload(this.shapes.map((s) => ({ ...s }))) as Plotly.Layout);\n  }\n\n  /** The shapes of the image on screen, labelled (or not) for display, as fresh dicts. */\n  shapesToRedraw(showLabel = this.regionStore.getShowShapeLabel()): any[] {\n    const shapesToRedraw: ShapeSelection[] = [];\n    for (const shape of this.shapes) {\n      if (JSON.stringify(shape.fileName) === JSON.stringify(this.host.fileName())) {\n        shape.label = showLabel\n          ? {\n              text: `${shape.legend}`,\n              texttemplate: `${shape.legend}`,\n              textposition: 'top left',\n              font: { color: `${shape.line.color}` },\n            }\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  /**\n   * Follow the shared store: redraw the shapes on every region update and move\n   * the edit handles on every selection change, whoever made the change (the\n   * router, an undo, the Region Editor, another backend's overlay, a canvas\n   * tool). Plotly is not on the store's write path any more — it listens, like\n   * the OpenSeadragon and napari-js overlays do. Service-lifetime: both\n   * callbacks no-op while no live Plotly graph holds the div.\n   */\n  connect(): Subscription {\n    const subs = new Subscription();\n    subs.add(this.regionStore.getRegionUpdateEvent().subscribe((regions) => this.onRegionUpdate(regions)));\n    subs.add(this.regionStore.getSelectedShapeIndices$().subscribe((indices) => this.onSelection(indices)));\n    return subs;\n  }\n\n  /**\n   * Run `write` — a store write this projection already reflects (a shape edited\n   * on the canvas, an image switch the next plot draws) — without redrawing from\n   * the update event it causes.\n   */\n  quietly(write: () => void): void {\n    this.muted++;\n    try {\n      write();\n    } finally {\n      this.muted--;\n    }\n  }\n\n  /**\n   * A region update. The stored set re-projects and redraws; a transient set\n   * (`setRegions(…, isRegionSaveOn = false)`, which the store emits without\n   * storing) is drawn as-is and leaves the working-set alone.\n   */\n  private onRegionUpdate(regions: Region[]): void {\n    if (this.muted > 0) return;\n    const stored = this.regionStore.getRegions();\n    const isStored = regions.length === stored.length && regions.every((r, i) => r === stored[i]);\n    if (isStored) {\n      this.syncFromStore();\n      this.render();\n      return;\n    }\n    const gd = this.liveGd();\n    if (!gd) return;\n    const showLabel = this.regionStore.getShowShapeLabel();\n    const dicts = regions.map((r) => {\n      r.filename = this.host.fileName();\n      return { ...r.getShape(showLabel) };\n    });\n    void Plotly.relayout(gd, this.relayoutPayload(dicts) as Plotly.Layout);\n  }\n\n  /**\n   * A selection change: Plotly's `_activeShapeIndex` points at the last selected\n   * shape so it gets the edit handles (Plotly's own active-shape rendering is the\n   * only highlight). Skipped when the plot already shows it — the change came\n   * from a click on the plot ({@link syncSelectionFromPlot}).\n   */\n  private onSelection(indices: number[]): void {\n    const gd = this.liveGd();\n    if (!gd) return;\n    const active = indices.length > 0 ? indices[indices.length - 1] : -1;\n    if ((gd._fullLayout!._activeShapeIndex ?? -1) === active) return;\n    gd._fullLayout!._activeShapeIndex = active;\n    try {\n      void Plotly.redraw(gd);\n    } catch {\n      /* noop in tests */\n    }\n  }\n\n  /**\n   * Read Plotly's `_activeShapeIndex` and push it as the selection. Plotly fires\n   * no dedicated active-shape event for clicks, so this is sampled after a\n   * relayout and a click. The store no-ops when the selection is unchanged.\n   */\n  syncSelectionFromPlot(): void {\n    if (!this.host.plotDiv()) return;\n    const raw = this.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\n  /** The shapes-relayout payload: the shapes plus the active-shape fill colour. */\n  private relayoutPayload(shapeDicts: any[]): Record<string, unknown> {\n    return { shapes: shapeDicts, activeshape: { fillcolor: this.regionStore.getFillColor() } };\n  }\n}\n"]}