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

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

@@ -0,0 +1,614 @@
+import { NO_CATEGORY, isCategoricalColumn, } from '../../contracts/spatial-dataset.contract';
+import { encodeCategorical, markerDiameters, resolveCategoryColors } from '../../spatial/spatial-encoding';
+import { emptySelection, maskToIndices, mutedFromSelection, } from '../../spatial/spatial-selection';
+import { framePositions } from '../../spatial/spatial-framing';
+import { PIXEL_WORLD_QUANTUM, worldQuantumForExtent } from '../../spatial/world-grid';
+import { observationsInSlice, volumeImageRef } from '../../spatial/spatial-volume-image';
+import { cellTypeColumnFor } from '../../spatial/spatial-tiles';
+import { colorExpressionField, fieldContrastWindow } from '../../spatial/spatial-expression';
+import { computeExpressionFieldAsync } from '../../workers/spatial-math';
+import { Supersede } from '../../util/supersede';
+import { isAbortError } from '../tile-server';
+import { Image2dScene } from './napari-image-2d-scene';
+import { GENE_MAP_MAX_SIDE, GENE_MAP_SIGMA, SPATIAL_FALLBACK_RADIUS, SPATIAL_NEUTRAL_COLOR, SPATIAL_NEUTRAL_HEX, SPATIAL_SLICE_MIN_DIAMETER_PX, encodeSpatialContinuous, gatherColors, } from './napari-spatial-encoding';
+import { SpatialSceneBase } from './napari-spatial-scene';
+/**
+ * SPATIAL_OMICS (review Appendix B, cluster J): the tissue image (an {@link Image2dScene}) with one
+ * marker per observation, coloured by an annotation column or a gene, the gene map under the
+ * cells, and the level-of-detail tile layers (outlines, transcripts, density) over them. The
+ * markers rebuild whenever the dataset or the view state changes, so switching the colour-by
+ * column does not remount the scene.
+ *
+ * Sets up the full 2D interaction stack — region overlay, pixel tools, readback currency — exactly
+ * as the plain image view does. That is NOT optional here: this mode's selection is driven by
+ * drawn ROIs, so without the overlay there is no way to make a selection at all.
+ */
+export class Spatial2dScene extends SpatialSceneBase {
+    /** `noImage`: an image-less dataset opened before any image — the observations alone. */
+    constructor(ctx, session, noImage = false) {
+        super(ctx, session, false);
+        /** The observation markers, and which dataset/plane they were built for — so a display-only
+         *  change (size, colour, opacity, selection) can update them in place. */
+        this.points = null;
+        this.layerKey = null;
+        /** The observation each marker is, in draw order; null when every observation is drawn. */
+        this.drawn = null;
+        /** The gene map's 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;
+        /** The dataset the camera has been framed on — see {@link frameOnce}. */
+        this.framed = null;
+        /** The gene-map estimate in flight (off the main thread past the worker threshold,
+         *  SPATIAL-19): a new field key supersedes — and aborts — it; a rebuild that leaves the key
+         *  alone lets it finish. */
+        this.geneMapLoads = new Supersede();
+        this.image = new Image2dScene(ctx, {
+            image: !noImage,
+            // Only fit to the image when this dataset actually has one. Otherwise there is nothing to
+            // fit, the image size still holds the LAST image's dimensions, and this fits to those — and
+            // because it defers to a frame, it lands AFTER the points are added and overwrites the
+            // framing they set. That is what left an image-less dataset as a ten-pixel speck.
+            fit: () => !!session.latest?.[0]?.imageRef,
+            onSlice: (rerendered) => {
+                this.redrawMarkers();
+                // The stitched re-render cleared the cells, transcripts and density too: re-plan them now
+                // rather than at the next camera move (each group redraws only what left the scene).
+                if (rerendered)
+                    this.session.tiles?.refresh();
+            },
+            onNavigatorInteract: () => this.hover.hide(),
+        });
+    }
+    async mount() {
+        const { ctx } = this;
+        await this.image.mount();
+        // Disposed while the image loaded: claiming the tiles now would take them from the next scene,
+        // and the spatial subscription would outlive this one.
+        if (ctx.signal.aborted)
+            return;
+        this.hover.install(ctx.host);
+        this.session.claimTiles(this)?.attach(ctx.viewer);
+        this.subscribeSpatial();
+        ctx.tools.scheduleReadback();
+    }
+    setZ(z) {
+        this.image.setZ(z);
+    }
+    histogram(channel, bins) {
+        return this.image.histogram(channel, bins);
+    }
+    setImageSmoothing(enabled) {
+        this.image.setImageSmoothing(enabled);
+    }
+    setNavigatorVisible(visible) {
+        this.image.setNavigatorVisible(visible);
+    }
+    dispose() {
+        this.disposeSpatial();
+        this.geneMapLoads.cancel();
+        this.session.releaseTiles(this);
+        this.image.dispose();
+    }
+    canvasSize() {
+        return [this.ctx.canvas.clientWidth ?? 0, this.ctx.canvas.clientHeight ?? 0];
+    }
+    polygonsShownChanged() {
+        if (this.points)
+            this.points.visible = this.pointsVisible();
+        this.ctx.viewer.requestRender();
+    }
+    afterChange() {
+        this.session.tiles?.refresh();
+    }
+    hoverTiles() {
+        return this.session.tiles;
+    }
+    /**
+     * The observation under a client position: napari-js's pick on the marker layer itself (a grid
+     * over its positions, rebuilt only when they change), so the tooltip cannot name a cell that is
+     * not drawn, then the drawn index mapped back to the observation.
+     *
+     * A marker is hit anywhere on its drawn disc, or within `slackPx` screen pixels of its centre
+     * when it is smaller than that (a 1.5 px dot still has to be hoverable), and of several hits the
+     * NEAREST centre wins (an exact tie goes to the one drawn on top). Not napari's `'topmost'`: the
+     * slack is wider than most markers, and over a dense field of small ones "the last drawn within
+     * 10 px" names a neighbour rather than the cell under the cursor.
+     */
+    pickObservation(clientX, clientY, slackPx) {
+        const points = this.points;
+        if (!points)
+            return -1;
+        const viewer = this.ctx.viewer;
+        const [wx, wy] = viewer.canvasToWorld(clientX, clientY);
+        const zoom = viewer.camera.zoom;
+        const k = points.pick(wx, wy, { tolerance: slackPx / (zoom > 0 ? zoom : 1), tieBreak: 'nearest' });
+        if (k < 0)
+            return -1;
+        return this.drawn ? this.drawn[k] : k;
+    }
+    /**
+     * Whether the markers are drawn: when the user wants them, and not while cell outlines are on
+     * screen — then a cell IS its outline, and a circle on top of it is noise. Zoomed out past the
+     * outline threshold, the circles stand in for the cells.
+     */
+    pointsVisible() {
+        const view = this.session.latest?.[1];
+        return (view?.showPoints ?? true) && !this.session.tiles?.outlinesShown;
+    }
+    /**
+     * Redraw the markers over a freshly rendered image. Two reasons, both invisible from the
+     * spatial store — which is why a scrub or a re-render never reached the markers on its own:
+     *  - the image render CLEARS the layer list, taking the markers with it;
+     *  - over a volume-backed dataset the displayed plane decides which observations belong on
+     *    screen at all, so the cells have to move with the section rather than hang over another.
+     */
+    redrawMarkers() {
+        const latest = this.session.latest;
+        if (!latest?.[0])
+            return;
+        void this.rebuild(...latest);
+    }
+    /** (Re)build the observation marker layer for the current dataset + view state. */
+    async rebuild(dataset, view, selection = emptySelection()) {
+        const viewer = this.ctx.viewer;
+        const task = this.rebuilds.next();
+        // Resolve colours BEFORE touching the scene: a gene fetch can fail or be
+        // superseded, and dropping the existing layer first would blank the view.
+        let faceColor;
+        const endLoading = this.ctx.badge.begin('Observations');
+        try {
+            faceColor = dataset ? await this.faceColors(dataset, view, selection) : SPATIAL_NEUTRAL_COLOR;
+        }
+        catch (err) {
+            console.warn('[napari-js] spatial colouring failed — falling back to a flat colour', err);
+            faceColor = SPATIAL_NEUTRAL_COLOR;
+        }
+        finally {
+            endLoading();
+        }
+        // A newer rebuild (or a teardown) started while the vector was in flight.
+        if (!task())
+            return;
+        if (!dataset || dataset.observations.count === 0) {
+            this.removeLayers(viewer);
+            return;
+        }
+        // A dataset whose image IS its volume shows ONE PLANE at a time, so the
+        // markers are the observations in the displayed plane, drawn in that plane's
+        // pixel grid. Without the filter the specimen's whole depth piles onto one
+        // section and reads as a smear; without the affine the coordinates are read
+        // as pixels and land off the slice entirely.
+        const slab = slabAt(dataset, this.ctx.z());
+        // The gene map goes UNDER the cells, so it is settled before they are added.
+        await this.ensureGeneMap(viewer, dataset, view, selection, slab);
+        if (!task())
+            return;
+        this.drawMarkers(viewer, dataset, view, faceColor, slab);
+    }
+    /** Nothing to draw: drop the markers and the gene map. */
+    removeLayers(viewer) {
+        if (this.points) {
+            viewer.layers.remove(this.points);
+            this.points = null;
+            this.layerKey = null;
+            this.drawn = null;
+        }
+        if (this.geneMapLayer) {
+            viewer.layers.remove(this.geneMapLayer);
+            this.geneMapLayer = null;
+            this.geneMapKey = null;
+        }
+    }
+    /**
+     * Draw the observation markers over the image (and the gene map): restyled in place for a
+     * display-only change, else a new layer.
+     */
+    drawMarkers(viewer, dataset, view, faceColor, slab) {
+        const obs = dataset.observations;
+        const ref = slab?.ref ?? dataset.imageRef;
+        const size = markerSizes(obs, view, slab);
+        // napari's image view CLEARS the whole layer list on every render, so the
+        // markers go with it whenever the image is re-rendered — a scrub, a contrast
+        // change. The cached handle is then detached, and mutating it draws nothing:
+        // treat a layer that is no longer in the scene as absent so it gets re-added.
+        if (this.points && !viewer.layers.items.includes(this.points)) {
+            this.points = null;
+            this.layerKey = null;
+        }
+        const showImage = (!!ref || !!dataset.volume) && view.showImage !== false;
+        // A size/colour/opacity/selection change is DISPLAY-only: mutate the layer
+        // rather than dropping and re-adding it. Both setters bump the layer's
+        // dataVersion, which is what makes napari-js rebuild the instance buffer and
+        // redraw — and it avoids rebuilding 84k positions to change one number.
+        // The slice is part of the key: a scrub changes WHICH observations are drawn,
+        // which is geometry, not display.
+        const key = `${dataset.id}:${obs.count}:${slab?.slice ?? ''}`;
+        if (this.points && key === this.layerKey) {
+            this.points.size = size;
+            this.points.visible = this.pointsVisible();
+            this.points.faceColor = gatherColors(faceColor, slab?.indices);
+            this.hideForeignImage(viewer, showImage);
+            this.ctx.tools.regionOverlay?.setRegionsVisible(view.showAnnotations !== false);
+            viewer.requestRender();
+            return;
+        }
+        if (this.points) {
+            viewer.layers.remove(this.points);
+            this.points = null;
+        }
+        const drawn = slab?.indices;
+        const positions = observationPositions(obs, drawn);
+        this.layerKey = key;
+        this.drawn = drawn ?? null;
+        this.points = viewer.addPoints(positions, {
+            name: 'observations',
+            size,
+            faceColor: gatherColors(faceColor, drawn),
+            // No border: at Visium spot density an outline per marker reads as noise,
+            // and it costs a second colour array.
+            borderWidth: 0,
+            // The dataset's data->world affine. SpatialData records one per coordinate
+            // system (Visium spot coords are in the FULL-resolution frame while the
+            // served image may be the hires downscale), so without this the markers
+            // land in the right shape at the wrong scale. Defaults to identity when
+            // the coordinates are already in the image's pixel space.
+            scale: ref?.scale ?? [1, 1],
+            translate: ref?.translate ?? [0, 0],
+            visible: this.pointsVisible(),
+        });
+        // Outlines, density and transcripts go back over the markers just added.
+        this.session.tiles?.afterObservations();
+        this.frameOnce(viewer, dataset.id, positions, !!ref);
+        this.hideForeignImage(viewer, showImage);
+        this.ctx.tools.regionOverlay?.setRegionsVisible(view.showAnnotations !== false);
+        this.setRegionGridFor(dataset, positions);
+    }
+    /**
+     * Tell the region overlay how finely a drawn vertex may be placed.
+     *
+     * Region geometry is stored in whole world units, which is right when the world IS
+     * pixels — a region should align to them. It is wrong for a dataset that registers onto
+     * no image: seqFISH's observations span about 5 x 7 units in total, so whole-unit
+     * vertices leave roughly six by eight placeable positions across the entire sample and
+     * an ROI cannot be drawn at any zoom. Nothing errors; the tool just cannot express the
+     * shape.
+     *
+     * Keyed on whether the dataset brings PIXELS rather than on the extent, because the
+     * extent cannot tell the two apart — 2,000 units is a small slide or a large section
+     * depending only on what the units are, and only the dataset knows.
+     */
+    setRegionGridFor(dataset, positions) {
+        const overlay = this.ctx.tools.regionOverlay;
+        if (!overlay?.setWorldQuantum)
+            return;
+        if (dataset.imageRef || dataset.volume) {
+            overlay.setWorldQuantum(PIXEL_WORLD_QUANTUM);
+            return;
+        }
+        let minX = Infinity;
+        let maxX = -Infinity;
+        let minY = Infinity;
+        let maxY = -Infinity;
+        for (let i = 0; i < positions.length; i += 2) {
+            const x = positions[i];
+            const y = positions[i + 1];
+            if (!Number.isFinite(x) || !Number.isFinite(y))
+                continue;
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+        }
+        overlay.setWorldQuantum(worldQuantumForExtent(maxX - minX, maxY - minY));
+    }
+    /**
+     * Hide the image layer for a dataset that brings no image of its own.
+     *
+     * The host's viewer keeps whatever image was last loaded, and for a dataset that
+     * registers onto none that picture belongs to something else entirely — the example's
+     * default slide, say. It is not merely irrelevant: the two live in different coordinate
+     * spaces (image pixels against the embedding's own units), so the leftover is magnified
+     * roughly a hundredfold. At the fitted zoom the camera sits inside its corner, where it
+     * reads as blank background, and it appears only once you zoom out far enough to find
+     * it — which is exactly how it gets noticed.
+     *
+     * Hidden rather than removed, and hidden HERE rather than by clearing the host's image
+     * state: that state drives the whole render pipeline, including a Plotly backend whose
+     * fields are declared with definite-assignment assertions, so emptying it throws from
+     * whichever field the next path happens to read. This touches one layer's visibility
+     * and nothing else.
+     */
+    hideForeignImage(viewer, datasetHasPixels) {
+        // No image of its own → nothing for an overview to show either.
+        this.image.showNavigatorFor(datasetHasPixels);
+        const tiles = this.session.tiles;
+        for (const layer of viewer.layers.items) {
+            if (layer.kind !== 'image')
+                continue;
+            // The transcript-density raster and the gene map are image layers too, but they are
+            // data, not the tissue: the Images toggle must not take them down with the slide.
+            if (tiles?.owns(layer) || layer === this.geneMapLayer)
+                continue;
+            // Re-shown when a dataset that owns an image comes back, so switching between
+            // datasets does not leave the tissue permanently hidden.
+            layer.visible = datasetHasPixels;
+        }
+        viewer.requestRender();
+    }
+    /**
+     * Frame the camera on the observations, for a dataset that brings no image.
+     *
+     * The 2D camera is normally fitted to the IMAGE, because the observations are in that
+     * image's pixel space and framing the image frames them too. A dataset with no
+     * reference image has coordinates in its own units instead — seqFISH's span about
+     * 5x7 — so the image framing left over from whatever was on screen before puts the
+     * whole cloud offscreen: measured at 9.7 x 13.4 PIXELS, centred 256px from where the
+     * camera was looking. The points are all there and drawn; they are a speck. Which
+     * looks exactly like the dataset having failed to load.
+     *
+     * Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring,
+     * slicing or picking a gene re-adds this layer, and re-framing on those would move
+     * the camera under the user — the camera tools and the canvas drag are meant to be
+     * the only things that do.
+     */
+    frameOnce(viewer, datasetId, positions, registered) {
+        // Gated on whether THIS dataset registers onto an image, not on the image size: that keeps
+        // the last plotted image's dimensions after the host clears it, so a stale 512x383 read as
+        // "there is an image" and skipped the framing entirely.
+        if (registered)
+            return;
+        // Once per dataset (see above).
+        if (this.framed === datasetId)
+            return;
+        const { canvas } = this.ctx;
+        const fit = framePositions(positions, canvas.clientWidth ?? 0, canvas.clientHeight ?? 0);
+        // Null means there is nothing to frame on; leave the camera where it is rather
+        // than moving the view for a dataset we cannot fit.
+        if (!fit)
+            return;
+        viewer.camera.set(fit.center, fit.zoom ?? viewer.camera.zoom);
+        this.framed = datasetId;
+    }
+    /**
+     * The **gene map**: the active gene's expression as a continuous field drawn under
+     * the cells.
+     *
+     * A scatter coloured by a gene says which cells express it; it cannot say where,
+     * because the eye will not integrate thousands of dots into a territory. The field
+     * is a kernel-weighted MEAN per cell (see `spatial-expression.ts`), so a dense
+     * region does not glow merely for being dense, and it is transparent wherever no
+     * cell was measured — an unsampled gap must not read as "not expressed".
+     *
+     * It shares the points' LUT, percentile window and log flag, so the layer under
+     * the cells and the cells themselves cannot disagree about what a colour means.
+     *
+     * Estimated on the DISPLAYED image's pixel grid, coarsened so the long side is at
+     * most `GENE_MAP_MAX_SIDE`: a smooth field gains nothing from a slide's full
+     * resolution. For a volume-backed dataset that grid is the current slice, and only
+     * that plane's observations are included — the same rule the markers follow.
+     */
+    async ensureGeneMap(viewer, dataset, view, selection, slab) {
+        const gene = view.geneMap && view.colorBy?.kind === 'feature' ? view.colorBy.name : null;
+        const port = this.session.port;
+        const cache = this.session.geneMap;
+        const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;
+        const clip = view.percentileClip ?? [0.01, 0.99];
+        // Two clocks: the FIELD depends on the gene, the plane and the bandwidth, while
+        // the colours depend on the window, the log flag and the opacity. Recolouring a
+        // cached field is a fraction of estimating one.
+        const fieldKey = gene
+            ? [dataset.id, gene, slab?.slice ?? '', smoothing, 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;
+        // A stitched slice re-render clears the whole layer list, the map with it, and the key of a
+        // registered image's map does not name the slice: a map no longer in the scene is absent,
+        // as the markers' is (see `rebuild`), so it is drawn again from the cached field.
+        if (this.geneMapLayer && !viewer.layers.items.includes(this.geneMapLayer)) {
+            this.geneMapLayer = null;
+            this.geneMapKey = 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;
+        }
+        // The raster covers the displayed image; without one there is nothing to
+        // overlay and the cloud is the 3D mode's business, not this one's. Gated on the
+        // DATASET bringing pixels, not on the image size: that keeps the last plotted image's
+        // size after the host clears it, which would size the map over the wrong extent.
+        if (!slab && !dataset.imageRef)
+            return;
+        const size = this.ctx.imageSize();
+        const imageW = slab ? dataset.volume.width : size.width;
+        const imageH = slab ? dataset.volume.height : size.height;
+        if (!imageW || !imageH)
+            return;
+        const step = Math.max(1, Math.ceil(Math.max(imageW, imageH) / GENE_MAP_MAX_SIDE));
+        if (fieldKey !== cache.key) {
+            const load = this.geneMapLoads.next();
+            let values;
+            try {
+                values = await port.getFeatureVector(gene);
+            }
+            catch (err) {
+                console.warn(`[napari-js] gene map: "${gene}" unavailable`, err);
+                this.geneMapKey = null;
+                return;
+            }
+            if (!load() || this.geneMapKey !== key)
+                return;
+            const inSelection = selection.count > 0 ? maskToIndices(selection.mask) : undefined;
+            let estimated;
+            try {
+                estimated = await computeExpressionFieldAsync(dataset.observations, {
+                    ref: slab?.ref ?? dataset.imageRef,
+                    width: Math.ceil(imageW / step),
+                    height: Math.ceil(imageH / step),
+                    step,
+                    sigma: GENE_MAP_SIGMA * smoothing,
+                    values,
+                    // A plane wins over a selection: the 2D view is showing one section, so a
+                    // field spanning the specimen's depth would not be the thing on screen.
+                    indices: slab?.indices ?? inSelection,
+                }, { 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 = estimated;
+            cache.key = fieldKey;
+        }
+        const field = cache.field;
+        if (!field)
+            return;
+        const lut = this.ctx.display.spatialLut(view);
+        // Over the measured pixels only: unmeasured ones are 0 and would drag the low end down.
+        const [lo, hi] = fieldContrastWindow(field, clip[0], clip[1]);
+        const rgba = colorExpressionField(field, lut, [lo, hi], {
+            log: view.logScale,
+            // The MAP's own opacity: reading a field under the cells means turning the
+            // cells down, which must not take the field with them.
+            opacity: view.geneMapOpacity,
+        });
+        this.geneMapLayer = viewer.addImage({ kind: 'typed', width: field.width, height: field.height, channels: 4, dtype: 'uint8', data: rgba }, {
+            name: `gene map · ${gene}`,
+            scale: [step, step],
+            translate: [0, 0],
+            blending: 'translucent',
+        });
+        // `addImage` appends, so the map just landed over the cells (drawn by this rebuild's
+        // previous pass, or by a newer rebuild while the field was computing): move it to just under
+        // them. A move keeps the markers' GPU buffers, where dropping and re-adding the markers
+        // re-uploaded every one of them (NAPARI-BOUNDARY-11). Without markers on screen there is
+        // nothing to go under; the rebuild adds them over the map.
+        const under = this.points ? viewer.layers.items.indexOf(this.points) : -1;
+        if (under >= 0)
+            viewer.layers.move(this.geneMapLayer, under);
+        viewer.requestRender();
+    }
+    /**
+     * Per-observation colours for the current view state, or a single flat colour when nothing is
+     * selected to colour by. Categorical columns use the column's own palette; continuous columns
+     * and gene vectors go through the active colormap with a percentile-clipped window.
+     */
+    async faceColors(dataset, view, selection) {
+        const port = this.session.port;
+        const colorBy = view.colorBy;
+        // Everything NOT selected is muted; with nothing selected, nothing is muted
+        // and the whole tissue reads normally (the CosMx highlight-vs-mute rule).
+        const muted = mutedFromSelection(selection);
+        if (!port || !colorBy) {
+            // Genuinely uniform: one broadcast tuple, so a flat 84k-observation view
+            // does not allocate a colour per point.
+            if (!muted && view.opacity >= 1)
+                return SPATIAL_NEUTRAL_COLOR;
+            // Not uniform — the opacity control or a selection varies the alpha, so it
+            // has to be per-point. Returning the constant tuple here is what made the
+            // Opacity slider do nothing in the default state, which is the state anyone
+            // lands in before picking a colour source.
+            return encodeCategorical(new Uint16Array(dataset.observations.count), {
+                colors: [SPATIAL_NEUTRAL_HEX],
+                opacity: view.opacity,
+                muted,
+            });
+        }
+        if (colorBy.kind === 'column') {
+            const column = await port.getColumn(colorBy.name);
+            if (isCategoricalColumn(column)) {
+                const rgba = encodeCategorical(column.codes, {
+                    colors: resolveCategoryColors(column.meta),
+                    opacity: view.opacity,
+                    muted,
+                });
+                // Groups switched off in the Cells panel hide their dots too, when the dots are
+                // coloured by that same grouping.
+                const groupColumn = cellTypeColumnFor(dataset, view);
+                if (view.hiddenGroups?.length && groupColumn === colorBy.name) {
+                    const off = new Set(view.hiddenGroups);
+                    const hide = column.meta.categories.map((c) => off.has(c));
+                    for (let i = 0; i < column.codes.length; i++) {
+                        const c = column.codes[i];
+                        if (c !== NO_CATEGORY && hide[c])
+                            rgba[4 * i + 3] = 0;
+                    }
+                }
+                return rgba;
+            }
+            // A continuous column may carry its own log hint (counts); the view's
+            // toggle wins once the user has set it.
+            return this.encodeContinuous(column.values, view, muted);
+        }
+        const values = await port.getFeatureVector(colorBy.name);
+        return this.encodeContinuous(values, view, muted);
+    }
+    /** Continuous values → RGBA through the active colormap and a clipped window. */
+    encodeContinuous(values, view, muted = null) {
+        return encodeSpatialContinuous(values, view, this.ctx.display.spatialLut(view), this.session.contrastWindows, muted);
+    }
+}
+/** The markers' diameters: each observation's own (or the fallback), at least the slab's floor,
+ *  times the view's point scale; one number when every marker is drawn at the same size. */
+function markerSizes(obs, view, slab) {
+    const base = markerDiameters(obs, SPATIAL_FALLBACK_RADIUS);
+    const scale = view.pointScale > 0 ? view.pointScale : 1;
+    const floor = slab?.minDiameter ?? 0;
+    if (typeof base === 'number' && !slab)
+        return Math.max(base, floor) * scale;
+    const sizeOf = (i) => Math.max(typeof base === 'number' ? base : base[i], floor) * scale;
+    return Float32Array.from(slab?.indices ?? { length: obs.count }, (_v, i) => sizeOf(slab ? slab.indices[i] : i));
+}
+/** Interleaved x,y of the `drawn` observations (undefined: all of them). */
+function observationPositions(obs, drawn) {
+    const count = drawn ? drawn.length : obs.count;
+    const positions = new Float32Array(count * 2);
+    for (let i = 0; i < count; i++) {
+        const o = drawn ? drawn[i] : i;
+        positions[i * 2] = obs.x[o];
+        positions[i * 2 + 1] = obs.y[o];
+    }
+    return positions;
+}
+/**
+ * The plane `slice` of a volume-backed dataset: its pixel affine, the observations that fall in
+ * it, and the marker floor that grid needs.
+ *
+ * Null for a dataset with a real `imageRef` (its coordinates are already the image's pixels and
+ * every observation belongs to the one section) and for one with no volume at all — both of
+ * which draw exactly as before.
+ */
+function slabAt(dataset, slice) {
+    const volume = dataset.volume;
+    if (dataset.imageRef || !volume)
+        return null;
+    return {
+        ref: volumeImageRef(volume, dataset.micronsPerUnit),
+        indices: observationsInSlice(dataset.observations, volume, slice),
+        slice,
+        minDiameter: SPATIAL_SLICE_MIN_DIAMETER_PX * volume.voxelSize[0],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-2d-scene.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-2d-scene.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ImageLayer, PointsLayer, Viewer } from 'napari-js';\n\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport {\n  NO_CATEGORY,\n  SpatialColumn,\n  SpatialDataset,\n  SpatialImageRef,\n  SpatialObservations,\n  isCategoricalColumn,\n} from '../../contracts/spatial-dataset.contract';\nimport { SpatialViewState } from '../../contracts/display-types';\nimport { encodeCategorical, markerDiameters, resolveCategoryColors } from '../../spatial/spatial-encoding';\nimport {\n  SpatialSelectionMask,\n  emptySelection,\n  maskToIndices,\n  mutedFromSelection,\n} from '../../spatial/spatial-selection';\nimport { framePositions } from '../../spatial/spatial-framing';\nimport { PIXEL_WORLD_QUANTUM, worldQuantumForExtent } from '../../spatial/world-grid';\nimport { observationsInSlice, volumeImageRef } from '../../spatial/spatial-volume-image';\nimport { cellTypeColumnFor } from '../../spatial/spatial-tiles';\nimport { ExpressionField, colorExpressionField, fieldContrastWindow } from '../../spatial/spatial-expression';\nimport { computeExpressionFieldAsync } from '../../workers/spatial-math';\nimport { Supersede } from '../../util/supersede';\nimport { isAbortError } from '../tile-server';\nimport { NapariSpatialTileLayers } from './napari-spatial-tiles';\nimport { Image2dScene } from './napari-image-2d-scene';\nimport {\n  GENE_MAP_MAX_SIDE,\n  GENE_MAP_SIGMA,\n  SPATIAL_FALLBACK_RADIUS,\n  SPATIAL_NEUTRAL_COLOR,\n  SPATIAL_NEUTRAL_HEX,\n  SPATIAL_SLICE_MIN_DIAMETER_PX,\n  PointColors,\n  encodeSpatialContinuous,\n  gatherColors,\n} from './napari-spatial-encoding';\nimport { SpatialSceneBase, SpatialSession, SpatialTileOwner } from './napari-spatial-scene';\nimport type { NapariScene, SceneContext } from './napari-scene';\n\n/** The plane a volume-backed dataset is showing (see {@link Spatial2dScene.slab}). */\ninterface Slab {\n  ref: SpatialImageRef;\n  indices: Uint32Array;\n  slice: number;\n  minDiameter: number;\n}\n\n/**\n * SPATIAL_OMICS (review Appendix B, cluster J): the tissue image (an {@link Image2dScene}) with one\n * marker per observation, coloured by an annotation column or a gene, the gene map under the\n * cells, and the level-of-detail tile layers (outlines, transcripts, density) over them. The\n * markers rebuild whenever the dataset or the view state changes, so switching the colour-by\n * column does not remount the scene.\n *\n * Sets up the full 2D interaction stack — region overlay, pixel tools, readback currency — exactly\n * as the plain image view does. That is NOT optional here: this mode's selection is driven by\n * drawn ROIs, so without the overlay there is no way to make a selection at all.\n */\nexport class Spatial2dScene extends SpatialSceneBase implements NapariScene, SpatialTileOwner {\n  readonly image: Image2dScene;\n  /** The observation markers, and which dataset/plane they were built for — so a display-only\n   *  change (size, colour, opacity, selection) can update them in place. */\n  private points: PointsLayer | null = null;\n  private layerKey: string | null = null;\n  /** The observation each marker is, in draw order; null when every observation is drawn. */\n  private drawn: Uint32Array | null = null;\n  /** The gene map's layer and the inputs it was coloured for (its field is cached in the session,\n   *  on a clock of its own). */\n  geneMapLayer: ImageLayer | null = null;\n  private geneMapKey: string | null = null;\n  /** The dataset the camera has been framed on — see {@link frameOnce}. */\n  private framed: string | null = null;\n  /** The gene-map estimate in flight (off the main thread past the worker threshold,\n   *  SPATIAL-19): a new field key supersedes — and aborts — it; a rebuild that leaves the key\n   *  alone lets it finish. */\n  private readonly geneMapLoads = new Supersede();\n\n  /** `noImage`: an image-less dataset opened before any image — the observations alone. */\n  constructor(ctx: SceneContext, session: SpatialSession, noImage = false) {\n    super(ctx, session, false);\n    this.image = new Image2dScene(ctx, {\n      image: !noImage,\n      // Only fit to the image when this dataset actually has one. Otherwise there is nothing to\n      // fit, the image size still holds the LAST image's dimensions, and this fits to those — and\n      // because it defers to a frame, it lands AFTER the points are added and overwrites the\n      // framing they set. That is what left an image-less dataset as a ten-pixel speck.\n      fit: () => !!session.latest?.[0]?.imageRef,\n      onSlice: (rerendered) => {\n        this.redrawMarkers();\n        // The stitched re-render cleared the cells, transcripts and density too: re-plan them now\n        // rather than at the next camera move (each group redraws only what left the scene).\n        if (rerendered) this.session.tiles?.refresh();\n      },\n      onNavigatorInteract: () => this.hover.hide(),\n    });\n  }\n\n  async mount(): Promise<void> {\n    const { ctx } = this;\n    await this.image.mount();\n    // Disposed while the image loaded: claiming the tiles now would take them from the next scene,\n    // and the spatial subscription would outlive this one.\n    if (ctx.signal.aborted) return;\n    this.hover.install(ctx.host);\n    this.session.claimTiles(this)?.attach(ctx.viewer);\n    this.subscribeSpatial();\n    ctx.tools.scheduleReadback();\n  }\n\n  setZ(z: number): void {\n    this.image.setZ(z);\n  }\n\n  histogram(channel: number, bins: number): IHistogram | null {\n    return this.image.histogram(channel, bins);\n  }\n\n  setImageSmoothing(enabled: boolean): void {\n    this.image.setImageSmoothing(enabled);\n  }\n\n  setNavigatorVisible(visible: boolean): void {\n    this.image.setNavigatorVisible(visible);\n  }\n\n  dispose(): void {\n    this.disposeSpatial();\n    this.geneMapLoads.cancel();\n    this.session.releaseTiles(this);\n    this.image.dispose();\n  }\n\n  canvasSize(): [number, number] {\n    return [this.ctx.canvas.clientWidth ?? 0, this.ctx.canvas.clientHeight ?? 0];\n  }\n\n  polygonsShownChanged(): void {\n    if (this.points) this.points.visible = this.pointsVisible();\n    this.ctx.viewer.requestRender();\n  }\n\n  protected override afterChange(): void {\n    this.session.tiles?.refresh();\n  }\n\n  protected override hoverTiles(): NapariSpatialTileLayers | null {\n    return this.session.tiles;\n  }\n\n  /**\n   * The observation under a client position: napari-js's pick on the marker layer itself (a grid\n   * over its positions, rebuilt only when they change), so the tooltip cannot name a cell that is\n   * not drawn, then the drawn index mapped back to the observation.\n   *\n   * A marker is hit anywhere on its drawn disc, or within `slackPx` screen pixels of its centre\n   * when it is smaller than that (a 1.5 px dot still has to be hoverable), and of several hits the\n   * NEAREST centre wins (an exact tie goes to the one drawn on top). Not napari's `'topmost'`: the\n   * slack is wider than most markers, and over a dense field of small ones \"the last drawn within\n   * 10 px\" names a neighbour rather than the cell under the cursor.\n   */\n  protected pickObservation(clientX: number, clientY: number, slackPx: number): number {\n    const points = this.points;\n    if (!points) return -1;\n    const viewer = this.ctx.viewer;\n    const [wx, wy] = viewer.canvasToWorld(clientX, clientY);\n    const zoom = viewer.camera.zoom;\n    const k = points.pick(wx, wy, { tolerance: slackPx / (zoom > 0 ? zoom : 1), tieBreak: 'nearest' });\n    if (k < 0) return -1;\n    return this.drawn ? this.drawn[k] : k;\n  }\n\n  /**\n   * Whether the markers are drawn: when the user wants them, and not while cell outlines are on\n   * screen — then a cell IS its outline, and a circle on top of it is noise. Zoomed out past the\n   * outline threshold, the circles stand in for the cells.\n   */\n  private pointsVisible(): boolean {\n    const view = this.session.latest?.[1];\n    return (view?.showPoints ?? true) && !this.session.tiles?.outlinesShown;\n  }\n\n  /**\n   * Redraw the markers over a freshly rendered image. Two reasons, both invisible from the\n   * spatial store — which is why a scrub or a re-render never reached the markers on its own:\n   *  - the image render CLEARS the layer list, taking the markers with it;\n   *  - over a volume-backed dataset the displayed plane decides which observations belong on\n   *    screen at all, so the cells have to move with the section rather than hang over another.\n   */\n  private redrawMarkers(): void {\n    const latest = this.session.latest;\n    if (!latest?.[0]) return;\n    void this.rebuild(...latest);\n  }\n\n  /** (Re)build the observation marker layer 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 colours BEFORE touching the scene: a gene fetch can fail or be\n    // superseded, and dropping the existing layer first would blank the view.\n    let faceColor: PointColors;\n    const endLoading = this.ctx.badge.begin('Observations');\n    try {\n      faceColor = dataset ? await this.faceColors(dataset, view, selection) : SPATIAL_NEUTRAL_COLOR;\n    } catch (err) {\n      console.warn('[napari-js] spatial colouring failed — falling back to a flat colour', err);\n      faceColor = SPATIAL_NEUTRAL_COLOR;\n    } finally {\n      endLoading();\n    }\n    // A newer rebuild (or a teardown) started while the vector was in flight.\n    if (!task()) return;\n\n    if (!dataset || dataset.observations.count === 0) {\n      this.removeLayers(viewer);\n      return;\n    }\n\n    // A dataset whose image IS its volume shows ONE PLANE at a time, so the\n    // markers are the observations in the displayed plane, drawn in that plane's\n    // pixel grid. Without the filter the specimen's whole depth piles onto one\n    // section and reads as a smear; without the affine the coordinates are read\n    // as pixels and land off the slice entirely.\n    const slab = slabAt(dataset, this.ctx.z());\n    // The gene map goes UNDER the cells, so it is settled before they are added.\n    await this.ensureGeneMap(viewer, dataset, view, selection, slab);\n    if (!task()) return;\n    this.drawMarkers(viewer, dataset, view, faceColor, slab);\n  }\n\n  /** Nothing to draw: drop the markers and the gene map. */\n  private removeLayers(viewer: Viewer): void {\n    if (this.points) {\n      viewer.layers.remove(this.points);\n      this.points = null;\n      this.layerKey = null;\n      this.drawn = null;\n    }\n    if (this.geneMapLayer) {\n      viewer.layers.remove(this.geneMapLayer);\n      this.geneMapLayer = null;\n      this.geneMapKey = null;\n    }\n  }\n\n  /**\n   * Draw the observation markers over the image (and the gene map): restyled in place for a\n   * display-only change, else a new layer.\n   */\n  private drawMarkers(\n    viewer: Viewer,\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    faceColor: PointColors,\n    slab: Slab | null,\n  ): void {\n    const obs = dataset.observations;\n    const ref = slab?.ref ?? dataset.imageRef;\n    const size = markerSizes(obs, view, slab);\n\n    // napari's image view CLEARS the whole layer list on every render, so the\n    // markers go with it whenever the image is re-rendered — a scrub, a contrast\n    // change. The cached handle is then detached, and mutating it draws nothing:\n    // treat a layer that is no longer in the scene as absent so it gets re-added.\n    if (this.points && !viewer.layers.items.includes(this.points)) {\n      this.points = null;\n      this.layerKey = null;\n    }\n\n    const showImage = (!!ref || !!dataset.volume) && view.showImage !== false;\n    // A size/colour/opacity/selection change is DISPLAY-only: mutate the layer\n    // rather than dropping and re-adding it. Both setters bump the layer's\n    // dataVersion, which is what makes napari-js rebuild the instance buffer and\n    // redraw — and it avoids rebuilding 84k positions to change one number.\n    // The slice is part of the key: a scrub changes WHICH observations are drawn,\n    // which is geometry, not display.\n    const key = `${dataset.id}:${obs.count}:${slab?.slice ?? ''}`;\n    if (this.points && key === this.layerKey) {\n      this.points.size = size;\n      this.points.visible = this.pointsVisible();\n      this.points.faceColor = gatherColors(faceColor, slab?.indices);\n      this.hideForeignImage(viewer, showImage);\n      this.ctx.tools.regionOverlay?.setRegionsVisible(view.showAnnotations !== false);\n      viewer.requestRender();\n      return;\n    }\n\n    if (this.points) {\n      viewer.layers.remove(this.points);\n      this.points = null;\n    }\n\n    const drawn = slab?.indices;\n    const positions = observationPositions(obs, drawn);\n    this.layerKey = key;\n    this.drawn = drawn ?? null;\n    this.points = viewer.addPoints(positions, {\n      name: 'observations',\n      size,\n      faceColor: gatherColors(faceColor, drawn),\n      // No border: at Visium spot density an outline per marker reads as noise,\n      // and it costs a second colour array.\n      borderWidth: 0,\n      // The dataset's data->world affine. SpatialData records one per coordinate\n      // system (Visium spot coords are in the FULL-resolution frame while the\n      // served image may be the hires downscale), so without this the markers\n      // land in the right shape at the wrong scale. Defaults to identity when\n      // the coordinates are already in the image's pixel space.\n      scale: ref?.scale ?? [1, 1],\n      translate: ref?.translate ?? [0, 0],\n      visible: this.pointsVisible(),\n    });\n    // Outlines, density and transcripts go back over the markers just added.\n    this.session.tiles?.afterObservations();\n    this.frameOnce(viewer, dataset.id, positions, !!ref);\n    this.hideForeignImage(viewer, showImage);\n    this.ctx.tools.regionOverlay?.setRegionsVisible(view.showAnnotations !== false);\n    this.setRegionGridFor(dataset, positions);\n  }\n\n  /**\n   * Tell the region overlay how finely a drawn vertex may be placed.\n   *\n   * Region geometry is stored in whole world units, which is right when the world IS\n   * pixels — a region should align to them. It is wrong for a dataset that registers onto\n   * no image: seqFISH's observations span about 5 x 7 units in total, so whole-unit\n   * vertices leave roughly six by eight placeable positions across the entire sample and\n   * an ROI cannot be drawn at any zoom. Nothing errors; the tool just cannot express the\n   * shape.\n   *\n   * Keyed on whether the dataset brings PIXELS rather than on the extent, because the\n   * extent cannot tell the two apart — 2,000 units is a small slide or a large section\n   * depending only on what the units are, and only the dataset knows.\n   */\n  private setRegionGridFor(dataset: SpatialDataset, positions: Float32Array): void {\n    const overlay = this.ctx.tools.regionOverlay;\n    if (!overlay?.setWorldQuantum) return;\n    if (dataset.imageRef || dataset.volume) {\n      overlay.setWorldQuantum(PIXEL_WORLD_QUANTUM);\n      return;\n    }\n    let minX = Infinity;\n    let maxX = -Infinity;\n    let minY = Infinity;\n    let maxY = -Infinity;\n    for (let i = 0; i < positions.length; i += 2) {\n      const x = positions[i];\n      const y = positions[i + 1];\n      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;\n      if (x < minX) minX = x;\n      if (x > maxX) maxX = x;\n      if (y < minY) minY = y;\n      if (y > maxY) maxY = y;\n    }\n    overlay.setWorldQuantum(worldQuantumForExtent(maxX - minX, maxY - minY));\n  }\n\n  /**\n   * Hide the image layer for a dataset that brings no image of its own.\n   *\n   * The host's viewer keeps whatever image was last loaded, and for a dataset that\n   * registers onto none that picture belongs to something else entirely — the example's\n   * default slide, say. It is not merely irrelevant: the two live in different coordinate\n   * spaces (image pixels against the embedding's own units), so the leftover is magnified\n   * roughly a hundredfold. At the fitted zoom the camera sits inside its corner, where it\n   * reads as blank background, and it appears only once you zoom out far enough to find\n   * it — which is exactly how it gets noticed.\n   *\n   * Hidden rather than removed, and hidden HERE rather than by clearing the host's image\n   * state: that state drives the whole render pipeline, including a Plotly backend whose\n   * fields are declared with definite-assignment assertions, so emptying it throws from\n   * whichever field the next path happens to read. This touches one layer's visibility\n   * and nothing else.\n   */\n  hideForeignImage(viewer: Pick<Viewer, 'layers' | 'requestRender'>, datasetHasPixels: boolean): void {\n    // No image of its own → nothing for an overview to show either.\n    this.image.showNavigatorFor(datasetHasPixels);\n    const tiles = this.session.tiles;\n    for (const layer of viewer.layers.items) {\n      if (layer.kind !== 'image') continue;\n      // The transcript-density raster and the gene map are image layers too, but they are\n      // data, not the tissue: the Images toggle must not take them down with the slide.\n      if (tiles?.owns(layer) || layer === this.geneMapLayer) continue;\n      // Re-shown when a dataset that owns an image comes back, so switching between\n      // datasets does not leave the tissue permanently hidden.\n      layer.visible = datasetHasPixels;\n    }\n    viewer.requestRender();\n  }\n\n  /**\n   * Frame the camera on the observations, for a dataset that brings no image.\n   *\n   * The 2D camera is normally fitted to the IMAGE, because the observations are in that\n   * image's pixel space and framing the image frames them too. A dataset with no\n   * reference image has coordinates in its own units instead — seqFISH's span about\n   * 5x7 — so the image framing left over from whatever was on screen before puts the\n   * whole cloud offscreen: measured at 9.7 x 13.4 PIXELS, centred 256px from where the\n   * camera was looking. The points are all there and drawn; they are a speck. Which\n   * looks exactly like the dataset having failed to load.\n   *\n   * Once per dataset, as napari-js's `fit3d: 'once'` does for the cloud: re-colouring,\n   * slicing or picking a gene re-adds this layer, and re-framing on those would move\n   * the camera under the user — the camera tools and the canvas drag are meant to be\n   * the only things that do.\n   */\n  private frameOnce(viewer: Viewer, datasetId: string, positions: Float32Array, registered: boolean): void {\n    // Gated on whether THIS dataset registers onto an image, not on the image size: that keeps\n    // the last plotted image's dimensions after the host clears it, so a stale 512x383 read as\n    // \"there is an image\" and skipped the framing entirely.\n    if (registered) return;\n    // Once per dataset (see above).\n    if (this.framed === datasetId) return;\n\n    const { canvas } = this.ctx;\n    const fit = framePositions(positions, canvas.clientWidth ?? 0, canvas.clientHeight ?? 0);\n    // Null means there is nothing to frame on; leave the camera where it is rather\n    // than moving the view for a dataset we cannot fit.\n    if (!fit) return;\n    viewer.camera.set(fit.center, fit.zoom ?? viewer.camera.zoom);\n    this.framed = datasetId;\n  }\n\n  /**\n   * The **gene map**: the active gene's expression as a continuous field drawn under\n   * the cells.\n   *\n   * A scatter coloured by a gene says which cells express it; it cannot say where,\n   * because the eye will not integrate thousands of dots into a territory. The field\n   * is a kernel-weighted MEAN per cell (see `spatial-expression.ts`), so a dense\n   * region does not glow merely for being dense, and it is transparent wherever no\n   * cell was measured — an unsampled gap must not read as \"not expressed\".\n   *\n   * It shares the points' LUT, percentile window and log flag, so the layer under\n   * the cells and the cells themselves cannot disagree about what a colour means.\n   *\n   * Estimated on the DISPLAYED image's pixel grid, coarsened so the long side is at\n   * most `GENE_MAP_MAX_SIDE`: a smooth field gains nothing from a slide's full\n   * resolution. For a volume-backed dataset that grid is the current slice, and only\n   * that plane's observations are included — the same rule the markers follow.\n   */\n  private async ensureGeneMap(\n    viewer: Viewer,\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n    slab: Slab | null,\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.geneMap;\n    const smoothing = view.geneMapSmoothing > 0 ? view.geneMapSmoothing : 1;\n    const clip = view.percentileClip ?? [0.01, 0.99];\n\n    // Two clocks: the FIELD depends on the gene, the plane and the bandwidth, while\n    // the colours depend on the window, the log flag and the opacity. Recolouring a\n    // cached field is a fraction of estimating one.\n    const fieldKey = gene\n      ? [dataset.id, gene, slab?.slice ?? '', smoothing, this.session.selectionRev(selection)].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    // A stitched slice re-render clears the whole layer list, the map with it, and the key of a\n    // registered image's map does not name the slice: a map no longer in the scene is absent,\n    // as the markers' is (see `rebuild`), so it is drawn again from the cached field.\n    if (this.geneMapLayer && !viewer.layers.items.includes(this.geneMapLayer)) {\n      this.geneMapLayer = null;\n      this.geneMapKey = null;\n    }\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    // The raster covers the displayed image; without one there is nothing to\n    // overlay and the cloud is the 3D mode's business, not this one's. Gated on the\n    // DATASET bringing pixels, not on the image size: that keeps the last plotted image's\n    // size after the host clears it, which would size the map over the wrong extent.\n    if (!slab && !dataset.imageRef) return;\n    const size = this.ctx.imageSize();\n    const imageW = slab ? dataset.volume!.width : size.width;\n    const imageH = slab ? dataset.volume!.height : size.height;\n    if (!imageW || !imageH) return;\n    const step = Math.max(1, Math.ceil(Math.max(imageW, imageH) / GENE_MAP_MAX_SIDE));\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] 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      let estimated: ExpressionField | null;\n      try {\n        estimated = await computeExpressionFieldAsync(\n          dataset.observations,\n          {\n            ref: slab?.ref ?? dataset.imageRef,\n            width: Math.ceil(imageW / step),\n            height: Math.ceil(imageH / step),\n            step,\n            sigma: GENE_MAP_SIGMA * smoothing,\n            values,\n            // A plane wins over a selection: the 2D view is showing one section, so a\n            // field spanning the specimen's depth would not be the thing on screen.\n            indices: slab?.indices ?? inSelection,\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 = estimated;\n      cache.key = fieldKey;\n    }\n    const field = cache.field;\n    if (!field) return;\n\n    const lut = this.ctx.display.spatialLut(view);\n    // Over the measured pixels only: unmeasured ones are 0 and would drag the low end down.\n    const [lo, hi] = fieldContrastWindow(field, clip[0], clip[1]);\n    const rgba = colorExpressionField(field, lut, [lo, hi], {\n      log: view.logScale,\n      // The MAP's own opacity: reading a field under the cells means turning the\n      // cells down, which must not take the field with them.\n      opacity: view.geneMapOpacity,\n    });\n    this.geneMapLayer = viewer.addImage(\n      { kind: 'typed', width: field.width, height: field.height, channels: 4, dtype: 'uint8', data: rgba },\n      {\n        name: `gene map · ${gene}`,\n        scale: [step, step],\n        translate: [0, 0],\n        blending: 'translucent',\n      },\n    );\n    // `addImage` appends, so the map just landed over the cells (drawn by this rebuild's\n    // previous pass, or by a newer rebuild while the field was computing): move it to just under\n    // them. A move keeps the markers' GPU buffers, where dropping and re-adding the markers\n    // re-uploaded every one of them (NAPARI-BOUNDARY-11). Without markers on screen there is\n    // nothing to go under; the rebuild adds them over the map.\n    const under = this.points ? viewer.layers.items.indexOf(this.points) : -1;\n    if (under >= 0) viewer.layers.move(this.geneMapLayer, under);\n    viewer.requestRender();\n  }\n\n  /**\n   * Per-observation colours for the current view state, or a single flat colour when nothing is\n   * selected to colour by. Categorical columns use the column's own palette; continuous columns\n   * and gene vectors go through the active colormap with a percentile-clipped window.\n   */\n  private async faceColors(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n  ): Promise<PointColors> {\n    const port = this.session.port;\n    const colorBy = view.colorBy;\n    // Everything NOT selected is muted; with nothing selected, nothing is muted\n    // and the whole tissue reads normally (the CosMx highlight-vs-mute rule).\n    const muted = mutedFromSelection(selection);\n\n    if (!port || !colorBy) {\n      // Genuinely uniform: one broadcast tuple, so a flat 84k-observation view\n      // does not allocate a colour per point.\n      if (!muted && view.opacity >= 1) return SPATIAL_NEUTRAL_COLOR;\n      // Not uniform — the opacity control or a selection varies the alpha, so it\n      // has to be per-point. Returning the constant tuple here is what made the\n      // Opacity slider do nothing in the default state, which is the state anyone\n      // lands in before picking a colour source.\n      return encodeCategorical(new Uint16Array(dataset.observations.count), {\n        colors: [SPATIAL_NEUTRAL_HEX],\n        opacity: view.opacity,\n        muted,\n      });\n    }\n\n    if (colorBy.kind === 'column') {\n      const column: SpatialColumn = await port.getColumn(colorBy.name);\n      if (isCategoricalColumn(column)) {\n        const rgba = encodeCategorical(column.codes, {\n          colors: resolveCategoryColors(column.meta),\n          opacity: view.opacity,\n          muted,\n        });\n        // Groups switched off in the Cells panel hide their dots too, when the dots are\n        // coloured by that same grouping.\n        const groupColumn = cellTypeColumnFor(dataset, view);\n        if (view.hiddenGroups?.length && groupColumn === colorBy.name) {\n          const off = new Set(view.hiddenGroups);\n          const hide = column.meta.categories.map((c) => off.has(c));\n          for (let i = 0; i < column.codes.length; i++) {\n            const c = column.codes[i];\n            if (c !== NO_CATEGORY && hide[c]) rgba[4 * i + 3] = 0;\n          }\n        }\n        return rgba;\n      }\n      // A continuous column may carry its own log hint (counts); the view's\n      // toggle wins once the user has set it.\n      return this.encodeContinuous(column.values, view, muted);\n    }\n\n    const values = await port.getFeatureVector(colorBy.name);\n    return this.encodeContinuous(values, view, muted);\n  }\n\n  /** Continuous values → RGBA through the active colormap and a clipped window. */\n  encodeContinuous(values: Float32Array, view: SpatialViewState, muted: Uint8Array | null = null): Float32Array {\n    return encodeSpatialContinuous(\n      values,\n      view,\n      this.ctx.display.spatialLut(view),\n      this.session.contrastWindows,\n      muted,\n    );\n  }\n}\n\n/** The markers' diameters: each observation's own (or the fallback), at least the slab's floor,\n *  times the view's point scale; one number when every marker is drawn at the same size. */\nfunction markerSizes(obs: SpatialObservations, view: SpatialViewState, slab: Slab | null): number | Float32Array {\n  const base = markerDiameters(obs, SPATIAL_FALLBACK_RADIUS);\n  const scale = view.pointScale > 0 ? view.pointScale : 1;\n  const floor = slab?.minDiameter ?? 0;\n  if (typeof base === 'number' && !slab) return Math.max(base, floor) * scale;\n  const sizeOf = (i: number) => Math.max(typeof base === 'number' ? base : base[i], floor) * scale;\n  return Float32Array.from(slab?.indices ?? { length: obs.count }, (_v, i) => sizeOf(slab ? slab.indices[i] : i));\n}\n\n/** Interleaved x,y of the `drawn` observations (undefined: all of them). */\nfunction observationPositions(obs: SpatialObservations, drawn: Uint32Array | undefined): Float32Array {\n  const count = drawn ? drawn.length : obs.count;\n  const positions = new Float32Array(count * 2);\n  for (let i = 0; i < count; i++) {\n    const o = drawn ? drawn[i] : i;\n    positions[i * 2] = obs.x[o];\n    positions[i * 2 + 1] = obs.y[o];\n  }\n  return positions;\n}\n\n/**\n * The plane `slice` of a volume-backed dataset: its pixel affine, the observations that fall in\n * it, and the marker floor that grid needs.\n *\n * Null for a dataset with a real `imageRef` (its coordinates are already the image's pixels and\n * every observation belongs to the one section) and for one with no volume at all — both of\n * which draw exactly as before.\n */\nfunction slabAt(dataset: SpatialDataset, slice: number): Slab | null {\n  const volume = dataset.volume;\n  if (dataset.imageRef || !volume) return null;\n  return {\n    ref: volumeImageRef(volume, dataset.micronsPerUnit),\n    indices: observationsInSlice(dataset.observations, volume, slice),\n    slice,\n    minDiameter: SPATIAL_SLICE_MIN_DIAMETER_PX * volume.voxelSize[0],\n  };\n}\n"]}