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

package/esm2022/lib/implementations/napari-js/napari-spatial-3d-scene.mjs

@@ -0,0 +1,769 @@
+import { PointPicker, colormapFromLut } from 'napari-js';
+import { ScaleBarOverlay } from 'napari-js/overlays';
+import { findColumnMeta, isCategoricalColumn, } from '../../contracts/spatial-dataset.contract';
+import { DEFAULT_MUTED_OPACITY, resolveCategoryColors } from '../../spatial/spatial-encoding';
+import { emptySelection, maskToIndices } from '../../spatial/spatial-selection';
+import { defaultSigma, densityGrid } from '../../spatial/spatial-density';
+import { observationsInSection, sectionsOf } from '../../spatial/spatial-sections';
+import { encodeExpressionVolume, fieldContrastWindow, } from '../../spatial/spatial-expression';
+import { computeExpressionVolumeAsync, rasterizeDensityAsync } from '../../workers/spatial-math';
+import { Supersede } from '../../util/supersede';
+import { isAbortError } from '../tile-server';
+import { GENE_MAP_SIGMA, GENE_MAP_VOLUME_STRIDE, SPATIAL_3D_BASE_SIZE, SPATIAL_SELECTED_SIZE_SCALE, encodeSpatial3dCategorical, encodeSpatial3dContinuous, gatherColors, rankDensityGroups, spatialFlatColormap, totalDensityGroup, } from './napari-spatial-encoding';
+import { HOVER_RADIUS_PX } from './napari-spatial-hover';
+import { SpatialSceneBase } from './napari-spatial-scene';
+/**
+ * SPATIAL_OMICS_3D (review Appendix B, cluster K): observations as a 3D point cloud under the
+ * orbit camera, with the dataset's reference volume around it, per-cluster density volumes and the
+ * 3D gene map.
+ *
+ * Thinner than the 2D scene: there is no tissue image to render (a registered volume like the
+ * Allen CCF has no single reference plane), so no readback and no navigator; the 3D scale bar
+ * follows the dataset (see {@link installScaleBar}). The region tools work in SCREEN space through
+ * the tool bridge's 3D interaction — a lasso selects the cells under it, and an orbit clears the
+ * shape while keeping the selection. The first 3D layer added frames the camera (`fit3d: 'once'`).
+ */
+export class Spatial3dScene extends SpatialSceneBase {
+    constructor(ctx, session) {
+        super(ctx, session, true);
+        /** The 3D point cloud. One layer: selection is a per-point alpha on it, not a second. */
+        this.points = null;
+        this.layerKey = null;
+        /** Interleaved x,y,z, cached so a colour change does not re-walk 3.7M observations. */
+        this.positions = null;
+        /** Identity of the scalars currently uploaded — see {@link rebuild}. */
+        this.scalarKey = null;
+        /** Observation indices the cached positions belong to, in the same order; null when every
+         *  observation is drawn. Without it a projection built from the positions is indexed by DRAWN
+         *  order and silently attributes each point to the wrong observation as soon as a section is
+         *  isolated. */
+        this.drawn = null;
+        /** The anatomical volume the cloud sits inside, when the dataset has one. */
+        this.volume = null;
+        this.volumeKey = null;
+        /** Per-cluster density volumes drawn alongside the cloud, and what they were
+         *  built from — rasterising is seconds of work, so it must not repeat for a
+         *  change that cannot affect the field. */
+        this.densityLayers = [];
+        this.densityKey = null;
+        /** The 3D gene map's volume layer and the inputs it was coloured for (its field is cached in
+         *  the session, on a clock of its own). */
+        this.geneMapLayer = null;
+        this.geneMapKey = null;
+        /** Offset applied to observation coordinates to sit them in the volume's box. */
+        this.origin = [0, 0, 0];
+        /**
+         * napari-js's depth-aware pick over the cloud, and the projection the ROI selection reads. It
+         * owns the caching policy: re-project lazily, on the first pick after the camera, the canvas or
+         * the cloud's data moved (never on the camera event, so an orbit drag pays nothing), into
+         * reused buffers, with a screen index once the cloud is large enough.
+         */
+        this.picker = null;
+        this.scaleBar = null;
+        /** Dataset the scale bar was built for. */
+        this.scaleBarKey = null;
+        /** The density rasterisation and the 3D gene-map estimate in flight (off the main thread
+         *  past the worker threshold, SPATIAL-19): a new key supersedes — and aborts — the previous
+         *  one; a rebuild that leaves the key alone lets it finish. */
+        this.densityLoads = new Supersede();
+        this.geneMapLoads = new Supersede();
+        /** The store's invert setting, which the density volumes follow (no other subscription of
+         *  this scene carries it). */
+        this.invertSub = null;
+    }
+    async mount() {
+        // Before the spatial subscription, so the first build already reads the current value.
+        this.invertSub = this.ctx.display.watchInvert((invert) => {
+            // A live setter: the volumes restyle, nothing is rasterised again.
+            for (const layer of this.densityLayers)
+                layer.invert = invert;
+            this.ctx.viewer.requestRender();
+        });
+        this.ctx.tools.install3dInteraction(this.ctx.viewer, this.ctx.host);
+        this.hover.install(this.ctx.host);
+        this.subscribeSpatial();
+    }
+    /** The observations' own z is on screen: there is no plane to step. */
+    setZ() {
+        /* nothing to step */
+    }
+    /** A cloud has no intensity distribution for the histogram pane. */
+    histogram() {
+        return null;
+    }
+    /**
+     * Every observation's position on the canvas under the current 3D camera (for the ROI
+     * selection), indexed by observation with NaN for anything not drawn. Null before the cloud
+     * is built.
+     *
+     * The projection is the picker's (see {@link picker}); what is left is the part that is
+     * genuinely this adapter's: SCATTERING the drawn subset back into observation order. The cloud
+     * holds only the points of the displayed section, in its own packing; every consumer indexes by
+     * observation. NaN stands for "not on screen", which is also the right answer for an
+     * observation whose section is hidden.
+     */
+    screenProjection(obs) {
+        const projected = this.picker?.projected();
+        if (!projected)
+            return null;
+        const drawn = this.drawn;
+        const { screen } = projected;
+        const count = screen.length >> 1;
+        const out = new Float32Array(obs.count * 2).fill(NaN);
+        for (let k = 0; k < count; k++) {
+            const i = drawn ? drawn[k] : k;
+            if (i >= obs.count)
+                continue;
+            out[i * 2] = screen[k * 2];
+            out[i * 2 + 1] = screen[k * 2 + 1];
+        }
+        return out;
+    }
+    dispose() {
+        this.disposeSpatial();
+        this.invertSub?.unsubscribe();
+        this.invertSub = null;
+        this.densityLoads.cancel();
+        this.geneMapLoads.cancel();
+        this.scaleBar?.dispose();
+        this.scaleBar = null;
+        // Drop the cached interleaved coordinates too: holding 3.7M x 3 floats after
+        // a teardown is ~45MB of retained heap for a scene that no longer exists.
+        this.positions = null;
+        this.setPicker(null);
+    }
+    /**
+     * The observation under a client position: the FRONT-most marker within `slackPx` of the
+     * pointer (ties by distance), as napari-js's {@link PointPicker} picks it. That matters more
+     * than it sounds: the renderer depth-tests the billboards, and in a 3.7M-point cloud the cursor
+     * covers many of them — picking the one nearest the cursor's centre regularly names a cell that
+     * something else is drawn over. The picker also takes each point's radius from the layer's
+     * per-point `sizes`, so a selected marker, drawn larger, is as large to the pointer.
+     */
+    pickObservation(clientX, clientY, slackPx) {
+        const picker = this.picker;
+        if (!picker)
+            return -1;
+        const rect = this.ctx.canvas.getBoundingClientRect();
+        const k = picker.pick(clientX - rect.left, clientY - rect.top, slackPx);
+        if (k < 0)
+            return -1;
+        return this.drawn ? this.drawn[k] : k;
+    }
+    /** Replace the cloud's picker (null: no cloud), releasing the old one's camera listener. */
+    setPicker(points) {
+        this.picker?.dispose();
+        this.picker = points
+            ? new PointPicker(this.ctx.viewer, points, {
+                // The largest radius a pick here can claim: the hover slack times the scale a SELECTED
+                // marker is drawn at. It decides whether a marker straddling the canvas edge is found.
+                maxReach: HOVER_RADIUS_PX * SPATIAL_SELECTED_SIZE_SCALE,
+            })
+            : null;
+    }
+    /**
+     * Scale bar for the cloud, measured at the ORBIT PIVOT.
+     *
+     * A perspective camera has no single scale — things farther away are smaller — so a bar can
+     * only be true at one depth. The pivot is the honest choice: it is what the camera is framing,
+     * what a zoom moves towards, and where the eye is anyway. napari's own 3D scale bar works the
+     * same way.
+     *
+     * napari-js's `ScaleBarOverlay` in `'3d'` mode measures there: CSS px per world unit is the
+     * reciprocal of `Camera3D.worldPerPixel` — the scale `Camera3D.pan` uses to track the cursor.
+     * The bar then converts through `micronsPerUnit`, and draws nothing at all when the dataset does
+     * not declare one, because a bar labelled in microns over unknown units would read as a
+     * measurement.
+     */
+    installScaleBar(dataset) {
+        this.scaleBar?.dispose();
+        this.scaleBar = null;
+        const micronsPerUnit = dataset?.micronsPerUnit;
+        if (!micronsPerUnit || micronsPerUnit <= 0)
+            return;
+        this.scaleBar = new ScaleBarOverlay(this.ctx.host, this.ctx.viewer, {
+            unitPerWorld: micronsPerUnit,
+            mode: '3d',
+        });
+    }
+    /** (Re)build the 3D point cloud for the current dataset + view state. */
+    async rebuild(dataset, view, selection = emptySelection()) {
+        const viewer = this.ctx.viewer;
+        const task = this.rebuilds.next();
+        // Resolve the scalar encoding BEFORE touching the scene, for the same reason
+        // the 2D path does: a gene fetch can fail or be superseded, and dropping the
+        // layer first would blank the view.
+        let enc = null;
+        if (dataset) {
+            const endLoading = this.ctx.badge.begin('Observations');
+            try {
+                enc = await this.scalarEncoding(view);
+            }
+            catch (err) {
+                console.warn('[napari-js] spatial 3D colouring failed — falling back to a flat colour', err);
+                enc = null;
+            }
+            finally {
+                endLoading();
+            }
+        }
+        if (!task())
+            return;
+        const obs = dataset?.observations;
+        // No z means nothing to draw in 3D. The plot type is gated on `requiresSpatial3d`
+        // so this should be unreachable from the UI, but a host can set the type directly.
+        if (!dataset || !obs || obs.count === 0 || !obs.z) {
+            this.removeLayers(viewer);
+            return;
+        }
+        // Anatomy first: on a scene's FIRST layer napari frames the orbit camera, and
+        // the reference volume is the framing we want — the brain, not the outermost
+        // stray segmentation. Every later add keeps the pose instead (napari-js `fit3d: 'once'`).
+        await this.ensureVolume(viewer, dataset, view);
+        if (!task())
+            return;
+        // Then the cluster density volumes, which can set the centring offset when
+        // there is no reference volume — so before any position is computed from it.
+        await this.ensureDensityVolumes(viewer, dataset, view, selection);
+        if (!task())
+            return;
+        // Then the gene map, which shares the reference volume's lattice — so it goes
+        // after anything that can still move the centring offset.
+        await this.ensureGeneMap(viewer, dataset, view, selection);
+        if (!task())
+            return;
+        // Scale depends on the dataset's declared unit, so it waits for the dataset
+        // rather than being set up at mount time.
+        if (dataset.id !== this.scaleBarKey) {
+            this.scaleBarKey = dataset.id;
+            this.installScaleBar(dataset);
+        }
+        // The reference volume is hidden, not removed: it also fixes the centring
+        // offset every position is computed from, and re-fetching a 100 MB template
+        // to un-hide it would make a checkbox feel like a load.
+        if (this.volume) {
+            this.volume.visible = view.showVolume;
+            this.volume.opacity = view.volumeOpacity;
+        }
+        this.drawCloud(viewer, dataset, view, selection, enc);
+    }
+    /**
+     * Draw the point cloud: a new layer for new geometry (a dataset or a section), the colour
+     * source swapped in place otherwise; then the selection and the visibility.
+     */
+    drawCloud(viewer, dataset, view, selection, enc) {
+        const obs = dataset.observations;
+        const scale = view.pointScale > 0 ? view.pointScale : 1;
+        const size = SPATIAL_3D_BASE_SIZE * scale;
+        // A categorical colouring is per-point RGBA, which wins over the scalars; the flat colormap
+        // and zero scalars stand behind it, as they do for "nothing to colour by".
+        const scalar = enc?.kind === 'scalars' ? enc : null;
+        const colors = enc?.kind === 'colors' ? enc.colors : null;
+        const scalars = scalar?.values ?? new Float32Array(obs.count);
+        const colormap = scalar?.colormap ?? spatialFlatColormap();
+        const contrastLimits = scalar?.contrastLimits ?? [0, 1];
+        const { shown, key, scalarKey } = cloudSubset(dataset, view);
+        if (key !== this.layerKey) {
+            // New geometry: interleave x,y,z (the layer's documented layout, x-fastest)
+            // and cache it, so later colour changes rebuild the layer without walking
+            // the observations again.
+            this.positions = this.cloudPositions(obs, shown);
+            this.drawn = shown;
+        }
+        // The scalars have to follow the geometry: a per-observation vector against one
+        // section's positions would colour each cell by a stranger's value. So do the colours.
+        const valuesFor = () => (shown ? Float32Array.from(shown, (i) => scalars[i]) : scalars);
+        const colorsFor = () => (colors ? gatherColors(colors, shown ?? undefined) : null);
+        if (!this.points || key !== this.layerKey) {
+            // New GEOMETRY — a different dataset, or a different section — so a new layer.
+            if (this.points)
+                viewer.layers.remove(this.points);
+            this.layerKey = key;
+            this.scalarKey = scalarKey;
+            this.points = viewer.addPoints3D(this.positions, valuesFor(), {
+                name: 'observations',
+                colormap,
+                contrastLimits,
+                size,
+                colors: colorsFor() ?? undefined,
+            });
+            this.setPicker(this.points);
+        }
+        else {
+            if (scalarKey !== this.scalarKey) {
+                // A change of colour SOURCE, which used to mean discarding the layer and building
+                // another — and, because adding a 3D layer reframes, a camera jump to undo as well.
+                // napari-js ≥ 0.14 lets the scalars be replaced in place — the setter bumps the
+                // layer's dataVersion so the visual re-uploads — and the positions have not moved,
+                // so there is nothing for the camera to reframe.
+                this.scalarKey = scalarKey;
+                this.points.values = valuesFor();
+                this.points.colors = colorsFor();
+            }
+            this.points.colormap = colormap;
+            this.points.contrastLimits = contrastLimits;
+            this.points.size = size;
+        }
+        const cloud = this.points;
+        if (cloud) {
+            cloud.opacity = view.opacity;
+            this.applySelection(cloud, selection, shown, obs.count);
+        }
+        // Last, so it also covers a layer this pass just created.
+        if (this.points)
+            this.points.visible = view.showPoints;
+        viewer.requestRender();
+    }
+    /** Interleaved x,y,z of the `shown` observations (null: all of them), offset by {@link origin}. */
+    cloudPositions(obs, shown) {
+        // rebuild() draws only a dataset whose observations have a z.
+        const z = obs.z;
+        const [ox, oy, oz] = this.origin;
+        const count = shown ? shown.length : obs.count;
+        const positions = new Float32Array(count * 3);
+        for (let k = 0; k < count; k++) {
+            const i = shown ? shown[k] : k;
+            positions[k * 3] = obs.x[i] + ox;
+            positions[k * 3 + 1] = obs.y[i] + oy;
+            positions[k * 3 + 2] = z[i] + oz;
+        }
+        return positions;
+    }
+    /**
+     * Selection is a PER-POINT alpha, in the one layer.
+     *
+     * It used to be a second layer: with a single opacity for the whole cloud, the only way
+     * to highlight a subset was to draw it again on top at full opacity while the parent
+     * dropped to the muted level. That second layer had to be kept in step through every
+     * colormap, window and size change, and the two then depth-sorted against each other as
+     * separate draws. Per-point alphas and sizes give the same reading — muted cloud, bright
+     * selection, slightly larger so a small one is findable inside 3.7M points — in one.
+     *
+     * `shown` is the drawn subset (null: every one of the `total` observations), so the alphas
+     * follow the drawn order.
+     */
+    applySelection(cloud, selection, shown, total) {
+        if (selection.count === 0 || selection.mask.length !== total) {
+            cloud.alphas = null;
+            cloud.sizes = null;
+            return;
+        }
+        const shownCount = shown ? shown.length : total;
+        const alphas = new Float32Array(shownCount);
+        const sizes = new Float32Array(shownCount);
+        for (let k = 0; k < shownCount; k++) {
+            const i = shown ? shown[k] : k;
+            const picked = !!selection.mask[i];
+            alphas[k] = picked ? 1 : DEFAULT_MUTED_OPACITY;
+            sizes[k] = picked ? SPATIAL_SELECTED_SIZE_SCALE : 1;
+        }
+        cloud.alphas = alphas;
+        cloud.sizes = sizes;
+    }
+    /**
+     * The **3D gene map**: the active gene's expression over the whole sectioned
+     * specimen, as one raymarched volume.
+     *
+     * Two things it can be, and the panel's `Volume rendering` toggle picks which:
+     *
+     *  - **sheets** — exactly the planes that were imaged, each carrying that
+     *    slide's own 2D gene map, with the gaps between sections empty. A stack of
+     *    measured fields, at their true z.
+     *  - **volume** — the same fields smoothed along z, so the planes between the
+     *    sections carry an interpolated value. An estimate, and drawn as a
+     *    translucent cloud for the same reason the density volumes are.
+     *
+     * One `VolumeLayer` rather than a textured quad per section: an `ImageLayer`
+     * renders only at `ndisplay === 2`, so 53 sheets in the orbit view would need a
+     * new layer type upstream — while a scalar volume whose z sampling already IS
+     * the section spacing expresses the sheets exactly, and the same lattice then
+     * gives the interpolated version for free.
+     *
+     * Estimated on the reference volume's own lattice (`densityGrid` at stride 1),
+     * so the field lands voxel-for-voxel on the anatomy and needs no offset — a
+     * `VolumeLayer` has no translate, and napari centres both boxes on the world
+     * origin.
+     */
+    async ensureGeneMap(viewer, dataset, view, selection) {
+        const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;
+        const port = this.session.port;
+        const cache = this.session.geneMapVolume;
+        const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;
+        const clip = view.percentileClip ?? [0.01, 0.99];
+        const obs = dataset.observations;
+        // A volume built from ONE section would smear that slide through the whole
+        // depth, so the section restriction only applies to the sheets.
+        const interpolate = !!view.geneMapVolume;
+        const sections = sectionsOf(obs);
+        const section = !interpolate && view.geneMapSection != null && sections && sections.length > 0
+            ? sections[Math.max(0, Math.min(sections.length - 1, view.geneMapSection))]
+            : null;
+        const fieldKey = gene
+            ? [
+                dataset.id,
+                gene,
+                smoothing,
+                section ?? 'all',
+                interpolate ? 'vol' : 'sheets',
+                this.session.selectionRev(selection),
+            ].join('|')
+            : null;
+        const key = fieldKey
+            ? [
+                fieldKey,
+                clip.join(','),
+                view.logScale ? 'log' : 'lin',
+                view.geneMapOpacity,
+                this.ctx.display.continuousColormapKey(view),
+            ].join('|')
+            : null;
+        if (key === this.geneMapKey)
+            return;
+        if (this.geneMapLayer) {
+            viewer.layers.remove(this.geneMapLayer);
+            this.geneMapLayer = null;
+        }
+        this.geneMapKey = key;
+        if (!key || !gene || !port) {
+            cache.field = null;
+            cache.key = null;
+            return;
+        }
+        // Coarsened in-plane but NOT along z: the sheets need one plane per imaged
+        // section, while the field they carry is smooth by construction and gains
+        // nothing from the template's 40 µm detail. At full resolution the estimate is
+        // a 5.7M-voxel pair of blurs — seconds of work for a checkbox; an eighth of the
+        // voxels is an eighth of the work.
+        const grid = densityGrid(dataset, GENE_MAP_VOLUME_STRIDE, 128, 1);
+        if (!grid)
+            return;
+        if (fieldKey !== cache.key) {
+            const load = this.geneMapLoads.next();
+            let values;
+            try {
+                values = await port.getFeatureVector(gene);
+            }
+            catch (err) {
+                console.warn(`[napari-js] 3D gene map: "${gene}" unavailable`, err);
+                this.geneMapKey = null;
+                return;
+            }
+            if (!load() || this.geneMapKey !== key)
+                return;
+            const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;
+            // In-plane σ is a PHYSICAL bandwidth, anchored to the reference volume's own
+            // voxel — the resolution the 2D map estimates at — so a sheet and the 2D
+            // view of the same section are the same field whatever lattice this is
+            // rasterised on. Along z it is the density path's 1.5 voxels: the smallest σ
+            // that bridges one section gap.
+            const inPlane = dataset.volume?.voxelSize ?? grid.voxelSize;
+            let field;
+            try {
+                field = await computeExpressionVolumeAsync(obs, grid, {
+                    sigma: [
+                        inPlane[0] * GENE_MAP_SIGMA * smoothing,
+                        inPlane[1] * GENE_MAP_SIGMA * smoothing,
+                        grid.voxelSize[2] * 1.5 * smoothing,
+                    ],
+                    values,
+                    indices: section != null ? observationsInSection(obs, section) : inSelection,
+                    interpolate,
+                }, { signal: load.signal });
+            }
+            catch (err) {
+                if (isAbortError(err))
+                    return; // superseded by a newer map, or the scene went away
+                throw err;
+            }
+            if (!load() || this.geneMapKey !== key)
+                return;
+            cache.field = field;
+            cache.key = fieldKey;
+        }
+        const field = cache.field;
+        if (!field)
+            return;
+        // The high end over the MEASURED voxels only (the unmeasured zeros would pull it down and
+        // saturate the map), but the low end stays 0: in a volume the value is also the opacity and
+        // 0 reads as "nothing here", so starting at the lowest measured value would erase it.
+        const [, hi] = fieldContrastWindow(field, clip[0], clip[1]);
+        const lo = 0;
+        const data = encodeExpressionVolume(field, [lo, hi], { log: view.logScale });
+        const lut = this.ctx.display.spatialLut(view);
+        this.geneMapLayer = viewer.addVolume(data, field.width, field.height, field.depth, {
+            name: `gene map · ${gene}${interpolate ? ' · volume' : ''}`,
+            colormap: colormapFromLut(`gene-map-${gene}`, lut),
+            // The encoding already applied the window, so the layer must not apply a
+            // second one: 0..255 is the whole of what it was given.
+            contrastLimits: [0, 255],
+            rendering: 'translucent',
+            // Additive like the density volumes, and for the same reason: the sheets
+            // have to read THROUGH each other and through the anatomy, which a
+            // translucent blend would occlude one sheet at a time.
+            blending: 'additive',
+            opacity: view.geneMapOpacity,
+            voxelSize: grid.voxelSize,
+        });
+        viewer.requestRender();
+    }
+    /**
+     * Cluster density volumes: each cluster rasterised into a smooth scalar field and
+     * raymarched alongside the cloud, tinted with the cluster's own legend colour.
+     *
+     * This is what makes a serially sectioned dataset readable as an anatomical
+     * distribution. The cloud shows measured cells and nothing else — but at 200 µm
+     * section spacing the eye cannot integrate a stack of discs into a shape, and
+     * every gap reads as absence. A density field is a different object from a cell:
+     * an estimate, defined between the imaged planes, drawn as a translucent cloud so
+     * it cannot be mistaken for measurement. Individual cells are never interpolated —
+     * consecutive sections sample different cells, so there is nothing to interpolate
+     * along.
+     *
+     * One volume per cluster rather than one for everything: additive blending is what
+     * makes two clusters' territories comparable, and a single blended field would
+     * answer no question anyone asks of a taxonomy. Capped at `DENSITY_MAX_CLUSTERS` by cell
+     * count.
+     *
+     * Keyed so it rebuilds only when the field would actually differ — the dataset,
+     * the colour column, the bandwidth, or the selection.
+     */
+    async ensureDensityVolumes(viewer, dataset, view, selection) {
+        const on = !!view.densityVolume && !!dataset.observations.z;
+        const smoothing = view.densitySmoothing > 0 ? view.densitySmoothing : 1;
+        const column = view.colorBy?.kind === 'column' ? view.colorBy.name : null;
+        // The selection enters the key by IDENTITY, not by count: two different ROIs
+        // holding the same number of cells would otherwise look like the same key and
+        // leave the previous ROI's fields on screen.
+        const key = on
+            ? [dataset.id, column ?? 'all', smoothing, this.session.selectionRev(selection)].join('|')
+            : null;
+        if (key === this.densityKey)
+            return;
+        for (const layer of this.densityLayers)
+            viewer.layers.remove(layer);
+        this.densityLayers = [];
+        this.densityKey = key;
+        const load = this.densityLoads.next();
+        if (!key)
+            return;
+        const grid = densityGrid(dataset);
+        if (!grid)
+            return;
+        // With no reference volume there is no offset yet, and a VolumeLayer has no
+        // translate — napari centres its box on the world origin. So the POINTS move by
+        // half the density box, exactly as they do for a reference volume, and the
+        // cached geometry is invalidated because that offset just changed.
+        if (!this.volume) {
+            this.origin = [
+                -(grid.width * grid.voxelSize[0]) / 2,
+                -(grid.height * grid.voxelSize[1]) / 2,
+                -(grid.depth * grid.voxelSize[2]) / 2,
+            ];
+            this.layerKey = null;
+        }
+        let groups;
+        try {
+            groups = await this.densityGroups(dataset, column, selection);
+        }
+        catch (err) {
+            console.warn('[napari-js] density volumes: column unavailable', err);
+            this.densityKey = null;
+            return;
+        }
+        if (!load() || this.densityKey !== key)
+            return;
+        const sigma = defaultSigma(grid, smoothing);
+        // Additive blending SUMS, so a fixed per-layer opacity blows out to white as
+        // soon as several broad clusters overlap — six subclasses at 0.55 each turned
+        // the brain into one cyan mass. Splitting the budget keeps n fully overlapping
+        // peaks inside the display's range, so overlap reads as overlap; a single
+        // cluster still gets the full 0.55. It only mitigates: a translucent raymarch
+        // integrates along the ray, so clusters that are ubiquitous rather than
+        // regional (the largest subclasses are glia, which are everywhere) still pile
+        // up, and one cluster at a time is the readable way to look at those.
+        const opacity = Math.min(0.55, 0.9 / Math.max(1, groups.length));
+        let fields;
+        try {
+            // Off the main thread past the worker threshold; the clusters queue on one worker.
+            fields = await Promise.all(groups.map((group) => rasterizeDensityAsync(dataset.observations, grid, { sigma, indices: group.indices }, { signal: load.signal })));
+        }
+        catch (err) {
+            if (isAbortError(err))
+                return; // superseded by a newer key, or the scene went away
+            throw err;
+        }
+        if (!load() || this.densityKey !== key)
+            return;
+        groups.forEach((group, i) => {
+            const data = fields[i];
+            // A cluster with nothing on the grid draws no layer, rather than an empty box.
+            if (!data)
+                return;
+            this.densityLayers.push(viewer.addVolume(data, grid.width, grid.height, grid.depth, {
+                name: `density · ${group.name}`,
+                colormap: this.ctx.display.channelTintColormap(group.color),
+                invert: this.ctx.display.invert,
+                // Translucent, not MIP: a cluster's interior is the readable part, and MIP
+                // would flatten every cloud to its brightest shell.
+                rendering: 'translucent',
+                opacity,
+                // Additive, so two clusters overlapping read as both being there instead
+                // of the nearer one hiding the other.
+                blending: 'additive',
+                voxelSize: grid.voxelSize,
+            }));
+        });
+        viewer.requestRender();
+    }
+    /**
+     * The clusters to rasterise: the categories of the active categorical colouring,
+     * biggest first and capped, each with its legend colour, restricted to the current selection
+     * when there is one. With no categorical colouring there is one group — total cell density,
+     * which is a real question on its own ("where is the tissue dense?") and the honest thing to
+     * show when the view is not encoding a taxonomy.
+     */
+    async densityGroups(dataset, column, selection) {
+        const port = this.session.port;
+        const meta = column ? findColumnMeta(dataset, column) : undefined;
+        if (!port || !column || !meta || meta.kind !== 'categorical')
+            return [totalDensityGroup(selection)];
+        const loaded = await port.getColumn(column);
+        if (!isCategoricalColumn(loaded))
+            return [];
+        return rankDensityGroups(column, loaded, dataset.observations.count, selection);
+    }
+    /**
+     * Add (or keep) the dataset's reference volume, and derive the offset that sits the
+     * observations inside it.
+     *
+     * `VolumeLayer` has no translate: napari-js maps the volume's unit cube to a world box
+     * **centred on the origin**, sized `dims x voxelSize`. The observations, by contract, are in
+     * the volume's own frame with its near corner at the coordinate origin. So the two only line
+     * up if the POINTS move — by half the box — which is what {@link origin} is.
+     *
+     * A failed or absent volume is not fatal: the cloud renders on its own, at its own
+     * coordinates, and the camera frames the points instead.
+     */
+    async ensureVolume(viewer, dataset, view) {
+        const meta = dataset.volume;
+        const port = this.session.port;
+        const key = meta ? `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}` : null;
+        if (key && key === this.volumeKey)
+            return;
+        if (this.volume) {
+            viewer.layers.remove(this.volume);
+            this.volume = null;
+            this.volumeKey = null;
+        }
+        this.origin = [0, 0, 0];
+        if (!meta || !port?.getVolume)
+            return;
+        let voxels;
+        try {
+            voxels = await port.getVolume();
+        }
+        catch (err) {
+            console.warn('[napari-js] reference volume unavailable — drawing the cloud alone', err);
+            return;
+        }
+        if (this.ctx.signal.aborted)
+            return;
+        const [vx, vy, vz] = meta.voxelSize;
+        this.volumeKey = key;
+        this.volume = viewer.addVolume(voxels, meta.width, meta.height, meta.depth, {
+            name: 'reference volume',
+            colormap: 'gray',
+            // MIP would draw the brightest voxel along each ray, which for an averaged
+            // template means a flat white shell that hides the cloud. Translucent lets
+            // the points read through the tissue, which is the entire point of drawing
+            // them together.
+            rendering: 'translucent',
+            opacity: view.volumeOpacity,
+            voxelSize: [vx, vy, vz],
+        });
+        // Half the box, negated: the observations' origin is the box's near corner,
+        // and the box is centred on the world origin.
+        this.origin = [-(meta.width * vx) / 2, -(meta.height * vy) / 2, -(meta.depth * vz) / 2];
+        // Force a geometry rebuild: the offset changed, so cached positions are stale.
+        this.layerKey = null;
+    }
+    /** Drop every layer of the cloud (the dataset went away, or has no z). */
+    removeLayers(viewer) {
+        for (const layer of [this.points, this.volume, this.geneMapLayer, ...this.densityLayers]) {
+            if (layer)
+                viewer.layers.remove(layer);
+        }
+        this.geneMapLayer = null;
+        this.geneMapKey = null;
+        this.session.geneMapVolume.field = null;
+        this.session.geneMapVolume.key = null;
+        this.densityLayers = [];
+        this.densityKey = null;
+        // The scene is gone, so the next 3D layer should frame itself again. That used to be
+        // `spatialFramed = null` next to a hand-rolled save/restore; the renderer owns the
+        // policy now, and this is the same statement addressed to it.
+        viewer.resetFit3D();
+        this.volume = null;
+        this.volumeKey = null;
+        this.origin = [0, 0, 0];
+        this.points = null;
+        this.setPicker(null);
+        this.layerKey = null;
+        this.scalarKey = null;
+        this.positions = null;
+        this.drawn = null;
+    }
+    /**
+     * What colours the cloud.
+     *
+     * Continuous data goes through the active colormap with the same percentile window the 2D path
+     * uses. Categorical data is one RGBA per point from the column's palette, so any number of
+     * categories keeps its own colour — see `encodeSpatial3dCategorical`.
+     */
+    async scalarEncoding(view) {
+        const port = this.session.port;
+        const colorBy = view.colorBy;
+        if (!port || !colorBy)
+            return null;
+        if (colorBy.kind === 'column') {
+            const column = await port.getColumn(colorBy.name);
+            if (isCategoricalColumn(column)) {
+                return encodeSpatial3dCategorical(column.codes, resolveCategoryColors(column.meta));
+            }
+            return this.encodeContinuous(column.values, view);
+        }
+        return this.encodeContinuous(await port.getFeatureVector(colorBy.name), view);
+    }
+    /** Continuous values → the active colormap over a percentile-clipped window. */
+    encodeContinuous(source, view) {
+        return encodeSpatial3dContinuous(source, view, this.ctx.display.spatialLut(view), this.session.contrastWindows);
+    }
+}
+/**
+ * The observations the cloud draws, and the keys of its geometry and of its colour source.
+ *
+ * One imaged section, or the whole stack (`shown` null). The subset IS the geometry, so it
+ * belongs in the geometry key rather than being re-derived per frame — and an out-of-range
+ * index is clamped rather than dropping the cloud, because the section count changes with the
+ * dataset while the view state persists. The scalars' identity is tracked separately from the
+ * geometry's (`colorBy` plus the transforms feeding the encoding): a new colour source swaps
+ * `values` in place (napari-js ≥ 0.14), while a new geometry needs a new layer.
+ */
+function cloudSubset(dataset, view) {
+    const obs = dataset.observations;
+    const sections = sectionsOf(obs);
+    const section = view.pointSection != null && sections && sections.length > 0
+        ? sections[Math.max(0, Math.min(sections.length - 1, view.pointSection))]
+        : null;
+    const shown = section != null ? observationsInSection(obs, section) : null;
+    const key = `${dataset.id}:${obs.count}:${section ?? 'all'}`;
+    const clip = view.percentileClip ?? [0.01, 0.99];
+    const scalarKey = [
+        key,
+        view.colorBy ? `${view.colorBy.kind}:${view.colorBy.name}` : 'flat',
+        view.logScale ? 'log' : 'lin',
+        clip.join(','),
+    ].join('|');
+    return { shown, key, scalarKey };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-3d-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-3d-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\nimport { PointPicker, colormapFromLut } from 'napari-js';\nimport type { Points3DLayer, Viewer, VolumeLayer } from 'napari-js';\nimport { ScaleBarOverlay } from 'napari-js/overlays';\n\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport {\n  SpatialColumn,\n  SpatialDataset,\n  SpatialObservations,\n  findColumnMeta,\n  isCategoricalColumn,\n} from '../../contracts/spatial-dataset.contract';\nimport { SpatialViewState } from '../../contracts/display-types';\nimport { DEFAULT_MUTED_OPACITY, resolveCategoryColors } from '../../spatial/spatial-encoding';\nimport { SpatialSelectionMask, emptySelection, maskToIndices } from '../../spatial/spatial-selection';\nimport { defaultSigma, densityGrid } from '../../spatial/spatial-density';\nimport { observationsInSection, sectionsOf } from '../../spatial/spatial-sections';\nimport {\n  ExpressionVolumeField,\n  encodeExpressionVolume,\n  fieldContrastWindow,\n} from '../../spatial/spatial-expression';\nimport { computeExpressionVolumeAsync, rasterizeDensityAsync } from '../../workers/spatial-math';\nimport { Supersede } from '../../util/supersede';\nimport { isAbortError } from '../tile-server';\nimport {\n  DensityGroup,\n  GENE_MAP_SIGMA,\n  GENE_MAP_VOLUME_STRIDE,\n  SPATIAL_3D_BASE_SIZE,\n  SPATIAL_SELECTED_SIZE_SCALE,\n  Spatial3dEncoding,\n  Spatial3dScalars,\n  encodeSpatial3dCategorical,\n  encodeSpatial3dContinuous,\n  gatherColors,\n  rankDensityGroups,\n  spatialFlatColormap,\n  totalDensityGroup,\n} from './napari-spatial-encoding';\nimport { HOVER_RADIUS_PX } from './napari-spatial-hover';\nimport { SpatialSceneBase, SpatialSession } from './napari-spatial-scene';\nimport type { NapariScene, SceneContext } from './napari-scene';\n\n/**\n * SPATIAL_OMICS_3D (review Appendix B, cluster K): observations as a 3D point cloud under the\n * orbit camera, with the dataset's reference volume around it, per-cluster density volumes and the\n * 3D gene map.\n *\n * Thinner than the 2D scene: there is no tissue image to render (a registered volume like the\n * Allen CCF has no single reference plane), so no readback and no navigator; the 3D scale bar\n * follows the dataset (see {@link installScaleBar}). The region tools work in SCREEN space through\n * the tool bridge's 3D interaction — a lasso selects the cells under it, and an orbit clears the\n * shape while keeping the selection. The first 3D layer added frames the camera (`fit3d: 'once'`).\n */\nexport class Spatial3dScene extends SpatialSceneBase implements NapariScene {\n  /** The 3D point cloud. One layer: selection is a per-point alpha on it, not a second. */\n  private points: Points3DLayer | null = null;\n  private layerKey: string | null = null;\n  /** Interleaved x,y,z, cached so a colour change does not re-walk 3.7M observations. */\n  private positions: Float32Array | null = null;\n  /** Identity of the scalars currently uploaded — see {@link rebuild}. */\n  private scalarKey: string | null = null;\n  /** Observation indices the cached positions belong to, in the same order; null when every\n   *  observation is drawn. Without it a projection built from the positions is indexed by DRAWN\n   *  order and silently attributes each point to the wrong observation as soon as a section is\n   *  isolated. */\n  private drawn: Uint32Array | null = null;\n  /** The anatomical volume the cloud sits inside, when the dataset has one. */\n  private volume: VolumeLayer | null = null;\n  private volumeKey: string | null = null;\n  /** Per-cluster density volumes drawn alongside the cloud, and what they were\n   *  built from — rasterising is seconds of work, so it must not repeat for a\n   *  change that cannot affect the field. */\n  private densityLayers: VolumeLayer[] = [];\n  private densityKey: string | null = null;\n  /** The 3D gene map's volume layer and the inputs it was coloured for (its field is cached in\n   *  the session, on a clock of its own). */\n  private geneMapLayer: VolumeLayer | null = null;\n  private geneMapKey: string | null = null;\n  /** Offset applied to observation coordinates to sit them in the volume's box. */\n  private origin: [number, number, number] = [0, 0, 0];\n  /**\n   * napari-js's depth-aware pick over the cloud, and the projection the ROI selection reads. It\n   * owns the caching policy: re-project lazily, on the first pick after the camera, the canvas or\n   * the cloud's data moved (never on the camera event, so an orbit drag pays nothing), into\n   * reused buffers, with a screen index once the cloud is large enough.\n   */\n  private picker: PointPicker | null = null;\n  private scaleBar: ScaleBarOverlay | null = null;\n  /** Dataset the scale bar was built for. */\n  private scaleBarKey: string | null = null;\n  /** The density rasterisation and the 3D gene-map estimate in flight (off the main thread\n   *  past the worker threshold, SPATIAL-19): a new key supersedes — and aborts — the previous\n   *  one; a rebuild that leaves the key alone lets it finish. */\n  private readonly densityLoads = new Supersede();\n  private readonly geneMapLoads = new Supersede();\n  /** The store's invert setting, which the density volumes follow (no other subscription of\n   *  this scene carries it). */\n  private invertSub: Subscription | null = null;\n\n  constructor(ctx: SceneContext, session: SpatialSession) {\n    super(ctx, session, true);\n  }\n\n  async mount(): Promise<void> {\n    // Before the spatial subscription, so the first build already reads the current value.\n    this.invertSub = this.ctx.display.watchInvert((invert) => {\n      // A live setter: the volumes restyle, nothing is rasterised again.\n      for (const layer of this.densityLayers) layer.invert = invert;\n      this.ctx.viewer.requestRender();\n    });\n    this.ctx.tools.install3dInteraction(this.ctx.viewer, this.ctx.host);\n    this.hover.install(this.ctx.host);\n    this.subscribeSpatial();\n  }\n\n  /** The observations' own z is on screen: there is no plane to step. */\n  setZ(): void {\n    /* nothing to step */\n  }\n\n  /** A cloud has no intensity distribution for the histogram pane. */\n  histogram(): IHistogram | null {\n    return null;\n  }\n\n  /**\n   * Every observation's position on the canvas under the current 3D camera (for the ROI\n   * selection), indexed by observation with NaN for anything not drawn. Null before the cloud\n   * is built.\n   *\n   * The projection is the picker's (see {@link picker}); what is left is the part that is\n   * genuinely this adapter's: SCATTERING the drawn subset back into observation order. The cloud\n   * holds only the points of the displayed section, in its own packing; every consumer indexes by\n   * observation. NaN stands for \"not on screen\", which is also the right answer for an\n   * observation whose section is hidden.\n   */\n  screenProjection(obs: SpatialObservations): Float32Array | null {\n    const projected = this.picker?.projected();\n    if (!projected) return null;\n    const drawn = this.drawn;\n    const { screen } = projected;\n    const count = screen.length >> 1;\n    const out = new Float32Array(obs.count * 2).fill(NaN);\n    for (let k = 0; k < count; k++) {\n      const i = drawn ? drawn[k] : k;\n      if (i >= obs.count) continue;\n      out[i * 2] = screen[k * 2];\n      out[i * 2 + 1] = screen[k * 2 + 1];\n    }\n    return out;\n  }\n\n  dispose(): void {\n    this.disposeSpatial();\n    this.invertSub?.unsubscribe();\n    this.invertSub = null;\n    this.densityLoads.cancel();\n    this.geneMapLoads.cancel();\n    this.scaleBar?.dispose();\n    this.scaleBar = null;\n    // Drop the cached interleaved coordinates too: holding 3.7M x 3 floats after\n    // a teardown is ~45MB of retained heap for a scene that no longer exists.\n    this.positions = null;\n    this.setPicker(null);\n  }\n\n  /**\n   * The observation under a client position: the FRONT-most marker within `slackPx` of the\n   * pointer (ties by distance), as napari-js's {@link PointPicker} picks it. That matters more\n   * than it sounds: the renderer depth-tests the billboards, and in a 3.7M-point cloud the cursor\n   * covers many of them — picking the one nearest the cursor's centre regularly names a cell that\n   * something else is drawn over. The picker also takes each point's radius from the layer's\n   * per-point `sizes`, so a selected marker, drawn larger, is as large to the pointer.\n   */\n  protected pickObservation(clientX: number, clientY: number, slackPx: number): number {\n    const picker = this.picker;\n    if (!picker) return -1;\n    const rect = this.ctx.canvas.getBoundingClientRect();\n    const k = picker.pick(clientX - rect.left, clientY - rect.top, slackPx);\n    if (k < 0) return -1;\n    return this.drawn ? this.drawn[k] : k;\n  }\n\n  /** Replace the cloud's picker (null: no cloud), releasing the old one's camera listener. */\n  private setPicker(points: Points3DLayer | null): void {\n    this.picker?.dispose();\n    this.picker = points\n      ? new PointPicker(this.ctx.viewer, points, {\n          // The largest radius a pick here can claim: the hover slack times the scale a SELECTED\n          // marker is drawn at. It decides whether a marker straddling the canvas edge is found.\n          maxReach: HOVER_RADIUS_PX * SPATIAL_SELECTED_SIZE_SCALE,\n        })\n      : null;\n  }\n\n  /**\n   * Scale bar for the cloud, measured at the ORBIT PIVOT.\n   *\n   * A perspective camera has no single scale — things farther away are smaller — so a bar can\n   * only be true at one depth. The pivot is the honest choice: it is what the camera is framing,\n   * what a zoom moves towards, and where the eye is anyway. napari's own 3D scale bar works the\n   * same way.\n   *\n   * napari-js's `ScaleBarOverlay` in `'3d'` mode measures there: CSS px per world unit is the\n   * reciprocal of `Camera3D.worldPerPixel` — the scale `Camera3D.pan` uses to track the cursor.\n   * The bar then converts through `micronsPerUnit`, and draws nothing at all when the dataset does\n   * not declare one, because a bar labelled in microns over unknown units would read as a\n   * measurement.\n   */\n  private installScaleBar(dataset: SpatialDataset | null): void {\n    this.scaleBar?.dispose();\n    this.scaleBar = null;\n    const micronsPerUnit = dataset?.micronsPerUnit;\n    if (!micronsPerUnit || micronsPerUnit <= 0) return;\n    this.scaleBar = new ScaleBarOverlay(this.ctx.host, this.ctx.viewer, {\n      unitPerWorld: micronsPerUnit,\n      mode: '3d',\n    });\n  }\n\n  /** (Re)build the 3D point cloud for the current dataset + view state. */\n  protected async rebuild(\n    dataset: SpatialDataset | null,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask = emptySelection(),\n  ): Promise<void> {\n    const viewer = this.ctx.viewer;\n    const task = this.rebuilds.next();\n\n    // Resolve the scalar encoding BEFORE touching the scene, for the same reason\n    // the 2D path does: a gene fetch can fail or be superseded, and dropping the\n    // layer first would blank the view.\n    let enc: Spatial3dEncoding | null = null;\n    if (dataset) {\n      const endLoading = this.ctx.badge.begin('Observations');\n      try {\n        enc = await this.scalarEncoding(view);\n      } catch (err) {\n        console.warn('[napari-js] spatial 3D colouring failed — falling back to a flat colour', err);\n        enc = null;\n      } finally {\n        endLoading();\n      }\n    }\n    if (!task()) return;\n\n    const obs = dataset?.observations;\n    // No z means nothing to draw in 3D. The plot type is gated on `requiresSpatial3d`\n    // so this should be unreachable from the UI, but a host can set the type directly.\n    if (!dataset || !obs || obs.count === 0 || !obs.z) {\n      this.removeLayers(viewer);\n      return;\n    }\n\n    // Anatomy first: on a scene's FIRST layer napari frames the orbit camera, and\n    // the reference volume is the framing we want — the brain, not the outermost\n    // stray segmentation. Every later add keeps the pose instead (napari-js `fit3d: 'once'`).\n    await this.ensureVolume(viewer, dataset, view);\n    if (!task()) return;\n    // Then the cluster density volumes, which can set the centring offset when\n    // there is no reference volume — so before any position is computed from it.\n    await this.ensureDensityVolumes(viewer, dataset, view, selection);\n    if (!task()) return;\n    // Then the gene map, which shares the reference volume's lattice — so it goes\n    // after anything that can still move the centring offset.\n    await this.ensureGeneMap(viewer, dataset, view, selection);\n    if (!task()) return;\n    // Scale depends on the dataset's declared unit, so it waits for the dataset\n    // rather than being set up at mount time.\n    if (dataset.id !== this.scaleBarKey) {\n      this.scaleBarKey = dataset.id;\n      this.installScaleBar(dataset);\n    }\n\n    // The reference volume is hidden, not removed: it also fixes the centring\n    // offset every position is computed from, and re-fetching a 100 MB template\n    // to un-hide it would make a checkbox feel like a load.\n    if (this.volume) {\n      this.volume.visible = view.showVolume;\n      this.volume.opacity = view.volumeOpacity;\n    }\n    this.drawCloud(viewer, dataset, view, selection, enc);\n  }\n\n  /**\n   * Draw the point cloud: a new layer for new geometry (a dataset or a section), the colour\n   * source swapped in place otherwise; then the selection and the visibility.\n   */\n  private drawCloud(\n    viewer: Viewer,\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n    enc: Spatial3dEncoding | null,\n  ): void {\n    const obs = dataset.observations;\n    const scale = view.pointScale > 0 ? view.pointScale : 1;\n    const size = SPATIAL_3D_BASE_SIZE * scale;\n    // A categorical colouring is per-point RGBA, which wins over the scalars; the flat colormap\n    // and zero scalars stand behind it, as they do for \"nothing to colour by\".\n    const scalar = enc?.kind === 'scalars' ? enc : null;\n    const colors = enc?.kind === 'colors' ? enc.colors : null;\n    const scalars = scalar?.values ?? new Float32Array(obs.count);\n    const colormap = scalar?.colormap ?? spatialFlatColormap();\n    const contrastLimits: [number, number] = scalar?.contrastLimits ?? [0, 1];\n    const { shown, key, scalarKey } = cloudSubset(dataset, view);\n\n    if (key !== this.layerKey) {\n      // New geometry: interleave x,y,z (the layer's documented layout, x-fastest)\n      // and cache it, so later colour changes rebuild the layer without walking\n      // the observations again.\n      this.positions = this.cloudPositions(obs, shown);\n      this.drawn = shown;\n    }\n\n    // The scalars have to follow the geometry: a per-observation vector against one\n    // section's positions would colour each cell by a stranger's value. So do the colours.\n    const valuesFor = () => (shown ? Float32Array.from(shown, (i) => scalars[i]) : scalars);\n    const colorsFor = () => (colors ? (gatherColors(colors, shown ?? undefined) as Float32Array) : null);\n\n    if (!this.points || key !== this.layerKey) {\n      // New GEOMETRY — a different dataset, or a different section — so a new layer.\n      if (this.points) viewer.layers.remove(this.points);\n      this.layerKey = key;\n      this.scalarKey = scalarKey;\n      this.points = viewer.addPoints3D(this.positions!, valuesFor(), {\n        name: 'observations',\n        colormap,\n        contrastLimits,\n        size,\n        colors: colorsFor() ?? undefined,\n      });\n      this.setPicker(this.points);\n    } else {\n      if (scalarKey !== this.scalarKey) {\n        // A change of colour SOURCE, which used to mean discarding the layer and building\n        // another — and, because adding a 3D layer reframes, a camera jump to undo as well.\n        // napari-js ≥ 0.14 lets the scalars be replaced in place — the setter bumps the\n        // layer's dataVersion so the visual re-uploads — and the positions have not moved,\n        // so there is nothing for the camera to reframe.\n        this.scalarKey = scalarKey;\n        this.points.values = valuesFor();\n        this.points.colors = colorsFor();\n      }\n      this.points.colormap = colormap;\n      this.points.contrastLimits = contrastLimits;\n      this.points.size = size;\n    }\n\n    const cloud = this.points;\n    if (cloud) {\n      cloud.opacity = view.opacity;\n      this.applySelection(cloud, selection, shown, obs.count);\n    }\n    // Last, so it also covers a layer this pass just created.\n    if (this.points) this.points.visible = view.showPoints;\n    viewer.requestRender();\n  }\n\n  /** Interleaved x,y,z of the `shown` observations (null: all of them), offset by {@link origin}. */\n  private cloudPositions(obs: SpatialObservations, shown: Uint32Array | null): Float32Array {\n    // rebuild() draws only a dataset whose observations have a z.\n    const z = obs.z!;\n    const [ox, oy, oz] = this.origin;\n    const count = shown ? shown.length : obs.count;\n    const positions = new Float32Array(count * 3);\n    for (let k = 0; k < count; k++) {\n      const i = shown ? shown[k] : k;\n      positions[k * 3] = obs.x[i] + ox;\n      positions[k * 3 + 1] = obs.y[i] + oy;\n      positions[k * 3 + 2] = z[i] + oz;\n    }\n    return positions;\n  }\n\n  /**\n   * Selection is a PER-POINT alpha, in the one layer.\n   *\n   * It used to be a second layer: with a single opacity for the whole cloud, the only way\n   * to highlight a subset was to draw it again on top at full opacity while the parent\n   * dropped to the muted level. That second layer had to be kept in step through every\n   * colormap, window and size change, and the two then depth-sorted against each other as\n   * separate draws. Per-point alphas and sizes give the same reading — muted cloud, bright\n   * selection, slightly larger so a small one is findable inside 3.7M points — in one.\n   *\n   * `shown` is the drawn subset (null: every one of the `total` observations), so the alphas\n   * follow the drawn order.\n   */\n  private applySelection(\n    cloud: Points3DLayer,\n    selection: SpatialSelectionMask,\n    shown: Uint32Array | null,\n    total: number,\n  ): void {\n    if (selection.count === 0 || selection.mask.length !== total) {\n      cloud.alphas = null;\n      cloud.sizes = null;\n      return;\n    }\n    const shownCount = shown ? shown.length : total;\n    const alphas = new Float32Array(shownCount);\n    const sizes = new Float32Array(shownCount);\n    for (let k = 0; k < shownCount; k++) {\n      const i = shown ? shown[k] : k;\n      const picked = !!selection.mask[i];\n      alphas[k] = picked ? 1 : DEFAULT_MUTED_OPACITY;\n      sizes[k] = picked ? SPATIAL_SELECTED_SIZE_SCALE : 1;\n    }\n    cloud.alphas = alphas;\n    cloud.sizes = sizes;\n  }\n\n  /**\n   * The **3D gene map**: the active gene's expression over the whole sectioned\n   * specimen, as one raymarched volume.\n   *\n   * Two things it can be, and the panel's `Volume rendering` toggle picks which:\n   *\n   *  - **sheets** — exactly the planes that were imaged, each carrying that\n   *    slide's own 2D gene map, with the gaps between sections empty. A stack of\n   *    measured fields, at their true z.\n   *  - **volume** — the same fields smoothed along z, so the planes between the\n   *    sections carry an interpolated value. An estimate, and drawn as a\n   *    translucent cloud for the same reason the density volumes are.\n   *\n   * One `VolumeLayer` rather than a textured quad per section: an `ImageLayer`\n   * renders only at `ndisplay === 2`, so 53 sheets in the orbit view would need a\n   * new layer type upstream — while a scalar volume whose z sampling already IS\n   * the section spacing expresses the sheets exactly, and the same lattice then\n   * gives the interpolated version for free.\n   *\n   * Estimated on the reference volume's own lattice (`densityGrid` at stride 1),\n   * so the field lands voxel-for-voxel on the anatomy and needs no offset — a\n   * `VolumeLayer` has no translate, and napari centres both boxes on the world\n   * origin.\n   */\n  private async ensureGeneMap(\n    viewer: Viewer,\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n  ): Promise<void> {\n    const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;\n    const port = this.session.port;\n    const cache = this.session.geneMapVolume;\n    const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;\n    const clip = view.percentileClip ?? [0.01, 0.99];\n    const obs = dataset.observations;\n    // A volume built from ONE section would smear that slide through the whole\n    // depth, so the section restriction only applies to the sheets.\n    const interpolate = !!view.geneMapVolume;\n    const sections = sectionsOf(obs);\n    const section =\n      !interpolate && view.geneMapSection != null && sections && sections.length > 0\n        ? sections[Math.max(0, Math.min(sections.length - 1, view.geneMapSection))]\n        : null;\n\n    const fieldKey = gene\n      ? [\n          dataset.id,\n          gene,\n          smoothing,\n          section ?? 'all',\n          interpolate ? 'vol' : 'sheets',\n          this.session.selectionRev(selection),\n        ].join('|')\n      : null;\n    const key = fieldKey\n      ? [\n          fieldKey,\n          clip.join(','),\n          view.logScale ? 'log' : 'lin',\n          view.geneMapOpacity,\n          this.ctx.display.continuousColormapKey(view),\n        ].join('|')\n      : null;\n    if (key === this.geneMapKey) return;\n\n    if (this.geneMapLayer) {\n      viewer.layers.remove(this.geneMapLayer);\n      this.geneMapLayer = null;\n    }\n    this.geneMapKey = key;\n    if (!key || !gene || !port) {\n      cache.field = null;\n      cache.key = null;\n      return;\n    }\n\n    // Coarsened in-plane but NOT along z: the sheets need one plane per imaged\n    // section, while the field they carry is smooth by construction and gains\n    // nothing from the template's 40 µm detail. At full resolution the estimate is\n    // a 5.7M-voxel pair of blurs — seconds of work for a checkbox; an eighth of the\n    // voxels is an eighth of the work.\n    const grid = densityGrid(dataset, GENE_MAP_VOLUME_STRIDE, 128, 1);\n    if (!grid) return;\n\n    if (fieldKey !== cache.key) {\n      const load = this.geneMapLoads.next();\n      let values: Float32Array;\n      try {\n        values = await port.getFeatureVector(gene);\n      } catch (err) {\n        console.warn(`[napari-js] 3D gene map: \"${gene}\" unavailable`, err);\n        this.geneMapKey = null;\n        return;\n      }\n      if (!load() || this.geneMapKey !== key) return;\n      const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;\n      // In-plane σ is a PHYSICAL bandwidth, anchored to the reference volume's own\n      // voxel — the resolution the 2D map estimates at — so a sheet and the 2D\n      // view of the same section are the same field whatever lattice this is\n      // rasterised on. Along z it is the density path's 1.5 voxels: the smallest σ\n      // that bridges one section gap.\n      const inPlane = dataset.volume?.voxelSize ?? grid.voxelSize;\n      let field: ExpressionVolumeField | null;\n      try {\n        field = await computeExpressionVolumeAsync(\n          obs,\n          grid,\n          {\n            sigma: [\n              inPlane[0] * GENE_MAP_SIGMA * smoothing,\n              inPlane[1] * GENE_MAP_SIGMA * smoothing,\n              grid.voxelSize[2] * 1.5 * smoothing,\n            ],\n            values,\n            indices: section != null ? observationsInSection(obs, section) : inSelection,\n            interpolate,\n          },\n          { signal: load.signal },\n        );\n      } catch (err) {\n        if (isAbortError(err)) return; // superseded by a newer map, or the scene went away\n        throw err;\n      }\n      if (!load() || this.geneMapKey !== key) return;\n      cache.field = field;\n      cache.key = fieldKey;\n    }\n    const field = cache.field;\n    if (!field) return;\n\n    // The high end over the MEASURED voxels only (the unmeasured zeros would pull it down and\n    // saturate the map), but the low end stays 0: in a volume the value is also the opacity and\n    // 0 reads as \"nothing here\", so starting at the lowest measured value would erase it.\n    const [, hi] = fieldContrastWindow(field, clip[0], clip[1]);\n    const lo = 0;\n    const data = encodeExpressionVolume(field, [lo, hi], { log: view.logScale });\n    const lut = this.ctx.display.spatialLut(view);\n    this.geneMapLayer = viewer.addVolume(data, field.width, field.height, field.depth, {\n      name: `gene map · ${gene}${interpolate ? ' · volume' : ''}`,\n      colormap: colormapFromLut(`gene-map-${gene}`, lut),\n      // The encoding already applied the window, so the layer must not apply a\n      // second one: 0..255 is the whole of what it was given.\n      contrastLimits: [0, 255],\n      rendering: 'translucent',\n      // Additive like the density volumes, and for the same reason: the sheets\n      // have to read THROUGH each other and through the anatomy, which a\n      // translucent blend would occlude one sheet at a time.\n      blending: 'additive',\n      opacity: view.geneMapOpacity,\n      voxelSize: grid.voxelSize,\n    });\n    viewer.requestRender();\n  }\n\n  /**\n   * Cluster density volumes: each cluster rasterised into a smooth scalar field and\n   * raymarched alongside the cloud, tinted with the cluster's own legend colour.\n   *\n   * This is what makes a serially sectioned dataset readable as an anatomical\n   * distribution. The cloud shows measured cells and nothing else — but at 200 µm\n   * section spacing the eye cannot integrate a stack of discs into a shape, and\n   * every gap reads as absence. A density field is a different object from a cell:\n   * an estimate, defined between the imaged planes, drawn as a translucent cloud so\n   * it cannot be mistaken for measurement. Individual cells are never interpolated —\n   * consecutive sections sample different cells, so there is nothing to interpolate\n   * along.\n   *\n   * One volume per cluster rather than one for everything: additive blending is what\n   * makes two clusters' territories comparable, and a single blended field would\n   * answer no question anyone asks of a taxonomy. Capped at `DENSITY_MAX_CLUSTERS` by cell\n   * count.\n   *\n   * Keyed so it rebuilds only when the field would actually differ — the dataset,\n   * the colour column, the bandwidth, or the selection.\n   */\n  private async ensureDensityVolumes(\n    viewer: Viewer,\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n  ): Promise<void> {\n    const on = !!view.densityVolume && !!dataset.observations.z;\n    const smoothing = view.densitySmoothing > 0 ? view.densitySmoothing : 1;\n    const column = view.colorBy?.kind === 'column' ? view.colorBy.name : null;\n    // The selection enters the key by IDENTITY, not by count: two different ROIs\n    // holding the same number of cells would otherwise look like the same key and\n    // leave the previous ROI's fields on screen.\n    const key = on\n      ? [dataset.id, column ?? 'all', smoothing, this.session.selectionRev(selection)].join('|')\n      : null;\n    if (key === this.densityKey) return;\n\n    for (const layer of this.densityLayers) viewer.layers.remove(layer);\n    this.densityLayers = [];\n    this.densityKey = key;\n    const load = this.densityLoads.next();\n    if (!key) return;\n\n    const grid = densityGrid(dataset);\n    if (!grid) return;\n    // With no reference volume there is no offset yet, and a VolumeLayer has no\n    // translate — napari centres its box on the world origin. So the POINTS move by\n    // half the density box, exactly as they do for a reference volume, and the\n    // cached geometry is invalidated because that offset just changed.\n    if (!this.volume) {\n      this.origin = [\n        -(grid.width * grid.voxelSize[0]) / 2,\n        -(grid.height * grid.voxelSize[1]) / 2,\n        -(grid.depth * grid.voxelSize[2]) / 2,\n      ];\n      this.layerKey = null;\n    }\n\n    let groups: DensityGroup[];\n    try {\n      groups = await this.densityGroups(dataset, column, selection);\n    } catch (err) {\n      console.warn('[napari-js] density volumes: column unavailable', err);\n      this.densityKey = null;\n      return;\n    }\n    if (!load() || this.densityKey !== key) return;\n\n    const sigma = defaultSigma(grid, smoothing);\n    // Additive blending SUMS, so a fixed per-layer opacity blows out to white as\n    // soon as several broad clusters overlap — six subclasses at 0.55 each turned\n    // the brain into one cyan mass. Splitting the budget keeps n fully overlapping\n    // peaks inside the display's range, so overlap reads as overlap; a single\n    // cluster still gets the full 0.55. It only mitigates: a translucent raymarch\n    // integrates along the ray, so clusters that are ubiquitous rather than\n    // regional (the largest subclasses are glia, which are everywhere) still pile\n    // up, and one cluster at a time is the readable way to look at those.\n    const opacity = Math.min(0.55, 0.9 / Math.max(1, groups.length));\n    let fields: (Uint8Array | null)[];\n    try {\n      // Off the main thread past the worker threshold; the clusters queue on one worker.\n      fields = await Promise.all(\n        groups.map((group) =>\n          rasterizeDensityAsync(\n            dataset.observations,\n            grid,\n            { sigma, indices: group.indices },\n            { signal: load.signal },\n          ),\n        ),\n      );\n    } catch (err) {\n      if (isAbortError(err)) return; // superseded by a newer key, or the scene went away\n      throw err;\n    }\n    if (!load() || this.densityKey !== key) return;\n    groups.forEach((group, i) => {\n      const data = fields[i];\n      // A cluster with nothing on the grid draws no layer, rather than an empty box.\n      if (!data) return;\n      this.densityLayers.push(\n        viewer.addVolume(data, grid.width, grid.height, grid.depth, {\n          name: `density · ${group.name}`,\n          colormap: this.ctx.display.channelTintColormap(group.color),\n          invert: this.ctx.display.invert,\n          // Translucent, not MIP: a cluster's interior is the readable part, and MIP\n          // would flatten every cloud to its brightest shell.\n          rendering: 'translucent',\n          opacity,\n          // Additive, so two clusters overlapping read as both being there instead\n          // of the nearer one hiding the other.\n          blending: 'additive',\n          voxelSize: grid.voxelSize,\n        }),\n      );\n    });\n    viewer.requestRender();\n  }\n\n  /**\n   * The clusters to rasterise: the categories of the active categorical colouring,\n   * biggest first and capped, each with its legend colour, restricted to the current selection\n   * when there is one. With no categorical colouring there is one group — total cell density,\n   * which is a real question on its own (\"where is the tissue dense?\") and the honest thing to\n   * show when the view is not encoding a taxonomy.\n   */\n  private async densityGroups(\n    dataset: SpatialDataset,\n    column: string | null,\n    selection: SpatialSelectionMask,\n  ): Promise<DensityGroup[]> {\n    const port = this.session.port;\n    const meta = column ? findColumnMeta(dataset, column) : undefined;\n    if (!port || !column || !meta || meta.kind !== 'categorical') return [totalDensityGroup(selection)];\n    const loaded = await port.getColumn(column);\n    if (!isCategoricalColumn(loaded)) return [];\n    return rankDensityGroups(column, loaded, dataset.observations.count, selection);\n  }\n\n  /**\n   * Add (or keep) the dataset's reference volume, and derive the offset that sits the\n   * observations inside it.\n   *\n   * `VolumeLayer` has no translate: napari-js maps the volume's unit cube to a world box\n   * **centred on the origin**, sized `dims x voxelSize`. The observations, by contract, are in\n   * the volume's own frame with its near corner at the coordinate origin. So the two only line\n   * up if the POINTS move — by half the box — which is what {@link origin} is.\n   *\n   * A failed or absent volume is not fatal: the cloud renders on its own, at its own\n   * coordinates, and the camera frames the points instead.\n   */\n  private async ensureVolume(viewer: Viewer, dataset: SpatialDataset, view: SpatialViewState): Promise<void> {\n    const meta = dataset.volume;\n    const port = this.session.port;\n    const key = meta ? `${dataset.id}:${meta.width}x${meta.height}x${meta.depth}` : null;\n    if (key && key === this.volumeKey) return;\n\n    if (this.volume) {\n      viewer.layers.remove(this.volume);\n      this.volume = null;\n      this.volumeKey = null;\n    }\n    this.origin = [0, 0, 0];\n    if (!meta || !port?.getVolume) return;\n\n    let voxels: Uint8Array;\n    try {\n      voxels = await port.getVolume();\n    } catch (err) {\n      console.warn('[napari-js] reference volume unavailable — drawing the cloud alone', err);\n      return;\n    }\n    if (this.ctx.signal.aborted) return;\n\n    const [vx, vy, vz] = meta.voxelSize;\n    this.volumeKey = key;\n    this.volume = viewer.addVolume(voxels, meta.width, meta.height, meta.depth, {\n      name: 'reference volume',\n      colormap: 'gray',\n      // MIP would draw the brightest voxel along each ray, which for an averaged\n      // template means a flat white shell that hides the cloud. Translucent lets\n      // the points read through the tissue, which is the entire point of drawing\n      // them together.\n      rendering: 'translucent',\n      opacity: view.volumeOpacity,\n      voxelSize: [vx, vy, vz],\n    });\n    // Half the box, negated: the observations' origin is the box's near corner,\n    // and the box is centred on the world origin.\n    this.origin = [-(meta.width * vx) / 2, -(meta.height * vy) / 2, -(meta.depth * vz) / 2];\n    // Force a geometry rebuild: the offset changed, so cached positions are stale.\n    this.layerKey = null;\n  }\n\n  /** Drop every layer of the cloud (the dataset went away, or has no z). */\n  private removeLayers(viewer: Viewer): void {\n    for (const layer of [this.points, this.volume, this.geneMapLayer, ...this.densityLayers]) {\n      if (layer) viewer.layers.remove(layer);\n    }\n    this.geneMapLayer = null;\n    this.geneMapKey = null;\n    this.session.geneMapVolume.field = null;\n    this.session.geneMapVolume.key = null;\n    this.densityLayers = [];\n    this.densityKey = null;\n    // The scene is gone, so the next 3D layer should frame itself again. That used to be\n    // `spatialFramed = null` next to a hand-rolled save/restore; the renderer owns the\n    // policy now, and this is the same statement addressed to it.\n    viewer.resetFit3D();\n    this.volume = null;\n    this.volumeKey = null;\n    this.origin = [0, 0, 0];\n    this.points = null;\n    this.setPicker(null);\n    this.layerKey = null;\n    this.scalarKey = null;\n    this.positions = null;\n    this.drawn = null;\n  }\n\n  /**\n   * What colours the cloud.\n   *\n   * Continuous data goes through the active colormap with the same percentile window the 2D path\n   * uses. Categorical data is one RGBA per point from the column's palette, so any number of\n   * categories keeps its own colour — see `encodeSpatial3dCategorical`.\n   */\n  private async scalarEncoding(view: SpatialViewState): Promise<Spatial3dEncoding | null> {\n    const port = this.session.port;\n    const colorBy = view.colorBy;\n    if (!port || !colorBy) return null;\n\n    if (colorBy.kind === 'column') {\n      const column: SpatialColumn = await port.getColumn(colorBy.name);\n      if (isCategoricalColumn(column)) {\n        return encodeSpatial3dCategorical(column.codes, resolveCategoryColors(column.meta));\n      }\n      return this.encodeContinuous(column.values, view);\n    }\n    return this.encodeContinuous(await port.getFeatureVector(colorBy.name), view);\n  }\n\n  /** Continuous values → the active colormap over a percentile-clipped window. */\n  encodeContinuous(source: Float32Array, view: SpatialViewState): Spatial3dScalars {\n    return encodeSpatial3dContinuous(\n      source,\n      view,\n      this.ctx.display.spatialLut(view),\n      this.session.contrastWindows,\n    );\n  }\n}\n\n/**\n * The observations the cloud draws, and the keys of its geometry and of its colour source.\n *\n * One imaged section, or the whole stack (`shown` null). The subset IS the geometry, so it\n * belongs in the geometry key rather than being re-derived per frame — and an out-of-range\n * index is clamped rather than dropping the cloud, because the section count changes with the\n * dataset while the view state persists. The scalars' identity is tracked separately from the\n * geometry's (`colorBy` plus the transforms feeding the encoding): a new colour source swaps\n * `values` in place (napari-js ≥ 0.14), while a new geometry needs a new layer.\n */\nfunction cloudSubset(\n  dataset: SpatialDataset,\n  view: SpatialViewState,\n): { shown: Uint32Array | null; key: string; scalarKey: string } {\n  const obs = dataset.observations;\n  const sections = sectionsOf(obs);\n  const section =\n    view.pointSection != null && sections && sections.length > 0\n      ? sections[Math.max(0, Math.min(sections.length - 1, view.pointSection))]\n      : null;\n  const shown = section != null ? observationsInSection(obs, section) : null;\n  const key = `${dataset.id}:${obs.count}:${section ?? 'all'}`;\n  const clip = view.percentileClip ?? [0.01, 0.99];\n  const scalarKey = [\n    key,\n    view.colorBy ? `${view.colorBy.kind}:${view.colorBy.name}` : 'flat',\n    view.logScale ? 'log' : 'lin',\n    clip.join(','),\n  ].join('|');\n  return { shown, key, scalarKey };\n}\n"]}