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

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

@@ -0,0 +1,550 @@
+import { MultiChannelVolumeView, histogramScalar } from 'napari-js';
+import { formatLength } from 'napari-js/overlays';
+import { NapariVolumeZHandle } from './napari-volume-z-handle';
+import { Axes3dGizmo, surface3dControls } from './napari-axes-gizmo';
+import { SCATTER3D_MAX_POINTS, SCATTER3D_MAX_XY, VOLUME_WORLD_INPLANE_REF, isServerlessMultichannel, stackDepth, tintFor, toIHistogram, toNapariGamma, volumeResolutionFor, } from './napari-helpers';
+import { VolumeRegionMeshes } from './napari-volume-region-meshes';
+import { VolumeSlicePlanes } from './napari-volume-slice-planes';
+import { RegionMeshPointer } from './napari-region-mesh-pointer';
+/** The intensity histogram of an assembled uint8 channel (or the single grayscale volume, key 0). */
+function channelHistogram(data, channel, bins) {
+    if (!data.size)
+        return null;
+    const plane = data.get(channel) ?? data.get(0);
+    return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;
+}
+/** Assemble `info`'s stack into a uint8 volume under the stack progress bar; null once `loading`
+ *  aborts (a Cancel or a new plot). The caller owns the loading flag and takes `loading` once per
+ *  load: a Cancel replaces `ctx.loading()`, and a multichannel volume assembles channels in turn. */
+function assemble(ctx, info, opts, loading, channel) {
+    return ctx.tiles.assembleVolume(info, opts, channel, {
+        signal: loading,
+        progress: (p) => ctx.stack.progress(p),
+    });
+}
+/**
+ * NAPARI_VOLUME / NAPARI_ISOSURFACE (review Appendix B, cluster F): the stack assembled into a
+ * decimated volume — one additive, tinted `VolumeLayer` per channel for a multichannel image, a
+ * single grayscale volume otherwise — with the axes gizmo and the in-view Z-height handle.
+ */
+export class VolumeScene {
+    constructor(ctx, info, rendering) {
+        this.ctx = ctx;
+        this.info = info;
+        this.rendering = rendering;
+        /** napari-js high-level view owning the volume layers. */
+        this.view = null;
+        /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */
+        this.multichannel = false;
+        /** Volume world box at Z-scale 1 (base) + the sampled voxel depth — enough to recompute the
+         *  Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */
+        this.worldBase = null;
+        this.sampledDepth = 1;
+        this.dims = null;
+        /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity
+         *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */
+        this.channelData = new Map();
+        this.gizmo = null;
+        this.zHandle = null;
+        this.displaySub = null;
+        /** The image's full size (px, px, slices), which reconstructions are in. */
+        this.fullSize = null;
+        /** Clicks and hover on the reconstructions (with the selection tool). */
+        this.meshPointer = null;
+        this.toolSub = null;
+        this.selecting = false;
+        /** Whether the volume lets every region through (see {@link setRegionsThroughVolume}). */
+        this.regionsThrough = false;
+        this.regionMeshes = new VolumeRegionMeshes(ctx.viewer);
+        this.slicePlanes = new VolumeSlicePlanes(ctx.viewer, ctx.host, {
+            onMove: (axis, value) => ctx.inZone(() => ctx.slicePlaneMoved(axis, value)),
+        });
+    }
+    /** Show these region reconstructions in the volume (replacing the ones shown). */
+    setRegionMeshes(meshes) {
+        this.regionMeshes.set(meshes);
+    }
+    setRegionHighlight(keys) {
+        this.regionMeshes.setHighlight(keys);
+    }
+    setRegionHidden(keys) {
+        this.regionMeshes.setHidden(keys);
+    }
+    /**
+     * The volume hides the region reconstructions behind what it shows (its brightest sample along
+     * each ray, napari-js's `'translucent'` depth) — the perspective of a region behind the
+     * cerebellum — or, `through`, hides none (`'translucent_no_depth'`): surfaces traced inside its
+     * bright structures, an OCT's layer boundaries in its bright bands, which that depth speckles
+     * or hides. A multichannel volume's channels add up and hide nothing either way.
+     */
+    setRegionsThroughVolume(through) {
+        this.regionsThrough = through;
+        this.applyVolumeDepth();
+        this.ctx.viewer.requestRender();
+    }
+    applyVolumeDepth() {
+        if (this.multichannel)
+            return;
+        for (const layer of this.view?.layers ?? []) {
+            layer.blending = this.regionsThrough ? 'translucent_no_depth' : 'translucent';
+        }
+    }
+    /** Show the planes of the sections beside the volume where they are (null: hide one). */
+    setSlicePlanes(planes) {
+        this.slicePlanes.set(planes);
+    }
+    /**
+     * The assembled volume's voxels per channel (key 0: the grayscale one), its frame, and whether
+     * it is a multichannel composite — what the sections beside it are cut from. Null before it is
+     * assembled.
+     */
+    volumeVoxels() {
+        const base = this.worldBase;
+        if (!this.dims || !base || !this.fullSize || !this.channelData.size)
+            return null;
+        const depth = base.depth * this.ctx.settings.volumeZScale;
+        return {
+            ...this.dims,
+            channels: this.channelData,
+            multichannel: this.multichannel,
+            frame: { size: this.fullSize, world: [base.width, base.height, depth] },
+        };
+    }
+    /**
+     * Picking the reconstructions: with the selection tool armed, a click on one selects its class
+     * (null beside them); resting over one names it, whatever the tool.
+     */
+    listenToRegionMeshes() {
+        const { ctx } = this;
+        if (this.meshPointer)
+            return;
+        this.toolSub = ctx.store.getActiveTool$().subscribe((tool) => (this.selecting = tool === 'select'));
+        this.meshPointer = ctx.outsideZone(() => new RegionMeshPointer(ctx.canvas, ctx.host, {
+            pickAt: (x, y) => this.regionMeshes.pickAt(x, y),
+            active: () => this.selecting && this.regionMeshes.shown.length > 0,
+            hoverable: () => this.regionMeshes.shown.length > 0,
+            onPick: (key, additive) => ctx.inZone(() => ctx.regionMeshPicked(key, additive)),
+        }));
+    }
+    /** Image px per voxel of the assembled volume (in-plane), or null before it is assembled. */
+    voxelStep() {
+        return this.fullSize && this.dims ? this.fullSize[0] / Math.max(1, this.dims.width) : null;
+    }
+    /** Place the region reconstructions in the volume's world box as it is now. */
+    frameRegionMeshes() {
+        const base = this.worldBase;
+        if (!base || !this.fullSize)
+            return;
+        const depth = base.depth * this.ctx.settings.volumeZScale;
+        const frame = { size: this.fullSize, world: [base.width, base.height, depth] };
+        this.regionMeshes.setFrame(frame);
+        this.slicePlanes.setFrame(frame);
+    }
+    /**
+     * Assemble and render the volume, then add the axes gizmo + labels and the Z handle and follow
+     * the display state.
+     */
+    async mount() {
+        const { ctx, info } = this;
+        const loading = ctx.loading(); // bail before rendering on a Cancel / new plot
+        const desc = await ctx.tiles.ensureDescriptor(ctx.info());
+        // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so
+        // derive the channel count from imageMeta and assemble each band from its own
+        // channelUrls[z][c] plane (fetchImage does the per-channel routing).
+        const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);
+        const channelCount = simpleMc ? info.imageMeta[0].channelCount : (desc?.channels ?? 1);
+        const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);
+        this.channelData.clear();
+        this.multichannel = multichannel;
+        const view = new MultiChannelVolumeView(ctx.viewer);
+        this.view = view;
+        const { dims, channels } = await this.assembleChannels(desc, channelCount, loading);
+        if (!dims || !channels.length || loading.aborted)
+            return; // cancelled → don't render
+        const world = this.worldBox(dims);
+        // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted
+        // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.
+        this.worldBase = world;
+        this.sampledDepth = Math.max(1, dims.depth);
+        const worldZ = world.depth * ctx.settings.volumeZScale;
+        const voxelSize = [
+            world.width / dims.width,
+            world.height / dims.height,
+            worldZ / this.sampledDepth,
+        ];
+        for (const ch of channels)
+            ch.voxelSize = voxelSize;
+        view.render(this.multichannel ? 'multichannel' : 'grayscale', channels, { rendering: this.rendering });
+        this.applyVolumeDepth();
+        ctx.setImageSize(dims.width, dims.height);
+        this.dims = dims;
+        // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks
+        // the rendered proportions. Physical scale text still comes from the FULL image extent.
+        const box = { width: world.width, height: world.height, depth: worldZ };
+        this.gizmo = new Axes3dGizmo(ctx.viewer, ctx.host, box, this.axesLabels(box), {
+            visible: ctx.settings.axesVisible,
+        });
+        // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue
+        // "Z" axis + label live), so it reads as the Z-height control. Floated a little past the axis
+        // tip (×1.12) so the grip clears the "Z · …" label. Drag ↕ to restretch Z live.
+        this.zHandle = new NapariVolumeZHandle(ctx.host, ctx.viewer.camera3d, {
+            topAnchor: () => [
+                -this.worldBase.width / 2,
+                -this.worldBase.height / 2,
+                ((this.worldBase.depth * ctx.settings.volumeZScale) / 2) * 1.12,
+            ],
+            getScale: () => ctx.settings.volumeZScale,
+            setScale: (s) => this.setZScale(s),
+        });
+        this.followDisplayState();
+        this.frameRegionMeshes();
+        this.listenToRegionMeshes();
+    }
+    /**
+     * Assemble each channel's volume from the server tiles (or the single grayscale volume) under
+     * the stack progress bar, with the display settings it is drawn with. `dims` is null when
+     * nothing was assembled (a Cancel, a new plot, or no slices).
+     */
+    async assembleChannels(desc, channelCount, loading) {
+        const { ctx, info } = this;
+        const res = volumeResolutionFor(ctx.settings.resolutionScale);
+        const states = ctx.store.currentChannelStates();
+        // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view
+        // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale
+        // volume). The adapter computes each channel's colormap (incl. the reverse flip) and invert.
+        let dims = null;
+        const channels = [];
+        ctx.stack.loading(true);
+        ctx.stack.progress(0);
+        try {
+            if (this.multichannel) {
+                for (let c = 0; c < channelCount; c++) {
+                    const vol = await assemble(ctx, info, res, loading, c);
+                    if (loading.aborted)
+                        break; // a Cancel / new plot: fetch no further channel
+                    if (!vol)
+                        continue;
+                    dims = vol;
+                    this.channelData.set(c, vol.data);
+                    const st = states.find((s) => s.index === c);
+                    const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: ctx.display.channelTintColormap(color),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+                        invert: ctx.display.invert,
+                        visible: st?.visible ?? true,
+                    });
+                }
+            }
+            else {
+                const vol = await assemble(ctx, info, res, loading);
+                if (vol) {
+                    dims = vol;
+                    this.channelData.set(0, vol.data);
+                    const st = states[0];
+                    channels.push({
+                        data: vol.data,
+                        width: vol.width,
+                        height: vol.height,
+                        depth: vol.depth,
+                        colormap: ctx.display.volumeColormap(st),
+                        contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+                        gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ
+                        invert: ctx.display.invert,
+                    });
+                }
+            }
+        }
+        finally {
+            ctx.stack.loading(false);
+            ctx.stack.progress(0);
+        }
+        return { dims, channels };
+    }
+    /** The volume's world box for the assembled `dims`, independent of the decimate factor. */
+    worldBox(dims) {
+        const { ctx } = this;
+        // Resolution-invariant world box; the per-axis `voxelSize` (napari `scale`) maps the sampled
+        // grid onto it.
+        //
+        // A stack that declares its physical spacing on ALL THREE axes gets its true
+        // extent as the world box — the only way anisotropy survives, and what makes a
+        // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect
+        // brick. It needs none of the reference-box arithmetic: a physical box is
+        // already independent of the decimate factor.
+        //
+        // Everything else keeps that arithmetic. Sizing the box by the sampled voxel
+        // counts made higher in-plane resolution grow X/Y while the depth stayed the
+        // (constant) slice count — so Z appeared to shrink at higher resolution.
+        // Anchoring the in-plane long side to a fixed reference and letting Z span the
+        // full slice count makes the box shape identical at every decimate factor.
+        const meta = ctx.info()?.imageMeta?.[0];
+        const imageDesc = ctx.tiles.currentDescriptor(ctx.info());
+        // The server's descriptor first (it reports a tiled stack's spacing, e.g. a NRRD volume's), else
+        // the image metadata.
+        const mx = imageDesc?.mppX || meta?.mppX;
+        const my = imageDesc?.mppY || meta?.mppY;
+        const mz = imageDesc?.mppZ || meta?.mppZ;
+        const mppXYZ = mx && my && mz ? [mx, my, mz] : null;
+        // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled
+        // dims are decimated, so sizing a physical box by them would make the world
+        // box depend on the resolution the user happens to be viewing at.
+        const fullW = imageDesc?.width ?? meta?.x ?? dims.width;
+        const fullH = imageDesc?.height ?? meta?.y ?? dims.height;
+        const fullD = stackDepth(ctx.info()) || dims.depth;
+        this.fullSize = [fullW, fullH, fullD];
+        if (mppXYZ) {
+            return {
+                width: fullW * mppXYZ[0],
+                height: fullH * mppXYZ[1],
+                depth: fullD * mppXYZ[2],
+            };
+        }
+        const fullLong = Math.max(1, fullW, fullH);
+        return {
+            width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,
+            height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,
+            depth: fullD,
+        };
+    }
+    /**
+     * The whole stack is already on screen: no plane to step. (This used to write `viewer.dims.z`,
+     * which only a tiled 2D image reads — a volume raymarches every slice — and schedule a readback
+     * of a frame that had not changed. The toolbar shows no slice control in volume / isosurface
+     * mode, as Plotly's isosurface ignores the slice too.)
+     */
+    setZ() {
+        /* nothing to step */
+    }
+    /** The intensity histogram of the assembled (downsampled) uint8 volume for the requested
+     *  channel (multichannel) or the single grayscale volume. */
+    histogram(channel, bins) {
+        return channelHistogram(this.channelData, channel, bins);
+    }
+    isoControls() {
+        if (!this.view)
+            return null;
+        return {
+            setIsoRange: (isoMin, isoMax) => {
+                // Apply to every channel's volume layer.
+                for (const layer of this.view?.layers ?? []) {
+                    layer.contrastLimits = [isoMin, isoMax];
+                    layer.rendering = 'iso';
+                    layer.isoThreshold = 0.5;
+                }
+                this.ctx.viewer.requestRender();
+            },
+        };
+    }
+    surface3dControls() {
+        return this.view ? surface3dControls(this.ctx, () => this.gizmo) : null;
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+        this.gizmo?.destroy();
+        this.gizmo = null;
+        this.zHandle?.destroy();
+        this.zHandle = null;
+        this.regionMeshes.clear();
+        this.slicePlanes.destroy();
+        this.meshPointer?.destroy();
+        this.meshPointer = null;
+        this.toolSub?.unsubscribe();
+        this.toolSub = null;
+        this.worldBase = null;
+    }
+    /**
+     * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only
+     * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is
+     * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts
+     * (resolution changes) so the chosen height sticks.
+     */
+    setZScale(factor) {
+        const { settings } = this.ctx;
+        settings.volumeZScale = Math.min(10, Math.max(0.1, factor));
+        const base = this.worldBase;
+        if (!base || !this.view)
+            return;
+        const worldZ = base.depth * settings.volumeZScale;
+        const vsZ = worldZ / this.sampledDepth;
+        for (const layer of this.view.layers) {
+            const [sx, sy] = layer.voxelSize;
+            layer.voxelSize = [sx, sy, vsZ];
+        }
+        this.gizmo?.setDepth(worldZ, this.axesLabels({ width: base.width, height: base.height, depth: worldZ }));
+        this.zHandle?.reposition();
+        this.frameRegionMeshes();
+        this.ctx.viewer.requestRender();
+    }
+    /** The X/Y/Z axis-end label specs for the gizmo. Anchors are in the volume's centred world box
+     *  (matching the AxesLayer geometry); the scale text reflects the FULL image extent — physical µm
+     *  when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */
+    axesLabels(vol) {
+        const hx = vol.width / 2;
+        const hy = vol.height / 2;
+        const hz = vol.depth / 2;
+        // Measured from the IMAGE's own extent, never from the world box: the box is a
+        // shape (and for a physically sized volume it is already in µm, so reading a
+        // pixel count off it and multiplying by mpp would scale the label twice).
+        const { px, mpp } = this.imageExtent();
+        const len = (n, um) => (um > 0 ? formatLength(n * um, 'µm') : `${n} px`);
+        return [
+            { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },
+            { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },
+            // Physical when the stack declares its slice spacing (`mppZ`) — a resampled
+            // volume knows how thick it is; a plain z-stack can only say how many slices.
+            { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },
+        ];
+    }
+    /**
+     * The image's declared extent in pixels/slices, and its physical spacing per
+     * axis in µm (0 = undeclared, and then that axis reads in pixels).
+     *
+     * One place, because the volume world box and the axis labels have to agree
+     * about what the image's real dimensions are — the sampled grid is decimated and
+     * says nothing about either.
+     */
+    imageExtent() {
+        const info = this.ctx.info();
+        const meta = info?.imageMeta?.[0];
+        const dims = this.dims;
+        const desc = this.ctx.tiles.currentDescriptor(info);
+        const mppX = desc?.mppX || meta?.mppX || 0;
+        return {
+            px: [
+                desc?.width ?? meta?.x ?? dims?.width ?? 1,
+                desc?.height ?? meta?.y ?? dims?.height ?? 1,
+                stackDepth(info) || dims?.depth || 1,
+            ],
+            // A descriptor that reports only mppX is square-pixel by convention, which is
+            // what the 2D scale bar already assumes of it.
+            mpp: [mppX, desc?.mppY || meta?.mppY || mppX, desc?.mppZ || meta?.mppZ || 0],
+        };
+    }
+    /** The store's colormap, reverse, invert and channel windows → the volume's transfer function:
+     *  colour (channel tint or selected colormap), the intensity window (min/max → contrastLimits)
+     *  and gamma, mirroring the grayscale image's display controls so the histogram pane drives the
+     *  3D render. */
+    followDisplayState() {
+        const { display } = this.ctx;
+        this.displaySub = display.watch((channels) => {
+            const view = this.view;
+            if (!view)
+                return;
+            if (this.multichannel) {
+                // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.
+                view.layers.forEach((_, c) => {
+                    const st = channels.find((s) => s.index === c);
+                    view.updateChannel(c, {
+                        colormap: display.channelTintColormap(st?.color ?? '#ffffff'),
+                        invert: display.invert,
+                        ...(st
+                            ? {
+                                contrastLimits: [st.min, st.max],
+                                gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ
+                                visible: st.visible,
+                            }
+                            : {}),
+                    });
+                });
+            }
+            else {
+                const st = channels[0];
+                view.updateChannel(0, {
+                    colormap: display.volumeColormap(st),
+                    invert: display.invert,
+                    ...(st ? { contrastLimits: [st.min, st.max], gamma: toNapariGamma(st.gamma) } : {}),
+                });
+            }
+        });
+    }
+}
+/**
+ * NAPARI_SCATTER3D (review Appendix B, cluster H): the downsampled voxel grid as a 3D point cloud
+ * coloured by intensity (the napari-js analog of Plotly's voxel scatter3d). Assembles a coarse
+ * volume, then emits a flat-strided sample of voxels (capped at `SCATTER3D_MAX_POINTS`).
+ */
+export class Scatter3dScene {
+    constructor(ctx, info) {
+        this.ctx = ctx;
+        this.info = info;
+        this.layer = null;
+        /** The assembled volume (key 0), for the intensity histogram. */
+        this.channelData = new Map();
+        this.displaySub = null;
+    }
+    async mount() {
+        const { ctx } = this;
+        const res = volumeResolutionFor(ctx.settings.resolutionScale);
+        ctx.stack.loading(true);
+        ctx.stack.progress(0);
+        let vol = null;
+        try {
+            vol = await assemble(ctx, this.info, { maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY), sliceStep: res.sliceStep }, ctx.loading());
+        }
+        finally {
+            ctx.stack.loading(false);
+            ctx.stack.progress(0);
+        }
+        if (!vol || ctx.signal.aborted)
+            return;
+        const { data, width, height, depth } = vol;
+        const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect
+        const total = width * height * depth;
+        const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));
+        const pos = [];
+        const val = [];
+        for (let i = 0; i < total; i += stride) {
+            const x = i % width;
+            const y = Math.floor(i / width) % height;
+            const zi = Math.floor(i / (width * height));
+            pos.push(x, y, zi * zScale);
+            val.push(data[i]);
+        }
+        const st = ctx.store.currentChannelStates()[0];
+        this.layer = ctx.viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {
+            colormap: ctx.display.volumeColormap(st),
+            contrastLimits: [st?.min ?? 0, st?.max ?? 255],
+            invert: ctx.display.invert,
+            size: 3,
+        });
+        ctx.setImageSize(width, height);
+        // Feed the intensity histogram from the assembled volume (key 0).
+        this.channelData.clear();
+        this.channelData.set(0, data);
+        // Store colormap / reverse / invert / channel window → the cloud's colormap + contrast.
+        this.displaySub = ctx.display.watch((channels) => {
+            const layer = this.layer;
+            if (!layer)
+                return;
+            const s = channels[0];
+            layer.colormap = ctx.display.volumeColormap(s);
+            layer.invert = ctx.display.invert;
+            if (s)
+                layer.contrastLimits = [s.min, s.max];
+            ctx.viewer.requestRender();
+        });
+        ctx.tools.scheduleReadback();
+    }
+    /** The whole stack is already on screen: no plane to step. */
+    setZ() {
+        /* nothing to step */
+    }
+    histogram(channel, bins) {
+        return channelHistogram(this.channelData, channel, bins);
+    }
+    surface3dControls() {
+        return this.layer ? surface3dControls(this.ctx, () => null) : null;
+    }
+    dispose() {
+        this.displaySub?.unsubscribe();
+        this.displaySub = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-volume-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-volume-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\nimport { MultiChannelVolumeView, histogramScalar } from 'napari-js';\nimport type { Points3DLayer, VolumeChannel } from 'napari-js';\nimport { formatLength } from 'napari-js/overlays';\nimport type { AxisLabelSpec } from 'napari-js/overlays';\n\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { IIsosurfaceControls, ISurface3dControls } from '../../contracts/visualizer.contract';\nimport { NapariVolumeZHandle } from './napari-volume-z-handle';\nimport { AssembledVolume } from './napari-tile-client';\nimport { TileDescriptor } from '../tile-server';\nimport { Axes3dGizmo, Box3, surface3dControls } from './napari-axes-gizmo';\nimport {\n  SCATTER3D_MAX_POINTS,\n  SCATTER3D_MAX_XY,\n  VOLUME_WORLD_INPLANE_REF,\n  isServerlessMultichannel,\n  stackDepth,\n  tintFor,\n  toIHistogram,\n  toNapariGamma,\n  volumeResolutionFor,\n} from './napari-helpers';\nimport type { NapariScene, SceneContext, VolumeVoxelsOnScreen } from './napari-scene';\nimport { RegionMesh3D, VolumeFrame, VolumeRegionMeshes } from './napari-volume-region-meshes';\nimport { SlicePlanes, VolumeSlicePlanes } from './napari-volume-slice-planes';\nimport { RegionMeshPointer } from './napari-region-mesh-pointer';\n\n/** The intensity histogram of an assembled uint8 channel (or the single grayscale volume, key 0). */\nfunction channelHistogram(data: Map<number, Uint8Array>, channel: number, bins: number): IHistogram | null {\n  if (!data.size) return null;\n  const plane = data.get(channel) ?? data.get(0);\n  return plane ? toIHistogram(histogramScalar(plane, bins, 0, 255)) : null;\n}\n\n/** Assemble `info`'s stack into a uint8 volume under the stack progress bar; null once `loading`\n *  aborts (a Cancel or a new plot). The caller owns the loading flag and takes `loading` once per\n *  load: a Cancel replaces `ctx.loading()`, and a multichannel volume assembles channels in turn. */\nfunction assemble(\n  ctx: SceneContext,\n  info: IImageInfo | undefined,\n  opts: { maxSlice?: number; sliceStep?: number },\n  loading: AbortSignal,\n  channel?: number,\n): Promise<AssembledVolume | null> {\n  return ctx.tiles.assembleVolume(info, opts, channel, {\n    signal: loading,\n    progress: (p) => ctx.stack.progress(p),\n  });\n}\n\n/**\n * NAPARI_VOLUME / NAPARI_ISOSURFACE (review Appendix B, cluster F): the stack assembled into a\n * decimated volume — one additive, tinted `VolumeLayer` per channel for a multichannel image, a\n * single grayscale volume otherwise — with the axes gizmo and the in-view Z-height handle.\n */\nexport class VolumeScene implements NapariScene {\n  /** napari-js high-level view owning the volume layers. */\n  view: MultiChannelVolumeView | null = null;\n  /** True when the volume is composited from per-channel layers (vs a single grayscale volume). */\n  private multichannel = false;\n  /** Volume world box at Z-scale 1 (base) + the sampled voxel depth — enough to recompute the\n   *  Z-axis voxel scale, axes depth, and overlay anchors as the handle stretches Z. */\n  private worldBase: Box3 | null = null;\n  private sampledDepth = 1;\n  private dims: Box3 | null = null;\n  /** Assembled uint8 volume data per channel (key = channel index), kept for the volume intensity\n   *  histogram. Key 0 holds the grayscale/composite volume in the single-channel case. */\n  private readonly channelData = new Map<number, Uint8Array>();\n  gizmo: Axes3dGizmo | null = null;\n  private zHandle: NapariVolumeZHandle | null = null;\n  private displaySub: Subscription | null = null;\n  /** Regions' 3D reconstructions shown in the volume (see {@link setRegionMeshes}). */\n  private readonly regionMeshes: VolumeRegionMeshes;\n  /** The planes of the sections shown beside the volume, marked and draggable in it. */\n  private readonly slicePlanes: VolumeSlicePlanes;\n  /** The image's full size (px, px, slices), which reconstructions are in. */\n  private fullSize: [number, number, number] | null = null;\n  /** Clicks and hover on the reconstructions (with the selection tool). */\n  private meshPointer: RegionMeshPointer | null = null;\n  private toolSub: Subscription | null = null;\n  private selecting = false;\n\n  constructor(\n    private readonly ctx: SceneContext,\n    private readonly info: IImageInfo | undefined,\n    private readonly rendering: 'iso' | 'mip',\n  ) {\n    this.regionMeshes = new VolumeRegionMeshes(ctx.viewer);\n    this.slicePlanes = new VolumeSlicePlanes(ctx.viewer, ctx.host, {\n      onMove: (axis, value) => ctx.inZone(() => ctx.slicePlaneMoved(axis, value)),\n    });\n  }\n\n  /** Show these region reconstructions in the volume (replacing the ones shown). */\n  setRegionMeshes(meshes: readonly RegionMesh3D[]): void {\n    this.regionMeshes.set(meshes);\n  }\n\n  setRegionHighlight(keys: readonly string[]): void {\n    this.regionMeshes.setHighlight(keys);\n  }\n\n  setRegionHidden(keys: readonly string[]): void {\n    this.regionMeshes.setHidden(keys);\n  }\n\n  /** Whether the volume lets every region through (see {@link setRegionsThroughVolume}). */\n  private regionsThrough = false;\n\n  /**\n   * The volume hides the region reconstructions behind what it shows (its brightest sample along\n   * each ray, napari-js's `'translucent'` depth) — the perspective of a region behind the\n   * cerebellum — or, `through`, hides none (`'translucent_no_depth'`): surfaces traced inside its\n   * bright structures, an OCT's layer boundaries in its bright bands, which that depth speckles\n   * or hides. A multichannel volume's channels add up and hide nothing either way.\n   */\n  setRegionsThroughVolume(through: boolean): void {\n    this.regionsThrough = through;\n    this.applyVolumeDepth();\n    this.ctx.viewer.requestRender();\n  }\n\n  private applyVolumeDepth(): void {\n    if (this.multichannel) return;\n    for (const layer of this.view?.layers ?? []) {\n      layer.blending = this.regionsThrough ? 'translucent_no_depth' : 'translucent';\n    }\n  }\n\n  /** Show the planes of the sections beside the volume where they are (null: hide one). */\n  setSlicePlanes(planes: SlicePlanes): void {\n    this.slicePlanes.set(planes);\n  }\n\n  /**\n   * The assembled volume's voxels per channel (key 0: the grayscale one), its frame, and whether\n   * it is a multichannel composite — what the sections beside it are cut from. Null before it is\n   * assembled.\n   */\n  volumeVoxels(): VolumeVoxelsOnScreen | null {\n    const base = this.worldBase;\n    if (!this.dims || !base || !this.fullSize || !this.channelData.size) return null;\n    const depth = base.depth * this.ctx.settings.volumeZScale;\n    return {\n      ...this.dims,\n      channels: this.channelData,\n      multichannel: this.multichannel,\n      frame: { size: this.fullSize, world: [base.width, base.height, depth] },\n    };\n  }\n\n  /**\n   * Picking the reconstructions: with the selection tool armed, a click on one selects its class\n   * (null beside them); resting over one names it, whatever the tool.\n   */\n  private listenToRegionMeshes(): void {\n    const { ctx } = this;\n    if (this.meshPointer) return;\n    this.toolSub = ctx.store.getActiveTool$().subscribe((tool) => (this.selecting = tool === 'select'));\n    this.meshPointer = ctx.outsideZone(\n      () =>\n        new RegionMeshPointer(ctx.canvas, ctx.host, {\n          pickAt: (x, y) => this.regionMeshes.pickAt(x, y),\n          active: () => this.selecting && this.regionMeshes.shown.length > 0,\n          hoverable: () => this.regionMeshes.shown.length > 0,\n          onPick: (key, additive) => ctx.inZone(() => ctx.regionMeshPicked(key, additive)),\n        }),\n    );\n  }\n\n  /** Image px per voxel of the assembled volume (in-plane), or null before it is assembled. */\n  voxelStep(): number | null {\n    return this.fullSize && this.dims ? this.fullSize[0] / Math.max(1, this.dims.width) : null;\n  }\n\n  /** Place the region reconstructions in the volume's world box as it is now. */\n  private frameRegionMeshes(): void {\n    const base = this.worldBase;\n    if (!base || !this.fullSize) return;\n    const depth = base.depth * this.ctx.settings.volumeZScale;\n    const frame: VolumeFrame = { size: this.fullSize, world: [base.width, base.height, depth] };\n    this.regionMeshes.setFrame(frame);\n    this.slicePlanes.setFrame(frame);\n  }\n\n  /**\n   * Assemble and render the volume, then add the axes gizmo + labels and the Z handle and follow\n   * the display state.\n   */\n  async mount(): Promise<void> {\n    const { ctx, info } = this;\n    const loading = ctx.loading(); // bail before rendering on a Cancel / new plot\n    const desc = await ctx.tiles.ensureDescriptor(ctx.info());\n    // Serverless multichannel (tiled:false + channelUrls): no tile descriptor, so\n    // derive the channel count from imageMeta and assemble each band from its own\n    // channelUrls[z][c] plane (fetchImage does the per-channel routing).\n    const simpleMc = isServerlessMultichannel(ctx.tiles.isSimple(info), info);\n    const channelCount = simpleMc ? info!.imageMeta![0].channelCount : (desc?.channels ?? 1);\n    const multichannel = simpleMc || (!!desc?.multichannel && channelCount > 1);\n\n    this.channelData.clear();\n    this.multichannel = multichannel;\n    const view = new MultiChannelVolumeView(ctx.viewer);\n    this.view = view;\n    const { dims, channels } = await this.assembleChannels(desc, channelCount, loading);\n    if (!dims || !channels.length || loading.aborted) return; // cancelled → don't render\n\n    const world = this.worldBox(dims);\n    // Base box (Z-scale = 1) + the sampled depth drive the live Z-height handle below; the persisted\n    // `volumeZScale` (user drag) applies on top so changing resolution keeps the chosen height.\n    this.worldBase = world;\n    this.sampledDepth = Math.max(1, dims.depth);\n    const worldZ = world.depth * ctx.settings.volumeZScale;\n    const voxelSize: [number, number, number] = [\n      world.width / dims.width,\n      world.height / dims.height,\n      worldZ / this.sampledDepth,\n    ];\n    for (const ch of channels) ch.voxelSize = voxelSize;\n\n    view.render(this.multichannel ? 'multichannel' : 'grayscale', channels, { rendering: this.rendering });\n    this.applyVolumeDepth();\n    ctx.setImageSize(dims.width, dims.height);\n    this.dims = dims;\n\n    // 3D coordinate-axes / scale gizmo + labels, sharing the volume's world box so the gizmo tracks\n    // the rendered proportions. Physical scale text still comes from the FULL image extent.\n    const box = { width: world.width, height: world.height, depth: worldZ };\n    this.gizmo = new Axes3dGizmo(ctx.viewer, ctx.host, box, this.axesLabels(box), {\n      visible: ctx.settings.axesVisible,\n    });\n    // In-view drag handle at the TOP END OF THE Z AXIS (the box's min-XY corner, where the blue\n    // \"Z\" axis + label live), so it reads as the Z-height control. Floated a little past the axis\n    // tip (×1.12) so the grip clears the \"Z · …\" label. Drag ↕ to restretch Z live.\n    this.zHandle = new NapariVolumeZHandle(ctx.host, ctx.viewer.camera3d, {\n      topAnchor: () => [\n        -this.worldBase!.width / 2,\n        -this.worldBase!.height / 2,\n        ((this.worldBase!.depth * ctx.settings.volumeZScale) / 2) * 1.12,\n      ],\n      getScale: () => ctx.settings.volumeZScale,\n      setScale: (s) => this.setZScale(s),\n    });\n    this.followDisplayState();\n    this.frameRegionMeshes();\n    this.listenToRegionMeshes();\n  }\n\n  /**\n   * Assemble each channel's volume from the server tiles (or the single grayscale volume) under\n   * the stack progress bar, with the display settings it is drawn with. `dims` is null when\n   * nothing was assembled (a Cancel, a new plot, or no slices).\n   */\n  private async assembleChannels(\n    desc: TileDescriptor | null,\n    channelCount: number,\n    loading: AbortSignal,\n  ): Promise<{ dims: Box3 | null; channels: VolumeChannel[] }> {\n    const { ctx, info } = this;\n    const res = volumeResolutionFor(ctx.settings.resolutionScale);\n    const states = ctx.store.currentChannelStates();\n\n    // Assemble per-channel scalar volumes from the server tiles (jit-specific); the napari-js view\n    // owns the layer orchestration (one additive tinted volume per channel, or a single grayscale\n    // volume). The adapter computes each channel's colormap (incl. the reverse flip) and invert.\n    let dims: Box3 | null = null;\n    const channels: VolumeChannel[] = [];\n    ctx.stack.loading(true);\n    ctx.stack.progress(0);\n    try {\n      if (this.multichannel) {\n        for (let c = 0; c < channelCount; c++) {\n          const vol = await assemble(ctx, info, res, loading, c);\n          if (loading.aborted) break; // a Cancel / new plot: fetch no further channel\n          if (!vol) continue;\n          dims = vol;\n          this.channelData.set(c, vol.data);\n          const st = states.find((s) => s.index === c);\n          const color = st?.color ?? desc?.channelInfo?.[c]?.color ?? tintFor(c);\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: ctx.display.channelTintColormap(color),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n            invert: ctx.display.invert,\n            visible: st?.visible ?? true,\n          });\n        }\n      } else {\n        const vol = await assemble(ctx, info, res, loading);\n        if (vol) {\n          dims = vol;\n          this.channelData.set(0, vol.data);\n          const st = states[0];\n          channels.push({\n            data: vol.data,\n            width: vol.width,\n            height: vol.height,\n            depth: vol.depth,\n            colormap: ctx.display.volumeColormap(st),\n            contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n            gamma: toNapariGamma(st?.gamma), // ImageJ γ → napari-js γ\n            invert: ctx.display.invert,\n          });\n        }\n      }\n    } finally {\n      ctx.stack.loading(false);\n      ctx.stack.progress(0);\n    }\n    return { dims, channels };\n  }\n\n  /** The volume's world box for the assembled `dims`, independent of the decimate factor. */\n  private worldBox(dims: Box3): Box3 {\n    const { ctx } = this;\n    // Resolution-invariant world box; the per-axis `voxelSize` (napari `scale`) maps the sampled\n    // grid onto it.\n    //\n    // A stack that declares its physical spacing on ALL THREE axes gets its true\n    // extent as the world box — the only way anisotropy survives, and what makes a\n    // resampled 40 x 40 x 200 µm volume read as a brain instead of a cube-aspect\n    // brick. It needs none of the reference-box arithmetic: a physical box is\n    // already independent of the decimate factor.\n    //\n    // Everything else keeps that arithmetic. Sizing the box by the sampled voxel\n    // counts made higher in-plane resolution grow X/Y while the depth stayed the\n    // (constant) slice count — so Z appeared to shrink at higher resolution.\n    // Anchoring the in-plane long side to a fixed reference and letting Z span the\n    // full slice count makes the box shape identical at every decimate factor.\n    const meta = ctx.info()?.imageMeta?.[0];\n    const imageDesc = ctx.tiles.currentDescriptor(ctx.info());\n    // The server's descriptor first (it reports a tiled stack's spacing, e.g. a NRRD volume's), else\n    // the image metadata.\n    const mx = imageDesc?.mppX || meta?.mppX;\n    const my = imageDesc?.mppY || meta?.mppY;\n    const mz = imageDesc?.mppZ || meta?.mppZ;\n    const mppXYZ: [number, number, number] | null = mx && my && mz ? [mx, my, mz] : null;\n    // The image's DECLARED pixel dimensions, which is what mpp is per: the sampled\n    // dims are decimated, so sizing a physical box by them would make the world\n    // box depend on the resolution the user happens to be viewing at.\n    const fullW = imageDesc?.width ?? meta?.x ?? dims.width;\n    const fullH = imageDesc?.height ?? meta?.y ?? dims.height;\n    const fullD = stackDepth(ctx.info()) || dims.depth;\n    this.fullSize = [fullW, fullH, fullD];\n    if (mppXYZ) {\n      return {\n        width: fullW * mppXYZ[0],\n        height: fullH * mppXYZ[1],\n        depth: fullD * mppXYZ[2],\n      };\n    }\n    const fullLong = Math.max(1, fullW, fullH);\n    return {\n      width: (fullW * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      height: (fullH * VOLUME_WORLD_INPLANE_REF) / fullLong,\n      depth: fullD,\n    };\n  }\n\n  /**\n   * The whole stack is already on screen: no plane to step. (This used to write `viewer.dims.z`,\n   * which only a tiled 2D image reads — a volume raymarches every slice — and schedule a readback\n   * of a frame that had not changed. The toolbar shows no slice control in volume / isosurface\n   * mode, as Plotly's isosurface ignores the slice too.)\n   */\n  setZ(): void {\n    /* nothing to step */\n  }\n\n  /** The intensity histogram of the assembled (downsampled) uint8 volume for the requested\n   *  channel (multichannel) or the single grayscale volume. */\n  histogram(channel: number, bins: number): IHistogram | null {\n    return channelHistogram(this.channelData, channel, bins);\n  }\n\n  isoControls(): IIsosurfaceControls | null {\n    if (!this.view) return null;\n    return {\n      setIsoRange: (isoMin: number, isoMax: number): void => {\n        // Apply to every channel's volume layer.\n        for (const layer of this.view?.layers ?? []) {\n          layer.contrastLimits = [isoMin, isoMax];\n          layer.rendering = 'iso';\n          layer.isoThreshold = 0.5;\n        }\n        this.ctx.viewer.requestRender();\n      },\n    };\n  }\n\n  surface3dControls(): ISurface3dControls | null {\n    return this.view ? surface3dControls(this.ctx, () => this.gizmo) : null;\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n    this.gizmo?.destroy();\n    this.gizmo = null;\n    this.zHandle?.destroy();\n    this.zHandle = null;\n    this.regionMeshes.clear();\n    this.slicePlanes.destroy();\n    this.meshPointer?.destroy();\n    this.meshPointer = null;\n    this.toolSub?.unsubscribe();\n    this.toolSub = null;\n    this.worldBase = null;\n  }\n\n  /**\n   * Restretch the volume's Z height live (driven by the in-view {@link NapariVolumeZHandle}). Only\n   * the per-axis `voxelSize` / axes depth change — the voxel textures are untouched — so dragging is\n   * smooth. `factor` is relative to the volume's natural proportions (1). Persists across re-mounts\n   * (resolution changes) so the chosen height sticks.\n   */\n  setZScale(factor: number): void {\n    const { settings } = this.ctx;\n    settings.volumeZScale = Math.min(10, Math.max(0.1, factor));\n    const base = this.worldBase;\n    if (!base || !this.view) return;\n    const worldZ = base.depth * settings.volumeZScale;\n    const vsZ = worldZ / this.sampledDepth;\n    for (const layer of this.view.layers) {\n      const [sx, sy] = layer.voxelSize;\n      layer.voxelSize = [sx, sy, vsZ];\n    }\n    this.gizmo?.setDepth(worldZ, this.axesLabels({ width: base.width, height: base.height, depth: worldZ }));\n    this.zHandle?.reposition();\n    this.frameRegionMeshes();\n    this.ctx.viewer.requestRender();\n  }\n\n  /** The X/Y/Z axis-end label specs for the gizmo. Anchors are in the volume's centred world box\n   *  (matching the AxesLayer geometry); the scale text reflects the FULL image extent — physical µm\n   *  when µm/pixel is known, else pixel (X/Y) / slice (Z) counts. */\n  axesLabels(vol: Box3): AxisLabelSpec[] {\n    const hx = vol.width / 2;\n    const hy = vol.height / 2;\n    const hz = vol.depth / 2;\n    // Measured from the IMAGE's own extent, never from the world box: the box is a\n    // shape (and for a physically sized volume it is already in µm, so reading a\n    // pixel count off it and multiplying by mpp would scale the label twice).\n    const { px, mpp } = this.imageExtent();\n    const len = (n: number, um: number): string => (um > 0 ? formatLength(n * um, 'µm') : `${n} px`);\n    return [\n      { anchor: [hx, -hy, -hz], text: `X · ${len(px[0], mpp[0])}`, color: '#ed4545' },\n      { anchor: [-hx, hy, -hz], text: `Y · ${len(px[1], mpp[1])}`, color: '#4dd959' },\n      // Physical when the stack declares its slice spacing (`mppZ`) — a resampled\n      // volume knows how thick it is; a plain z-stack can only say how many slices.\n      { anchor: [-hx, -hy, hz], text: `Z · ${len(px[2], mpp[2])}`, color: '#668cff' },\n    ];\n  }\n\n  /**\n   * The image's declared extent in pixels/slices, and its physical spacing per\n   * axis in µm (0 = undeclared, and then that axis reads in pixels).\n   *\n   * One place, because the volume world box and the axis labels have to agree\n   * about what the image's real dimensions are — the sampled grid is decimated and\n   * says nothing about either.\n   */\n  private imageExtent(): { px: [number, number, number]; mpp: [number, number, number] } {\n    const info = this.ctx.info();\n    const meta = info?.imageMeta?.[0];\n    const dims = this.dims;\n    const desc = this.ctx.tiles.currentDescriptor(info);\n    const mppX = desc?.mppX || meta?.mppX || 0;\n    return {\n      px: [\n        desc?.width ?? meta?.x ?? dims?.width ?? 1,\n        desc?.height ?? meta?.y ?? dims?.height ?? 1,\n        stackDepth(info) || dims?.depth || 1,\n      ],\n      // A descriptor that reports only mppX is square-pixel by convention, which is\n      // what the 2D scale bar already assumes of it.\n      mpp: [mppX, desc?.mppY || meta?.mppY || mppX, desc?.mppZ || meta?.mppZ || 0],\n    };\n  }\n\n  /** The store's colormap, reverse, invert and channel windows → the volume's transfer function:\n   *  colour (channel tint or selected colormap), the intensity window (min/max → contrastLimits)\n   *  and gamma, mirroring the grayscale image's display controls so the histogram pane drives the\n   *  3D render. */\n  private followDisplayState(): void {\n    const { display } = this.ctx;\n    this.displaySub = display.watch((channels) => {\n      const view = this.view;\n      if (!view) return;\n      if (this.multichannel) {\n        // Each channel's layer is tinted by its colour and gets its own window/gamma/visibility.\n        view.layers.forEach((_, c) => {\n          const st = channels.find((s) => s.index === c);\n          view.updateChannel(c, {\n            colormap: display.channelTintColormap(st?.color ?? '#ffffff'),\n            invert: display.invert,\n            ...(st\n              ? {\n                  contrastLimits: [st.min, st.max] as [number, number],\n                  gamma: toNapariGamma(st.gamma), // ImageJ γ → napari-js γ\n                  visible: st.visible,\n                }\n              : {}),\n          });\n        });\n      } else {\n        const st = channels[0];\n        view.updateChannel(0, {\n          colormap: display.volumeColormap(st),\n          invert: display.invert,\n          ...(st ? { contrastLimits: [st.min, st.max] as [number, number], gamma: toNapariGamma(st.gamma) } : {}),\n        });\n      }\n    });\n  }\n}\n\n/**\n * NAPARI_SCATTER3D (review Appendix B, cluster H): the downsampled voxel grid as a 3D point cloud\n * coloured by intensity (the napari-js analog of Plotly's voxel scatter3d). Assembles a coarse\n * volume, then emits a flat-strided sample of voxels (capped at `SCATTER3D_MAX_POINTS`).\n */\nexport class Scatter3dScene implements NapariScene {\n  private layer: Points3DLayer | null = null;\n  /** The assembled volume (key 0), for the intensity histogram. */\n  private readonly channelData = new Map<number, Uint8Array>();\n  private displaySub: Subscription | null = null;\n\n  constructor(\n    private readonly ctx: SceneContext,\n    private readonly info: IImageInfo | undefined,\n  ) {}\n\n  async mount(): Promise<void> {\n    const { ctx } = this;\n    const res = volumeResolutionFor(ctx.settings.resolutionScale);\n    ctx.stack.loading(true);\n    ctx.stack.progress(0);\n    let vol: AssembledVolume | null = null;\n    try {\n      vol = await assemble(\n        ctx,\n        this.info,\n        { maxSlice: Math.min(res.maxSlice, SCATTER3D_MAX_XY), sliceStep: res.sliceStep },\n        ctx.loading(),\n      );\n    } finally {\n      ctx.stack.loading(false);\n      ctx.stack.progress(0);\n    }\n    if (!vol || ctx.signal.aborted) return;\n\n    const { data, width, height, depth } = vol;\n    const zScale = Math.max(width, height) / Math.max(1, depth); // ≈ cubic aspect\n    const total = width * height * depth;\n    const stride = Math.max(1, Math.ceil(total / SCATTER3D_MAX_POINTS));\n    const pos: number[] = [];\n    const val: number[] = [];\n    for (let i = 0; i < total; i += stride) {\n      const x = i % width;\n      const y = Math.floor(i / width) % height;\n      const zi = Math.floor(i / (width * height));\n      pos.push(x, y, zi * zScale);\n      val.push(data[i]);\n    }\n\n    const st = ctx.store.currentChannelStates()[0];\n    this.layer = ctx.viewer.addPoints3D(new Float32Array(pos), new Float32Array(val), {\n      colormap: ctx.display.volumeColormap(st),\n      contrastLimits: [st?.min ?? 0, st?.max ?? 255],\n      invert: ctx.display.invert,\n      size: 3,\n    });\n    ctx.setImageSize(width, height);\n    // Feed the intensity histogram from the assembled volume (key 0).\n    this.channelData.clear();\n    this.channelData.set(0, data);\n    // Store colormap / reverse / invert / channel window → the cloud's colormap + contrast.\n    this.displaySub = ctx.display.watch((channels) => {\n      const layer = this.layer;\n      if (!layer) return;\n      const s = channels[0];\n      layer.colormap = ctx.display.volumeColormap(s);\n      layer.invert = ctx.display.invert;\n      if (s) layer.contrastLimits = [s.min, s.max];\n      ctx.viewer.requestRender();\n    });\n    ctx.tools.scheduleReadback();\n  }\n\n  /** The whole stack is already on screen: no plane to step. */\n  setZ(): void {\n    /* nothing to step */\n  }\n\n  histogram(channel: number, bins: number): IHistogram | null {\n    return channelHistogram(this.channelData, channel, bins);\n  }\n\n  surface3dControls(): ISurface3dControls | null {\n    return this.layer ? surface3dControls(this.ctx, () => null) : null;\n  }\n\n  dispose(): void {\n    this.displaySub?.unsubscribe();\n    this.displaySub = null;\n  }\n}\n"]}