@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/implementations/napari-js/napari-spatial-tooltip.mjs

@@ -1,6 +1,6 @@
 /**
  * Cursor tooltip naming the observation under the pointer, for the spatial-omics
- * views — the same overlay-in-the-host pattern as {@link NapariScaleBar}.
+ * views — the same overlay-in-the-host pattern as napari-js's `ScaleBarOverlay`.
  *
  * A 34-entry legend cannot be read back from a dot: several classes get similar
  * colours, and matching one to a swatch by eye is the job a tooltip removes. It
@@ -96,4 +96,4 @@ export class NapariSpatialTooltip {
         this.el.remove();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-tooltip.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-tooltip.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cursor tooltip naming the observation under the pointer, for the spatial-omics\n * views — the same overlay-in-the-host pattern as {@link NapariScaleBar}.\n *\n * A 34-entry legend cannot be read back from a dot: several classes get similar\n * colours, and matching one to a swatch by eye is the job a tooltip removes. It\n * shows what the cloud is CURRENTLY coloured by, so it always agrees with the\n * legend beside it.\n *\n * Deliberately not PrimeNG's `pTooltip`: that binds to an element, and these\n * points are pixels in a WebGPU canvas with no DOM of their own.\n */\nexport class NapariSpatialTooltip {\n  private readonly el: HTMLDivElement;\n  private readonly primary: HTMLSpanElement;\n  private readonly secondary: HTMLSpanElement;\n  /** Gap between the cursor and the box, so the box never sits under the arrow. */\n  private static readonly OFFSET = 14;\n\n  constructor(private readonly host: HTMLElement) {\n    // Absolutely positioned within the host, so the host must establish a\n    // containing block (the plot host is often statically positioned). Tested for\n    // what it must NOT be rather than for 'static': a computed position can also\n    // come back empty, and treating that as already-positioned would leave the box\n    // anchored to some ancestor instead.\n    const positioned = ['relative', 'absolute', 'fixed', 'sticky'];\n    if (!positioned.includes(getComputedStyle(host).position)) {\n      host.style.position = 'relative';\n    }\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      display: 'none',\n      // Above the canvas and the region overlay, below any dialog.\n      zIndex: '6',\n      // The pointer has to reach the canvas underneath: a tooltip that ate\n      // pointer events would kill orbiting the moment it appeared.\n      pointerEvents: 'none',\n      padding: '4px 8px',\n      borderRadius: '4px',\n      background: 'rgba(17, 17, 20, 0.88)',\n      color: '#fff',\n      font: '12px/1.35 system-ui, sans-serif',\n      whiteSpace: 'nowrap',\n      boxShadow: '0 2px 8px rgba(0, 0, 0, 0.35)',\n      maxWidth: '22rem',\n      overflow: 'hidden',\n      textOverflow: 'ellipsis',\n    } as Partial<CSSStyleDeclaration>);\n\n    this.primary = document.createElement('span');\n    Object.assign(this.primary.style, { display: 'block', fontWeight: '600' });\n    this.secondary = document.createElement('span');\n    Object.assign(this.secondary.style, {\n      display: 'block',\n      opacity: '0.7',\n      fontSize: '11px',\n      // Every line after the first is a detail line, one per row.\n      whiteSpace: 'pre',\n    } as Partial<CSSStyleDeclaration>);\n\n    this.el.append(this.primary, this.secondary);\n    host.appendChild(this.el);\n  }\n\n  /**\n   * Show `lines` at a point given in HOST-relative pixels.\n   *\n   * Flips to the other side of the cursor near an edge rather than being clipped\n   * by the host — a tooltip half outside the plot is worse than one on the left.\n   */\n  show(lines: readonly string[], hostX: number, hostY: number): void {\n    if (lines.length === 0) {\n      this.hide();\n      return;\n    }\n    this.primary.textContent = lines[0];\n    const details = lines.slice(1).filter(Boolean);\n    this.secondary.textContent = details.join('\\n');\n    this.secondary.style.display = details.length ? 'block' : 'none';\n    // Measured while visible: offsetWidth is 0 on a `display: none` element, so\n    // the flip below would always think the box fits.\n    this.el.style.display = 'block';\n\n    const gap = NapariSpatialTooltip.OFFSET;\n    const w = this.el.offsetWidth;\n    const h = this.el.offsetHeight;\n    const hostW = this.host.clientWidth;\n    const hostH = this.host.clientHeight;\n    const left = hostX + gap + w > hostW ? Math.max(0, hostX - gap - w) : hostX + gap;\n    const top = hostY + gap + h > hostH ? Math.max(0, hostY - gap - h) : hostY + gap;\n    this.el.style.left = `${Math.round(left)}px`;\n    this.el.style.top = `${Math.round(top)}px`;\n  }\n\n  hide(): void {\n    this.el.style.display = 'none';\n  }\n\n  /** True while the box is on screen — for tests, and to skip redundant hides. */\n  get visible(): boolean {\n    return this.el.style.display !== 'none';\n  }\n\n  dispose(): void {\n    this.el.remove();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-tooltip.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-tooltip.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Cursor tooltip naming the observation under the pointer, for the spatial-omics\n * views — the same overlay-in-the-host pattern as napari-js's `ScaleBarOverlay`.\n *\n * A 34-entry legend cannot be read back from a dot: several classes get similar\n * colours, and matching one to a swatch by eye is the job a tooltip removes. It\n * shows what the cloud is CURRENTLY coloured by, so it always agrees with the\n * legend beside it.\n *\n * Deliberately not PrimeNG's `pTooltip`: that binds to an element, and these\n * points are pixels in a WebGPU canvas with no DOM of their own.\n */\nexport class NapariSpatialTooltip {\n  private readonly el: HTMLDivElement;\n  private readonly primary: HTMLSpanElement;\n  private readonly secondary: HTMLSpanElement;\n  /** Gap between the cursor and the box, so the box never sits under the arrow. */\n  private static readonly OFFSET = 14;\n\n  constructor(private readonly host: HTMLElement) {\n    // Absolutely positioned within the host, so the host must establish a\n    // containing block (the plot host is often statically positioned). Tested for\n    // what it must NOT be rather than for 'static': a computed position can also\n    // come back empty, and treating that as already-positioned would leave the box\n    // anchored to some ancestor instead.\n    const positioned = ['relative', 'absolute', 'fixed', 'sticky'];\n    if (!positioned.includes(getComputedStyle(host).position)) {\n      host.style.position = 'relative';\n    }\n\n    this.el = document.createElement('div');\n    Object.assign(this.el.style, {\n      position: 'absolute',\n      display: 'none',\n      // Above the canvas and the region overlay, below any dialog.\n      zIndex: '6',\n      // The pointer has to reach the canvas underneath: a tooltip that ate\n      // pointer events would kill orbiting the moment it appeared.\n      pointerEvents: 'none',\n      padding: '4px 8px',\n      borderRadius: '4px',\n      background: 'rgba(17, 17, 20, 0.88)',\n      color: '#fff',\n      font: '12px/1.35 system-ui, sans-serif',\n      whiteSpace: 'nowrap',\n      boxShadow: '0 2px 8px rgba(0, 0, 0, 0.35)',\n      maxWidth: '22rem',\n      overflow: 'hidden',\n      textOverflow: 'ellipsis',\n    } as Partial<CSSStyleDeclaration>);\n\n    this.primary = document.createElement('span');\n    Object.assign(this.primary.style, { display: 'block', fontWeight: '600' });\n    this.secondary = document.createElement('span');\n    Object.assign(this.secondary.style, {\n      display: 'block',\n      opacity: '0.7',\n      fontSize: '11px',\n      // Every line after the first is a detail line, one per row.\n      whiteSpace: 'pre',\n    } as Partial<CSSStyleDeclaration>);\n\n    this.el.append(this.primary, this.secondary);\n    host.appendChild(this.el);\n  }\n\n  /**\n   * Show `lines` at a point given in HOST-relative pixels.\n   *\n   * Flips to the other side of the cursor near an edge rather than being clipped\n   * by the host — a tooltip half outside the plot is worse than one on the left.\n   */\n  show(lines: readonly string[], hostX: number, hostY: number): void {\n    if (lines.length === 0) {\n      this.hide();\n      return;\n    }\n    this.primary.textContent = lines[0];\n    const details = lines.slice(1).filter(Boolean);\n    this.secondary.textContent = details.join('\\n');\n    this.secondary.style.display = details.length ? 'block' : 'none';\n    // Measured while visible: offsetWidth is 0 on a `display: none` element, so\n    // the flip below would always think the box fits.\n    this.el.style.display = 'block';\n\n    const gap = NapariSpatialTooltip.OFFSET;\n    const w = this.el.offsetWidth;\n    const h = this.el.offsetHeight;\n    const hostW = this.host.clientWidth;\n    const hostH = this.host.clientHeight;\n    const left = hostX + gap + w > hostW ? Math.max(0, hostX - gap - w) : hostX + gap;\n    const top = hostY + gap + h > hostH ? Math.max(0, hostY - gap - h) : hostY + gap;\n    this.el.style.left = `${Math.round(left)}px`;\n    this.el.style.top = `${Math.round(top)}px`;\n  }\n\n  hide(): void {\n    this.el.style.display = 'none';\n  }\n\n  /** True while the box is on screen — for tests, and to skip redundant hides. */\n  get visible(): boolean {\n    return this.el.style.display !== 'none';\n  }\n\n  dispose(): void {\n    this.el.remove();\n  }\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-surface-scene.mjs

@@ -0,0 +1,271 @@
+import { heightField, histogramScalar } from 'napari-js';
+import { formatLength } from 'napari-js/overlays';
+import { Axes3dGizmo, surface3dControls } from './napari-axes-gizmo';
+import { SURFACE_Z_ASPECT, VOLUME_FETCH_CONCURRENCY, isServerlessMultichannel, mapPool, stackDepth, surfaceResolutionFor, toIHistogram, toNapariGamma, } from './napari-helpers';
+/**
+ * NAPARI_SURFACE (review Appendix B, cluster G): the slice as a height field. A height field is
+ * single-scalar, so for a multichannel image the surface follows ONE band — the pane-selected
+ * channel — coloured by that channel's window/colormap (like the Plotly SURFACE, which is
+ * grayscale-only). Every slice's plane is pre-loaded with a progress bar (as the volume does) so
+ * the stack slider re-slices instantly. All mesh + GPU work lives in napari-js (`heightField` +
+ * `Viewer.addSurface`); this scene supplies scalar slices.
+ */
+export class SurfaceScene {
+    constructor(ctx) {
+        this.ctx = ctx;
+        /** The height-field mesh (null until the first build). */
+        this.layer = null;
+        /** Which band the surface samples (a channel index for multichannel, else the composite). */
+        this.channel = undefined;
+        /** True when the surface follows one band of a multichannel image. */
+        this.multichannel = false;
+        /** Pre-loaded per-slice luminance planes (already decimated to the surface grid), keyed by z,
+         *  so the stack slider rebuilds the surface instantly. Filled by {@link preloadPlanes}. */
+        this.planes = new Map();
+        /** The preload in flight; a newer one (a channel switch) aborts it. */
+        this.preload = null;
+        /** In-plane grid cap for this load (full grid ÷ the decimate factor). */
+        this.maxGrid = surfaceResolutionFor(1).maxGrid;
+        /** Contrast window [min,max] the current mesh was built with. A change reshapes the mesh (pixel
+         *  height = intensity within [min,max]), so it triggers a geometry rebuild. */
+        this.window = null;
+        /** The current slice's plane, for the intensity histogram. */
+        this.histogramPlane = null;
+        this.gizmo = null;
+        this.displaySub = null;
+    }
+    async mount() {
+        const { ctx } = this;
+        const desc = await ctx.tiles.ensureDescriptor(ctx.info());
+        const info = ctx.info();
+        // Serverless multichannel (tiled:false + channelUrls) has no descriptor — detect
+        // it from imageMeta so the Surface still follows one band.
+        const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);
+        this.multichannel = simpleMc || (!!desc?.multichannel && (desc?.channels ?? 1) > 1);
+        // A height field is single-scalar → follow the pane-SELECTED channel.
+        this.channel = this.multichannel ? ctx.store.currentSelectedChannel() : undefined;
+        this.maxGrid = surfaceResolutionFor(ctx.settings.resolutionScale).maxGrid;
+        await this.preloadPlanes();
+        if (ctx.signal.aborted)
+            return;
+        await this.build(ctx.z());
+        this.installAxes();
+        // Subscribe after the first build so display-state edits target a live layer.
+        this.followDisplayState();
+    }
+    /** One slice → one mesh: re-build the height field for the new slice. Not built yet → nothing to
+     *  do; the build at the end of the mount reads the current slice. */
+    setZ(z) {
+        if (!this.layer)
+            return;
+        void this.build(z).catch((err) => console.error('[napari-js] setZIndex surface failed:', err));
+    }
+    /** The current slice's intensity histogram (the plane the mesh was built from). */
+    histogram(_channel, bins) {
+        const plane = this.histogramPlane;
+        return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;
+    }
+    surface3dControls() {
+        return this.layer
+            ? surface3dControls(this.ctx, () => this.gizmo, () => this.layer)
+            : null;
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+        this.preload?.abort();
+        this.preload = null;
+        this.planes.clear();
+        this.gizmo?.destroy();
+        this.gizmo = null;
+    }
+    /** Add the axes gizmo + labels around the (origin-centered) mesh, matching the volume. The box
+     *  tracks the mesh bounds, X/Y show the physical (or pixel) extent, and Z is the intensity axis. */
+    installAxes() {
+        if (!this.layer)
+            return;
+        const { ctx } = this;
+        const b = this.layer.bounds();
+        const boxW = Math.max(1, b.max[0] - b.min[0]);
+        const boxH = Math.max(1, b.max[1] - b.min[1]);
+        const boxD = Math.max(1, b.max[2] - b.min[2]);
+        const desc = ctx.tiles.currentDescriptor(ctx.info());
+        const mppX = ctx.tiles.mppX(ctx.info());
+        const imageW = ctx.imageSize().width;
+        const voxel = mppX > 0 ? (mppX * (desc?.width ?? imageW)) / Math.max(1, imageW) : 1;
+        this.gizmo = new Axes3dGizmo(ctx.viewer, ctx.host, { width: boxW, height: boxH, depth: boxD }, this.axesLabels(boxW, boxH, boxD, mppX), { visible: ctx.settings.axesVisible, voxelSize: [voxel, voxel, 1] });
+    }
+    /** X/Y/Z end-labels for the gizmo: X/Y are the physical (µm) or pixel extent of the FULL image;
+     *  Z is the intensity/height axis. Anchors are in the centered box (matching AxesLayer). */
+    axesLabels(boxW, boxH, boxD, mppX) {
+        const hx = boxW / 2;
+        const hy = boxH / 2;
+        const hz = boxD / 2;
+        const desc = this.ctx.tiles.currentDescriptor(this.ctx.info());
+        const size = this.ctx.imageSize();
+        const descW = desc?.width ?? size.width;
+        const descH = desc?.height ?? size.height;
+        const len = (px) => (mppX > 0 ? formatLength(px * mppX, 'µm') : `${px} px`);
+        return [
+            { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },
+            { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },
+            { anchor: [-hx, -hy, hz], text: 'Z · intensity', color: '#668cff' },
+        ];
+    }
+    /**
+     * Pre-fetch every stack slice's luminance plane (decimated to the surface grid) into
+     * {@link planes}, driving the stack progress — the same load-with-progress UX as the volume, but
+     * keeping one 2D plane per slice rather than packing a 3D volume. Bounded concurrency keeps the
+     * connection pool busy without flooding it on a deep stack.
+     */
+    async preloadPlanes() {
+        const { ctx } = this;
+        // A channel switch starts a new preload while this one may still be in flight: the newer
+        // one owns the plane cache and the progress bar from here on.
+        this.preload?.abort();
+        const preload = new AbortController();
+        this.preload = preload;
+        const loading = ctx.loading(); // bail on a Cancel / new plot while we fetch
+        const stale = () => preload.signal.aborted || loading.aborted || ctx.signal.aborted;
+        const depth = stackDepth(ctx.info()) || 1;
+        const { maxGrid } = surfaceResolutionFor(ctx.settings.resolutionScale);
+        this.planes.clear();
+        ctx.stack.loading(true);
+        ctx.stack.progress(0);
+        try {
+            let done = 0;
+            const slices = Array.from({ length: depth }, (_, z) => z);
+            await mapPool(slices, VOLUME_FETCH_CONCURRENCY, async (z) => {
+                try {
+                    const plane = await this.fetchPlane(z, maxGrid);
+                    // Superseded while in flight: this plane may be the OLD band, and the cache is not
+                    // this preload's any more.
+                    if (stale())
+                        return;
+                    this.planes.set(z, plane);
+                }
+                catch (err) {
+                    if (stale())
+                        return;
+                    console.warn(`[napari-js] surface slice ${z} preload failed`, err);
+                }
+                done++;
+                ctx.stack.progress(Math.round((done / depth) * 100));
+            }, stale);
+        }
+        finally {
+            // Only the newest preload ends the progress bar; a superseded one would hide it while
+            // its successor is still loading.
+            if (this.preload === preload) {
+                this.preload = null;
+                ctx.stack.loading(false);
+                ctx.stack.progress(0);
+            }
+        }
+    }
+    /** Slice `z` as a whole-image luminance plane of the surface's band, decimated to `maxGrid`. */
+    fetchPlane(z, maxGrid) {
+        return this.ctx.tiles.fetchPlane(this.ctx.info(), z, this.channel, maxGrid);
+    }
+    /** The channel state driving the surface: the chosen band for multichannel (matched by index),
+     *  else the single grayscale channel. */
+    channelState(channels) {
+        if (this.channel == null)
+            return channels[0];
+        return channels.find((s) => s.index === this.channel) ?? channels[0];
+    }
+    /**
+     * (Re)build the mesh for slice `z` from the pre-loaded plane cache (instant — this is what the
+     * stack slider calls); a slice missing from the cache is fetched on demand. napari-js's pure
+     * `heightField` builds the triangle grid (z = normalized intensity), then `addSurface` renders
+     * it. The slice plane also feeds the intensity histogram.
+     */
+    async build(z) {
+        const { ctx } = this;
+        let plane = this.planes.get(z);
+        if (!plane) {
+            ctx.stack.loading(true);
+            try {
+                plane = await this.fetchPlane(z, this.maxGrid);
+                this.planes.set(z, plane);
+            }
+            catch (err) {
+                console.error('[napari-js] surface slice fetch failed:', err);
+            }
+            finally {
+                ctx.stack.loading(false);
+            }
+        }
+        if (!plane || plane.width < 2 || plane.height < 2 || ctx.signal.aborted)
+            return;
+        const st = this.channelState(ctx.store.currentChannelStates());
+        const win = [st?.min ?? 0, st?.max ?? 255];
+        this.window = win;
+        // Height AND colour are normalized by the same contrast window, so changing min/max reshapes the
+        // surface (a pixel's height = its intensity within [min,max]). Center it for the axes gizmo. The
+        // plane is already decimated to the grid cap → stride 1.
+        const zScale = SURFACE_Z_ASPECT * Math.max(plane.width, plane.height);
+        const { vertices, faces, values } = heightField(plane.data, plane.width, plane.height, {
+            zScale,
+            zLimits: win,
+            center: true,
+        });
+        // A re-slice / window rebuild keeps the orbit camera: the viewer's `fit3d: 'once'` frames only
+        // the scene's first 3D add, so stepping the stack or changing the window keeps the pose.
+        if (this.layer) {
+            ctx.viewer.layers.remove(this.layer);
+            this.layer = null;
+        }
+        this.layer = ctx.viewer.addSurface(vertices, faces, values, {
+            colormap: ctx.display.volumeColormap(st),
+            contrastLimits: win,
+            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+            invert: ctx.display.invert,
+            wireframe: ctx.settings.surfaceWireframe,
+        });
+        ctx.setImageSize(plane.width, plane.height);
+        this.histogramPlane = plane.data;
+        ctx.tools.scheduleReadback();
+    }
+    /** The store colormap / reverse / invert / channel window → the surface, so histogram & channel
+     *  dialog edits update it live without a re-fetch. **min/max reshapes the surface's height** (a
+     *  pixel's height = its intensity within [min,max]), so a window change rebuilds the mesh
+     *  geometry (from the cached slice); colour-only edits (colormap/LUT, gamma, reverse, invert)
+     *  just update the layer's uniforms. */
+    followDisplayState() {
+        const { ctx } = this;
+        this.displaySub = ctx.display.watch((channels, selected) => {
+            const layer = this.layer;
+            if (!layer || ctx.signal.aborted)
+                return;
+            // Selected channel changed (multichannel): re-fetch THAT band's planes and
+            // rebuild the height-field for the current slice.
+            if (this.multichannel && selected !== this.channel) {
+                this.channel = selected;
+                void (async () => {
+                    await this.preloadPlanes();
+                    if (!ctx.signal.aborted)
+                        await this.build(ctx.z());
+                })().catch((err) => console.error('[napari-js] surface channel switch failed:', err));
+                return;
+            }
+            const st = this.channelState(channels);
+            const win = [st?.min ?? 0, st?.max ?? 255];
+            const windowChanged = !this.window || win[0] !== this.window[0] || win[1] !== this.window[1];
+            if (windowChanged) {
+                // Height follows the contrast window → rebuild the mesh for the new [min,max] (camera kept).
+                void this.build(ctx.z()).catch((err) => console.error('[napari-js] surface window rebuild failed:', err));
+                return;
+            }
+            // Colour-only change: update uniforms in place, no geometry rebuild.
+            layer.colormap = ctx.display.volumeColormap(st);
+            layer.invert = ctx.display.invert;
+            if (st) {
+                layer.contrastLimits = win;
+                layer.gamma = toNapariGamma(st.gamma); // ImageJ γ → napari-js γ
+            }
+            ctx.viewer.requestRender();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-surface-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-surface-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\nimport { heightField, histogramScalar } from 'napari-js';\nimport type { SurfaceLayer } from 'napari-js';\nimport { formatLength } from 'napari-js/overlays';\nimport type { AxisLabelSpec } from 'napari-js/overlays';\n\nimport { IChannelState, IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { ISurface3dControls } from '../../contracts/visualizer.contract';\nimport { Axes3dGizmo, surface3dControls } from './napari-axes-gizmo';\nimport {\n  LumaPlane,\n  SURFACE_Z_ASPECT,\n  VOLUME_FETCH_CONCURRENCY,\n  isServerlessMultichannel,\n  mapPool,\n  stackDepth,\n  surfaceResolutionFor,\n  toIHistogram,\n  toNapariGamma,\n} from './napari-helpers';\nimport type { NapariScene, SceneContext } from './napari-scene';\n\n/**\n * NAPARI_SURFACE (review Appendix B, cluster G): the slice as a height field. A height field is\n * single-scalar, so for a multichannel image the surface follows ONE band — the pane-selected\n * channel — coloured by that channel's window/colormap (like the Plotly SURFACE, which is\n * grayscale-only). Every slice's plane is pre-loaded with a progress bar (as the volume does) so\n * the stack slider re-slices instantly. All mesh + GPU work lives in napari-js (`heightField` +\n * `Viewer.addSurface`); this scene supplies scalar slices.\n */\nexport class SurfaceScene implements NapariScene {\n  /** The height-field mesh (null until the first build). */\n  layer: SurfaceLayer | null = null;\n  /** Which band the surface samples (a channel index for multichannel, else the composite). */\n  private channel: number | undefined = undefined;\n  /** True when the surface follows one band of a multichannel image. */\n  private multichannel = false;\n  /** Pre-loaded per-slice luminance planes (already decimated to the surface grid), keyed by z,\n   *  so the stack slider rebuilds the surface instantly. Filled by {@link preloadPlanes}. */\n  readonly planes = new Map<number, LumaPlane>();\n  /** The preload in flight; a newer one (a channel switch) aborts it. */\n  private preload: AbortController | null = null;\n  /** In-plane grid cap for this load (full grid ÷ the decimate factor). */\n  private maxGrid = surfaceResolutionFor(1).maxGrid;\n  /** Contrast window [min,max] the current mesh was built with. A change reshapes the mesh (pixel\n   *  height = intensity within [min,max]), so it triggers a geometry rebuild. */\n  private window: [number, number] | null = null;\n  /** The current slice's plane, for the intensity histogram. */\n  private histogramPlane: Uint8Array | null = null;\n  private gizmo: Axes3dGizmo | null = null;\n  private displaySub: Subscription | null = null;\n\n  constructor(private readonly ctx: SceneContext) {}\n\n  async mount(): Promise<void> {\n    const { ctx } = this;\n    const desc = await ctx.tiles.ensureDescriptor(ctx.info());\n    const info = ctx.info();\n    // Serverless multichannel (tiled:false + channelUrls) has no descriptor — detect\n    // it from imageMeta so the Surface still follows one band.\n    const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);\n    this.multichannel = simpleMc || (!!desc?.multichannel && (desc?.channels ?? 1) > 1);\n    // A height field is single-scalar → follow the pane-SELECTED channel.\n    this.channel = this.multichannel ? ctx.store.currentSelectedChannel() : undefined;\n    this.maxGrid = surfaceResolutionFor(ctx.settings.resolutionScale).maxGrid;\n    await this.preloadPlanes();\n    if (ctx.signal.aborted) return;\n    await this.build(ctx.z());\n    this.installAxes();\n    // Subscribe after the first build so display-state edits target a live layer.\n    this.followDisplayState();\n  }\n\n  /** One slice → one mesh: re-build the height field for the new slice. Not built yet → nothing to\n   *  do; the build at the end of the mount reads the current slice. */\n  setZ(z: number): void {\n    if (!this.layer) return;\n    void this.build(z).catch((err) => console.error('[napari-js] setZIndex surface failed:', err));\n  }\n\n  /** The current slice's intensity histogram (the plane the mesh was built from). */\n  histogram(_channel: number, bins: number): IHistogram | null {\n    const plane = this.histogramPlane;\n    return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;\n  }\n\n  surface3dControls(): ISurface3dControls | null {\n    return this.layer\n      ? surface3dControls(\n          this.ctx,\n          () => this.gizmo,\n          () => this.layer,\n        )\n      : null;\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.preload?.abort();\n    this.preload = null;\n    this.planes.clear();\n    this.gizmo?.destroy();\n    this.gizmo = null;\n  }\n\n  /** Add the axes gizmo + labels around the (origin-centered) mesh, matching the volume. The box\n   *  tracks the mesh bounds, X/Y show the physical (or pixel) extent, and Z is the intensity axis. */\n  private installAxes(): void {\n    if (!this.layer) return;\n    const { ctx } = this;\n    const b = this.layer.bounds();\n    const boxW = Math.max(1, b.max[0] - b.min[0]);\n    const boxH = Math.max(1, b.max[1] - b.min[1]);\n    const boxD = Math.max(1, b.max[2] - b.min[2]);\n    const desc = ctx.tiles.currentDescriptor(ctx.info());\n    const mppX = ctx.tiles.mppX(ctx.info());\n    const imageW = ctx.imageSize().width;\n    const voxel = mppX > 0 ? (mppX * (desc?.width ?? imageW)) / Math.max(1, imageW) : 1;\n    this.gizmo = new Axes3dGizmo(\n      ctx.viewer,\n      ctx.host,\n      { width: boxW, height: boxH, depth: boxD },\n      this.axesLabels(boxW, boxH, boxD, mppX),\n      { visible: ctx.settings.axesVisible, voxelSize: [voxel, voxel, 1] },\n    );\n  }\n\n  /** X/Y/Z end-labels for the gizmo: X/Y are the physical (µm) or pixel extent of the FULL image;\n   *  Z is the intensity/height axis. Anchors are in the centered box (matching AxesLayer). */\n  private axesLabels(boxW: number, boxH: number, boxD: number, mppX: number): AxisLabelSpec[] {\n    const hx = boxW / 2;\n    const hy = boxH / 2;\n    const hz = boxD / 2;\n    const desc = this.ctx.tiles.currentDescriptor(this.ctx.info());\n    const size = this.ctx.imageSize();\n    const descW = desc?.width ?? size.width;\n    const descH = desc?.height ?? size.height;\n    const len = (px: number): string => (mppX > 0 ? formatLength(px * mppX, 'µm') : `${px} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(descW)}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(descH)}`, color: '#4dd959' },\n      { anchor: [-hx, -hy, hz], text: 'Z · intensity', color: '#668cff' },\n    ];\n  }\n\n  /**\n   * Pre-fetch every stack slice's luminance plane (decimated to the surface grid) into\n   * {@link planes}, driving the stack progress — the same load-with-progress UX as the volume, but\n   * keeping one 2D plane per slice rather than packing a 3D volume. Bounded concurrency keeps the\n   * connection pool busy without flooding it on a deep stack.\n   */\n  async preloadPlanes(): Promise<void> {\n    const { ctx } = this;\n    // A channel switch starts a new preload while this one may still be in flight: the newer\n    // one owns the plane cache and the progress bar from here on.\n    this.preload?.abort();\n    const preload = new AbortController();\n    this.preload = preload;\n    const loading = ctx.loading(); // bail on a Cancel / new plot while we fetch\n    const stale = (): boolean => preload.signal.aborted || loading.aborted || ctx.signal.aborted;\n    const depth = stackDepth(ctx.info()) || 1;\n    const { maxGrid } = surfaceResolutionFor(ctx.settings.resolutionScale);\n    this.planes.clear();\n    ctx.stack.loading(true);\n    ctx.stack.progress(0);\n    try {\n      let done = 0;\n      const slices = Array.from({ length: depth }, (_, z) => z);\n      await mapPool(\n        slices,\n        VOLUME_FETCH_CONCURRENCY,\n        async (z) => {\n          try {\n            const plane = await this.fetchPlane(z, maxGrid);\n            // Superseded while in flight: this plane may be the OLD band, and the cache is not\n            // this preload's any more.\n            if (stale()) return;\n            this.planes.set(z, plane);\n          } catch (err) {\n            if (stale()) return;\n            console.warn(`[napari-js] surface slice ${z} preload failed`, err);\n          }\n          done++;\n          ctx.stack.progress(Math.round((done / depth) * 100));\n        },\n        stale,\n      );\n    } finally {\n      // Only the newest preload ends the progress bar; a superseded one would hide it while\n      // its successor is still loading.\n      if (this.preload === preload) {\n        this.preload = null;\n        ctx.stack.loading(false);\n        ctx.stack.progress(0);\n      }\n    }\n  }\n\n  /** Slice `z` as a whole-image luminance plane of the surface's band, decimated to `maxGrid`. */\n  fetchPlane(z: number, maxGrid: number): Promise<LumaPlane> {\n    return this.ctx.tiles.fetchPlane(this.ctx.info(), z, this.channel, maxGrid);\n  }\n\n  /** The channel state driving the surface: the chosen band for multichannel (matched by index),\n   *  else the single grayscale channel. */\n  private channelState(channels: IChannelState[]): IChannelState | undefined {\n    if (this.channel == null) return channels[0];\n    return channels.find((s) => s.index === this.channel) ?? channels[0];\n  }\n\n  /**\n   * (Re)build the mesh for slice `z` from the pre-loaded plane cache (instant — this is what the\n   * stack slider calls); a slice missing from the cache is fetched on demand. napari-js's pure\n   * `heightField` builds the triangle grid (z = normalized intensity), then `addSurface` renders\n   * it. The slice plane also feeds the intensity histogram.\n   */\n  private async build(z: number): Promise<void> {\n    const { ctx } = this;\n    let plane = this.planes.get(z);\n    if (!plane) {\n      ctx.stack.loading(true);\n      try {\n        plane = await this.fetchPlane(z, this.maxGrid);\n        this.planes.set(z, plane);\n      } catch (err) {\n        console.error('[napari-js] surface slice fetch failed:', err);\n      } finally {\n        ctx.stack.loading(false);\n      }\n    }\n    if (!plane || plane.width < 2 || plane.height < 2 || ctx.signal.aborted) return;\n\n    const st = this.channelState(ctx.store.currentChannelStates());\n    const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n    this.window = win;\n    // Height AND colour are normalized by the same contrast window, so changing min/max reshapes the\n    // surface (a pixel's height = its intensity within [min,max]). Center it for the axes gizmo. The\n    // plane is already decimated to the grid cap → stride 1.\n    const zScale = SURFACE_Z_ASPECT * Math.max(plane.width, plane.height);\n    const { vertices, faces, values } = heightField(plane.data, plane.width, plane.height, {\n      zScale,\n      zLimits: win,\n      center: true,\n    });\n\n    // A re-slice / window rebuild keeps the orbit camera: the viewer's `fit3d: 'once'` frames only\n    // the scene's first 3D add, so stepping the stack or changing the window keeps the pose.\n    if (this.layer) {\n      ctx.viewer.layers.remove(this.layer);\n      this.layer = null;\n    }\n    this.layer = ctx.viewer.addSurface(vertices, faces, values, {\n      colormap: ctx.display.volumeColormap(st),\n      contrastLimits: win,\n      gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n      invert: ctx.display.invert,\n      wireframe: ctx.settings.surfaceWireframe,\n    });\n\n    ctx.setImageSize(plane.width, plane.height);\n    this.histogramPlane = plane.data;\n    ctx.tools.scheduleReadback();\n  }\n\n  /** The store colormap / reverse / invert / channel window → the surface, so histogram & channel\n   *  dialog edits update it live without a re-fetch. **min/max reshapes the surface's height** (a\n   *  pixel's height = its intensity within [min,max]), so a window change rebuilds the mesh\n   *  geometry (from the cached slice); colour-only edits (colormap/LUT, gamma, reverse, invert)\n   *  just update the layer's uniforms. */\n  private followDisplayState(): void {\n    const { ctx } = this;\n    this.displaySub = ctx.display.watch((channels, selected) => {\n      const layer = this.layer;\n      if (!layer || ctx.signal.aborted) return;\n      // Selected channel changed (multichannel): re-fetch THAT band's planes and\n      // rebuild the height-field for the current slice.\n      if (this.multichannel && selected !== this.channel) {\n        this.channel = selected;\n        void (async () => {\n          await this.preloadPlanes();\n          if (!ctx.signal.aborted) await this.build(ctx.z());\n        })().catch((err) => console.error('[napari-js] surface channel switch failed:', err));\n        return;\n      }\n      const st = this.channelState(channels);\n      const win: [number, number] = [st?.min ?? 0, st?.max ?? 255];\n      const windowChanged = !this.window || win[0] !== this.window[0] || win[1] !== this.window[1];\n      if (windowChanged) {\n        // Height follows the contrast window → rebuild the mesh for the new [min,max] (camera kept).\n        void this.build(ctx.z()).catch((err) => console.error('[napari-js] surface window rebuild failed:', err));\n        return;\n      }\n      // Colour-only change: update uniforms in place, no geometry rebuild.\n      layer.colormap = ctx.display.volumeColormap(st);\n      layer.invert = ctx.display.invert;\n      if (st) {\n        layer.contrastLimits = win;\n        layer.gamma = toNapariGamma(st.gamma); // ImageJ γ → napari-js γ\n      }\n      ctx.viewer.requestRender();\n    });\n  }\n}\n"]}