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

package/esm2022/lib/implementations/plotly/plotly-coordinate-transform.mjs

@@ -0,0 +1,37 @@
+/**
+ * Plotly implementation of {@link ICoordinateTransform}. Wraps the axis objects
+ * on the plot's `_fullLayout`. This is the exact math the wand / vertex-eraser
+ * used inline before they were decoupled — lifted here verbatim so Plotly
+ * behaviour is unchanged.
+ */
+export class PlotlyCoordinateTransform {
+    constructor(getGraphDiv, getContainer) {
+        this.getGraphDiv = getGraphDiv;
+        this.getContainer = getContainer;
+    }
+    axes() {
+        const layout = this.getGraphDiv()?._fullLayout;
+        return { xaxis: layout?.xaxis, yaxis: layout?.yaxis };
+    }
+    isReady() {
+        const { xaxis, yaxis } = this.axes();
+        return !!(xaxis && yaxis);
+    }
+    clientToData(clientX, clientY) {
+        const { xaxis, yaxis } = this.axes();
+        const rect = this.getContainer()?.getBoundingClientRect();
+        if (!xaxis || !yaxis || !rect)
+            return { x: NaN, y: NaN };
+        return {
+            x: xaxis.p2d(clientX - rect.left - xaxis._offset),
+            y: yaxis.p2d(clientY - rect.top - yaxis._offset),
+        };
+    }
+    dataLengthToScreen(dataLength) {
+        const { xaxis } = this.axes();
+        if (!xaxis)
+            return 0;
+        return Math.abs(xaxis.l2p(dataLength) - xaxis.l2p(0));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,31 @@
+/**
+ * Plotly implementation of {@link IRegionOverlay}.
+ *
+ * Plotly renders region shapes natively in its plot layout and edits them via
+ * its own drag modes, so this adapter is thin: it maps the neutral
+ * {@link RegionToolMode} onto Plotly drag modes and lets Plotly draw. `redraw`
+ * is a no-op because Plotly re-renders its shapes itself on relayout.
+ *
+ * It is the symmetric counterpart to {@link OsdRegionOverlay}: both render the
+ * same shared `IRegionStore`, each onto its own backend's canvas.
+ */
+export class PlotlyRegionOverlay {
+    constructor(plotly) {
+        this.plotly = plotly;
+    }
+    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;
+        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() { }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/implementations/plotly/plotly-trace-builders.mjs

@@ -0,0 +1,183 @@
+import { PlotType } from '../../contracts/plot-type';
+import { bt601Luminance } from '../../contracts/intensity';
+// ── helpers ──────────────────────────────────────────────────────────────
+/** Scalar value of a frame cell: `[r, g, b]` → BT.601 luminance, scalar as-is. */
+function luminance(cell) {
+    if (Array.isArray(cell)) {
+        return bt601Luminance(cell[0], cell[1], cell[2]);
+    }
+    return cell;
+}
+/** Project a frame to a scalar matrix (RGB → luminance, grayscale → as-is). */
+function toScalarFrame(frame, isGrayscale) {
+    if (isGrayscale)
+        return frame;
+    return frame.map((row) => row.map(luminance));
+}
+/** Even stride that keeps an axis under `maxSamples` sample points. */
+function strideFor(length, maxSamples) {
+    return Math.max(1, Math.ceil(length / maxSamples));
+}
+// ── builders ─────────────────────────────────────────────────────────────
+/** Max cells per axis the contour grid is downsampled to. The heatmap trace can
+ *  raster the full preview cheaply, but contour runs CPU marching-squares over
+ *  every cell, so a full-resolution preview (~1000²) costs seconds. Contours
+ *  interpolate, so a coarser grid looks the same while rendering near-instantly. */
+const CONTOUR_MAX_SAMPLES = 400;
+/** Every `sx`-th column / `sy`-th row of a scalar matrix. */
+function downsampleMatrix(matrix, sx, sy) {
+    if (sx <= 1 && sy <= 1)
+        return matrix;
+    const out = [];
+    for (let r = 0; r < matrix.length; r += sy) {
+        const row = matrix[r];
+        if (sx <= 1) {
+            out.push(row);
+            continue;
+        }
+        const sampled = [];
+        for (let c = 0; c < row.length; c += sx)
+            sampled.push(row[c]);
+        out.push(sampled);
+    }
+    return out;
+}
+/** CONTOUR — per-frame iso-contours over a downsampled scalar matrix. Mirrors
+ *  the heatmap trace geometry (x0/dx/y0/dy) so it lines up with the image axes;
+ *  the stride scales dx/dy so the coarser grid still spans the true extent. */
+function buildContourTraces(input) {
+    const [x0, , y0] = [input.trueImageSize[0], input.trueImageSize[1], input.trueImageSize[2]];
+    return input.frames.map((frame, index) => {
+        const scalar = toScalarFrame(frame, input.isGrayscale);
+        const height = scalar.length;
+        const width = height > 0 ? scalar[0].length : 0;
+        const sx = strideFor(width, CONTOUR_MAX_SAMPLES);
+        const sy = strideFor(height, CONTOUR_MAX_SAMPLES);
+        return {
+            x0,
+            dx: input.ratios[0] * sx,
+            y0,
+            dy: input.ratios[0] * sy,
+            z: downsampleMatrix(scalar, sx, sy),
+            type: 'contour',
+            hoverinfo: 'none',
+            colorscale: input.colorscale,
+            reversescale: input.reversescale,
+            contours: { coloring: 'heatmap' },
+            // Cap the level count so it doesn't scale with the (now coarser) grid.
+            ncontours: 15,
+            name: `Slice ${index + 1}`,
+            visible: index === 0,
+        };
+    });
+}
+/** SCATTER — region centroids as labelled markers (region-sourced). */
+function buildScatterTraces(input) {
+    const xs = [];
+    const ys = [];
+    const text = [];
+    input.regions.forEach((poly, i) => {
+        const n = poly.xpoints.length;
+        if (n === 0)
+            return;
+        const cx = poly.xpoints.reduce((a, b) => a + b, 0) / n;
+        const cy = poly.ypoints.reduce((a, b) => a + b, 0) / n;
+        xs.push(cx);
+        ys.push(cy);
+        text.push(`R${i + 1}`);
+    });
+    return [{
+            x: xs,
+            y: ys,
+            text,
+            type: 'scatter',
+            mode: 'markers+text',
+            textposition: 'top center',
+            marker: { size: 10, color: input.shapeColor, line: { color: '#000', width: 1 } },
+            name: 'Region centroids',
+        }];
+}
+/**
+ * Collect a downsampled regular grid of voxels across the z-stack.
+ * Returns parallel flat arrays suitable for both scatter3d and isosurface.
+ * A single-frame image is thickened to two z-planes so 3D traces render.
+ */
+function sampleVolume(input, maxXY, maxZ) {
+    let frames = input.frames.map(f => toScalarFrame(f, input.isGrayscale));
+    if (frames.length < 2)
+        frames = [frames[0] || [], frames[0] || []];
+    const height = frames[0].length;
+    const width = height > 0 ? frames[0][0].length : 0;
+    const sx = strideFor(width, maxXY);
+    const sy = strideFor(height, maxXY);
+    const sz = strideFor(frames.length, maxZ);
+    const x = [];
+    const y = [];
+    const z = [];
+    const value = [];
+    for (let zi = 0; zi < frames.length; zi += sz) {
+        for (let yi = 0; yi < height; yi += sy) {
+            const rowArr = frames[zi][yi] || [];
+            for (let xi = 0; xi < width; xi += sx) {
+                x.push(xi * input.ratios[0]);
+                y.push(yi * input.ratios[0]);
+                z.push(zi);
+                value.push(rowArr[xi]);
+            }
+        }
+    }
+    return { x, y, z, value };
+}
+/** SCATTER3D — downsampled voxels as intensity-coloured 3D markers. */
+function buildScatter3dTraces(input) {
+    const { x, y, z, value } = sampleVolume(input, 48, 40);
+    return [{
+            type: 'scatter3d',
+            mode: 'markers',
+            x, y, z,
+            marker: {
+                size: 2,
+                color: value,
+                colorscale: input.colorscale,
+                reversescale: input.reversescale,
+                opacity: 0.8,
+            },
+            name: 'Voxels',
+        }];
+}
+/** ISOSURFACE — iso-intensity surfaces over the downsampled volume grid.
+ *  isomin/isomax come straight from the toolbar range slider (0–255). */
+function buildIsosurfaceTraces(input) {
+    const { x, y, z, value } = sampleVolume(input, 40, 40);
+    // The caller (PlotlyService) maps the 0–255 slider onto the volume's real
+    // intensity range before this runs, so the band always sits inside the data.
+    // We only guard ordering here.
+    const isoMin = Math.min(input.isoMin, input.isoMax);
+    const isoMax = Math.max(input.isoMin, input.isoMax);
+    return [{
+            type: 'isosurface',
+            x, y, z, value,
+            isomin: isoMin,
+            isomax: isoMax,
+            // A few nested levels (not just the two band extremes): even if an extreme
+            // grazes the data edge and draws nothing, an interior level still renders,
+            // so the volume is never silently empty.
+            surface: { count: 3 },
+            colorscale: input.colorscale,
+            reversescale: input.reversescale,
+            opacity: 0.6,
+            caps: { x: { show: false }, y: { show: false }, z: { show: false } },
+            name: 'Isosurface',
+        }];
+}
+/** Registry of the pluggable (non-original) plot types. */
+export const PLOTLY_PLOT_TYPE_IMPLS = {
+    [PlotType.CONTOUR]: { buildTraces: buildContourTraces, layoutKind: '2d-image', threeD: false },
+    [PlotType.SCATTER]: { buildTraces: buildScatterTraces, layoutKind: '2d-overlay', threeD: false },
+    [PlotType.SCATTER3D]: { buildTraces: buildScatter3dTraces, layoutKind: '3d-volume', threeD: true },
+    [PlotType.ISOSURFACE]: { buildTraces: buildIsosurfaceTraces, layoutKind: '3d-volume', threeD: true },
+};
+export function getPlotTypeImpl(type) {
+    return PLOTLY_PLOT_TYPE_IMPLS[type];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly-trace-builders.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly-trace-builders.ts"],"names":[],"mappings":"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","sourcesContent":["import { PlotType } from '../../contracts/plot-type';\nimport { bt601Luminance } from '../../contracts/intensity';\n\n/**\n * Pluggable Plotly trace builders for the plot types added on top of the\n * original HEATMAP / SURFACE / RGB-image renderers.\n *\n * DESIGN / EXTRACTION ALIGNMENT\n * -----------------------------\n * Every function here is **pure** — it takes a `TraceBuildInput` and returns\n * Plotly trace dicts. There is no Angular, no RxJS, no host-state coupling\n * (`MainState`, `FilesService`, …). That keeps the module relocatable into the\n * future `@jax-data-science/image-visualization` library core (see the\n * `sketch/jit-plotting-extraction` SOW) without port surgery.\n *\n * Layout building stays in `PlotlyService` (it needs live service state such\n * as screen height, scale ratio and the current shapes); only TRACE building\n * is pluggable here. To add a new plot type: write a builder, register it in\n * `PLOTLY_PLOT_TYPE_IMPLS`, and add a descriptor in `contracts/plot-type.ts`.\n *\n * The original HEATMAP/SURFACE/RGB types intentionally keep their dedicated\n * renderers in `PlotlyService` (they are also reused by the high-def zoom\n * re-fetch path), so they are NOT registered here.\n */\n\n/** Normalised input for a trace builder. Frames are per-z-plane matrices:\n *  grayscale cells are scalars, RGB cells are `[r, g, b]`. */\nexport interface TraceBuildInput {\n  frames: any[];\n  width: number;\n  height: number;\n  /** [xRatio, yRatio] — data units per pixel. */\n  ratios: number[];\n  /** [x0, x1, y0, y1] — true image extent in data units. */\n  trueImageSize: number[];\n  isGrayscale: boolean;\n  /** Plotly colorscale value (e.g. from the active colormap). */\n  colorscale: any;\n  reversescale: boolean;\n  /** Region polygons in data coords, for region-sourced plots (SCATTER). */\n  regions: { xpoints: number[]; ypoints: number[] }[];\n  /** Default marker/line colour for derived (non-image-LUT) traces. */\n  shapeColor: string;\n  /** ISOSURFACE intensity bounds (0–255): surfaces are drawn for values in\n   *  [isoMin, isoMax], mapped straight onto Plotly's isomin/isomax. */\n  isoMin: number;\n  isoMax: number;\n}\n\nexport type TraceBuilder = (input: TraceBuildInput) => any[];\n\nexport type PlotLayoutKind = '2d-image' | '2d-overlay' | '2d-chart' | '3d-volume';\n\nexport interface PlotlyPlotTypeImpl {\n  buildTraces: TraceBuilder;\n  /** Which layout `PlotlyService` should build for this type. */\n  layoutKind: PlotLayoutKind;\n  /** True for scene-based (3D) traces — picks the 3D Plotly config. */\n  threeD: boolean;\n}\n\n// ── helpers ──────────────────────────────────────────────────────────────\n\n/** Scalar value of a frame cell: `[r, g, b]` → BT.601 luminance, scalar as-is. */\nfunction luminance(cell: any): number {\n  if (Array.isArray(cell)) {\n    return bt601Luminance(cell[0], cell[1], cell[2]);\n  }\n  return cell as number;\n}\n\n/** Project a frame to a scalar matrix (RGB → luminance, grayscale → as-is). */\nfunction toScalarFrame(frame: any[], isGrayscale: boolean): number[][] {\n  if (isGrayscale) return frame as number[][];\n  return frame.map((row: any[]) => row.map(luminance));\n}\n\n/** Even stride that keeps an axis under `maxSamples` sample points. */\nfunction strideFor(length: number, maxSamples: number): number {\n  return Math.max(1, Math.ceil(length / maxSamples));\n}\n\n// ── builders ─────────────────────────────────────────────────────────────\n\n/** Max cells per axis the contour grid is downsampled to. The heatmap trace can\n *  raster the full preview cheaply, but contour runs CPU marching-squares over\n *  every cell, so a full-resolution preview (~1000²) costs seconds. Contours\n *  interpolate, so a coarser grid looks the same while rendering near-instantly. */\nconst CONTOUR_MAX_SAMPLES = 400;\n\n/** Every `sx`-th column / `sy`-th row of a scalar matrix. */\nfunction downsampleMatrix(matrix: number[][], sx: number, sy: number): number[][] {\n  if (sx <= 1 && sy <= 1) return matrix;\n  const out: number[][] = [];\n  for (let r = 0; r < matrix.length; r += sy) {\n    const row = matrix[r];\n    if (sx <= 1) { out.push(row); continue; }\n    const sampled: number[] = [];\n    for (let c = 0; c < row.length; c += sx) sampled.push(row[c]);\n    out.push(sampled);\n  }\n  return out;\n}\n\n/** CONTOUR — per-frame iso-contours over a downsampled scalar matrix. Mirrors\n *  the heatmap trace geometry (x0/dx/y0/dy) so it lines up with the image axes;\n *  the stride scales dx/dy so the coarser grid still spans the true extent. */\nfunction buildContourTraces(input: TraceBuildInput): any[] {\n  const [x0, , y0] = [input.trueImageSize[0], input.trueImageSize[1], input.trueImageSize[2]];\n  return input.frames.map((frame, index) => {\n    const scalar = toScalarFrame(frame, input.isGrayscale);\n    const height = scalar.length;\n    const width = height > 0 ? scalar[0].length : 0;\n    const sx = strideFor(width, CONTOUR_MAX_SAMPLES);\n    const sy = strideFor(height, CONTOUR_MAX_SAMPLES);\n    return {\n      x0,\n      dx: input.ratios[0] * sx,\n      y0,\n      dy: input.ratios[0] * sy,\n      z: downsampleMatrix(scalar, sx, sy),\n      type: 'contour',\n      hoverinfo: 'none',\n      colorscale: input.colorscale,\n      reversescale: input.reversescale,\n      contours: { coloring: 'heatmap' },\n      // Cap the level count so it doesn't scale with the (now coarser) grid.\n      ncontours: 15,\n      name: `Slice ${index + 1}`,\n      visible: index === 0,\n    };\n  });\n}\n\n/** SCATTER — region centroids as labelled markers (region-sourced). */\nfunction buildScatterTraces(input: TraceBuildInput): any[] {\n  const xs: number[] = [];\n  const ys: number[] = [];\n  const text: string[] = [];\n  input.regions.forEach((poly, i) => {\n    const n = poly.xpoints.length;\n    if (n === 0) return;\n    const cx = poly.xpoints.reduce((a, b) => a + b, 0) / n;\n    const cy = poly.ypoints.reduce((a, b) => a + b, 0) / n;\n    xs.push(cx);\n    ys.push(cy);\n    text.push(`R${i + 1}`);\n  });\n  return [{\n    x: xs,\n    y: ys,\n    text,\n    type: 'scatter',\n    mode: 'markers+text',\n    textposition: 'top center',\n    marker: { size: 10, color: input.shapeColor, line: { color: '#000', width: 1 } },\n    name: 'Region centroids',\n  }];\n}\n\n/**\n * Collect a downsampled regular grid of voxels across the z-stack.\n * Returns parallel flat arrays suitable for both scatter3d and isosurface.\n * A single-frame image is thickened to two z-planes so 3D traces render.\n */\nfunction sampleVolume(input: TraceBuildInput, maxXY: number, maxZ: number) {\n  let frames = input.frames.map(f => toScalarFrame(f, input.isGrayscale));\n  if (frames.length < 2) frames = [frames[0] || [], frames[0] || []];\n\n  const height = frames[0].length;\n  const width = height > 0 ? frames[0][0].length : 0;\n  const sx = strideFor(width, maxXY);\n  const sy = strideFor(height, maxXY);\n  const sz = strideFor(frames.length, maxZ);\n\n  const x: number[] = [];\n  const y: number[] = [];\n  const z: number[] = [];\n  const value: number[] = [];\n  for (let zi = 0; zi < frames.length; zi += sz) {\n    for (let yi = 0; yi < height; yi += sy) {\n      const rowArr = frames[zi][yi] || [];\n      for (let xi = 0; xi < width; xi += sx) {\n        x.push(xi * input.ratios[0]);\n        y.push(yi * input.ratios[0]);\n        z.push(zi);\n        value.push(rowArr[xi]);\n      }\n    }\n  }\n  return { x, y, z, value };\n}\n\n/** SCATTER3D — downsampled voxels as intensity-coloured 3D markers. */\nfunction buildScatter3dTraces(input: TraceBuildInput): any[] {\n  const { x, y, z, value } = sampleVolume(input, 48, 40);\n  return [{\n    type: 'scatter3d',\n    mode: 'markers',\n    x, y, z,\n    marker: {\n      size: 2,\n      color: value,\n      colorscale: input.colorscale,\n      reversescale: input.reversescale,\n      opacity: 0.8,\n    },\n    name: 'Voxels',\n  }];\n}\n\n/** ISOSURFACE — iso-intensity surfaces over the downsampled volume grid.\n *  isomin/isomax come straight from the toolbar range slider (0–255). */\nfunction buildIsosurfaceTraces(input: TraceBuildInput): any[] {\n  const { x, y, z, value } = sampleVolume(input, 40, 40);\n  // The caller (PlotlyService) maps the 0–255 slider onto the volume's real\n  // intensity range before this runs, so the band always sits inside the data.\n  // We only guard ordering here.\n  const isoMin = Math.min(input.isoMin, input.isoMax);\n  const isoMax = Math.max(input.isoMin, input.isoMax);\n  return [{\n    type: 'isosurface',\n    x, y, z, value,\n    isomin: isoMin,\n    isomax: isoMax,\n    // A few nested levels (not just the two band extremes): even if an extreme\n    // grazes the data edge and draws nothing, an interior level still renders,\n    // so the volume is never silently empty.\n    surface: { count: 3 },\n    colorscale: input.colorscale,\n    reversescale: input.reversescale,\n    opacity: 0.6,\n    caps: { x: { show: false }, y: { show: false }, z: { show: false } },\n    name: 'Isosurface',\n  }];\n}\n\n/** Registry of the pluggable (non-original) plot types. */\nexport const PLOTLY_PLOT_TYPE_IMPLS: Partial<Record<PlotType, PlotlyPlotTypeImpl>> = {\n  [PlotType.CONTOUR]:    { buildTraces: buildContourTraces,    layoutKind: '2d-image',   threeD: false },\n  [PlotType.SCATTER]:    { buildTraces: buildScatterTraces,    layoutKind: '2d-overlay', threeD: false },\n  [PlotType.SCATTER3D]:  { buildTraces: buildScatter3dTraces,  layoutKind: '3d-volume',  threeD: true },\n  [PlotType.ISOSURFACE]: { buildTraces: buildIsosurfaceTraces, layoutKind: '3d-volume',  threeD: true },\n};\n\nexport function getPlotTypeImpl(type: PlotType): PlotlyPlotTypeImpl | undefined {\n  return PLOTLY_PLOT_TYPE_IMPLS[type];\n}\n"]}