@jax-data-science/sci-image-visualizer 0.6.0 → 0.8.0

package/esm2022/lib/spatial/spatial-tiles.mjs

@@ -0,0 +1,649 @@
+/**
+ * Level-of-detail planning for tiled spatial geometry — cell outlines and transcripts.
+ *
+ * The renderer knows its camera (a world-space centre, a zoom in canvas pixels per world
+ * unit, a canvas size); a tiled dataset knows its grids (one per level, in observation
+ * units). This module is the bridge: which level the zoom calls for, which tiles are on
+ * screen, how big a transcript marker should be. Everything here is pure, so the policy
+ * — the part that decides whether the view is fast and legible — is testable without a
+ * GPU.
+ *
+ * Observation units map onto world units through the dataset's `imageRef` affine
+ * (`world = data · scale + translate`), so "pixels per observation unit" is
+ * `zoom · scale`. For a Xenium bundle the data unit is the micron and the world unit the
+ * morphology pixel.
+ */
+/** Whether cell outlines are drawn: the user's choice, else on when the dataset has any. */
+export function cellsShown(dataset, view) {
+    const available = !!(dataset?.polygonTiles || dataset?.polygons);
+    return available && (view.showCells ?? true);
+}
+/** A column holding a hand-curated cell-type annotation, by naming convention. */
+export function isCuratedColumn(name) {
+    return /curated/i.test(name);
+}
+/**
+ * The categorical column that names each cell's type: the view's choice when it is a
+ * column of this dataset, else the first categorical column that is not a curated
+ * annotation (a pipeline's clustering is the default; curation is opted into), else
+ * any categorical column.
+ */
+export function cellTypeColumnFor(dataset, view) {
+    const categorical = dataset.columns.filter((c) => c.kind === 'categorical');
+    if (view.cellTypeColumn && categorical.some((c) => c.name === view.cellTypeColumn)) {
+        return view.cellTypeColumn;
+    }
+    return (categorical.find((c) => !isCuratedColumn(c.name)) ?? categorical[0])?.name ?? null;
+}
+export function tileId(k) {
+    return `${k.level}/${k.gx}/${k.gy}`;
+}
+/** Canvas pixels per observation unit along x, for a camera zoom and a data→world affine. */
+export function pixelsPerDataUnit(zoom, ref) {
+    return zoom * Math.abs(ref?.scale?.[0] ?? 1);
+}
+/**
+ * The part of observation space the camera shows, padded by `margin` (a fraction of the
+ * viewport) so tiles just off screen are already there when a pan brings them in.
+ */
+export function visibleDataRect(center, zoom, canvasW, canvasH, ref, margin = 0.15) {
+    if (!(zoom > 0) || !(canvasW > 0) || !(canvasH > 0))
+        return null;
+    const sx = ref?.scale?.[0] ?? 1;
+    const sy = ref?.scale?.[1] ?? 1;
+    const tx = ref?.translate?.[0] ?? 0;
+    const ty = ref?.translate?.[1] ?? 0;
+    const halfW = (canvasW / zoom / 2) * (1 + 2 * margin);
+    const halfH = (canvasH / zoom / 2) * (1 + 2 * margin);
+    const wx0 = center[0] - halfW;
+    const wx1 = center[0] + halfW;
+    const wy0 = center[1] - halfH;
+    const wy1 = center[1] + halfH;
+    const ax = (wx0 - tx) / sx;
+    const bx = (wx1 - tx) / sx;
+    const ay = (wy0 - ty) / sy;
+    const by = (wy1 - ty) / sy;
+    return { x0: Math.min(ax, bx), y0: Math.min(ay, by), x1: Math.max(ax, bx), y1: Math.max(ay, by) };
+}
+/**
+ * Tiles of one level intersecting `rect`, clipped to the dataset's `bounds` (so zooming
+ * out over empty canvas does not ask for tiles that cannot exist). Ordered from the
+ * rectangle's centre outward, so the middle of the screen fills in first.
+ */
+export function tilesInRect(rect, level, levels, bounds, limit = Infinity) {
+    const size = levels[level]?.tileSize;
+    if (!(size > 0))
+        return [];
+    let { x0, y0, x1, y1 } = rect;
+    if (bounds) {
+        x0 = Math.max(x0, bounds[0]);
+        y0 = Math.max(y0, bounds[1]);
+        x1 = Math.min(x1, bounds[2]);
+        y1 = Math.min(y1, bounds[3]);
+        if (x1 < x0 || y1 < y0)
+            return [];
+    }
+    const gx0 = Math.floor(x0 / size);
+    const gx1 = Math.floor(x1 / size);
+    const gy0 = Math.floor(y0 / size);
+    const gy1 = Math.floor(y1 / size);
+    const cx = (rect.x0 + rect.x1) / 2 / size;
+    const cy = (rect.y0 + rect.y1) / 2 / size;
+    const out = [];
+    for (let gy = gy0; gy <= gy1; gy++) {
+        for (let gx = gx0; gx <= gx1; gx++)
+            out.push({ level, gx, gy });
+    }
+    out.sort((a, b) => ((a.gx + 0.5 - cx) ** 2 + (a.gy + 0.5 - cy) ** 2)
+        - ((b.gx + 0.5 - cx) ** 2 + (b.gy + 0.5 - cy) ** 2));
+    return out.length > limit ? out.slice(0, limit) : out;
+}
+/**
+ * Typical cell diameter, in observation units, used to judge how large cells appear.
+ * Derived from the per-observation radius when there is one; 12 µm otherwise.
+ */
+export function typicalCellDiameter(radius, fallback = 12) {
+    if (typeof radius === 'number')
+        return radius > 0 ? radius * 2 : fallback;
+    if (!radius?.length)
+        return fallback;
+    // The median of a sample is plenty — this sets a threshold, not a measurement.
+    const step = Math.max(1, Math.floor(radius.length / 2048));
+    const sample = [];
+    for (let i = 0; i < radius.length; i += step) {
+        if (radius[i] > 0)
+            sample.push(radius[i]);
+    }
+    if (!sample.length)
+        return fallback;
+    sample.sort((a, b) => a - b);
+    return sample[sample.length >> 1] * 2;
+}
+/**
+ * On-screen cell diameter (px) at or above which each polygon level is used. A level
+ * halves the vertices of the one below, so each should take over when the cell is about
+ * half as large on screen. Below the last finite threshold outlines are not drawn at
+ * all — a cell a few pixels wide is a dot, and the observation markers already draw it
+ * as one.
+ *
+ * Xenium's fourth level (3 vertices per cell) is deliberately never used: seen on
+ * screen it is a field of triangles, which reads as an artefact rather than as cells.
+ * The dots below 8 px say the same thing more honestly.
+ */
+export const POLYGON_LEVEL_MIN_CELL_PX = [36, 18, 8, Infinity];
+/**
+ * Which polygon level suits this zoom, or -1 for "too small to outline".
+ * `detail` > 1 prefers finer levels (sharper, slower); < 1 coarser.
+ */
+export function polygonLevelFor(pxPerUnit, cellDiameter, levelCount, detail = 1) {
+    const cellPx = pxPerUnit * cellDiameter * detail;
+    const table = POLYGON_LEVEL_MIN_CELL_PX;
+    for (let l = 0; l < levelCount; l++) {
+        // Past the table, keep halving: each level still halves the vertices.
+        const min = table[l] ?? table[table.length - 1] / 2 ** (l - table.length + 1);
+        if (cellPx >= min)
+            return l;
+    }
+    return -1;
+}
+/**
+ * Which transcript level suits this zoom: the one whose tiles come out closest to
+ * `targetTilePx` on screen. Coarser levels aggregate more, so this keeps the number of
+ * markers per screen roughly constant however far out the camera is — the property that
+ * keeps the view fast.
+ */
+export function transcriptLevelFor(pxPerUnit, levels, targetTilePx = 512) {
+    if (!levels.length || !(pxPerUnit > 0))
+        return 0;
+    let best = 0;
+    let bestErr = Infinity;
+    for (let l = 0; l < levels.length; l++) {
+        const err = Math.abs(Math.log2((levels[l].tileSize * pxPerUnit) / targetTilePx));
+        if (err < bestErr) {
+            bestErr = err;
+            best = l;
+        }
+    }
+    return best;
+}
+/**
+ * The bin a selection of genes is grouped into at this zoom, in observation units, or null
+ * to draw every transcript. Bins follow the all-gene pyramid's ladder (`baseBin` × 2^m) so a
+ * gene selection and "all genes" group alike: the finest bin whose markers land at least
+ * `spacingPx` apart on screen. Once the finest bin is that wide, transcripts are drawn as
+ * themselves.
+ */
+export function geneBinSize(pxPerUnit, baseBin, levels = 7, spacingPx = GROUP_MIN_SPACING_PX) {
+    if (!(pxPerUnit > 0) || !(baseBin > 0))
+        return null;
+    if (baseBin * pxPerUnit >= spacingPx)
+        return null;
+    for (let m = 1; m < levels; m++) {
+        const bin = baseBin * 2 ** m;
+        if (bin * pxPerUnit >= spacingPx)
+            return bin;
+    }
+    return baseBin * 2 ** (levels - 1);
+}
+/** The entries of `t` inside `rect` (observation units). */
+export function clipTranscripts(t, rect) {
+    const keep = [];
+    for (let i = 0; i < t.count; i++) {
+        if (t.x[i] >= rect.x0 && t.x[i] <= rect.x1 && t.y[i] >= rect.y0 && t.y[i] <= rect.y1)
+            keep.push(i);
+    }
+    if (keep.length === t.count)
+        return t;
+    const pick = (a) => {
+        const out = new a.constructor(keep.length);
+        keep.forEach((src, i) => { out[i] = a[src]; });
+        return out;
+    };
+    return {
+        count: keep.length, aggregated: t.aggregated,
+        x: pick(t.x), y: pick(t.y), z: pick(t.z), weight: pick(t.weight), observation: pick(t.observation),
+        gene: pick(t.gene),
+    };
+}
+/**
+ * Group transcripts into `bin`-wide squares of a grid anchored at the origin (so a pan does
+ * not move them), one entry per (group, square): `groupOf(gene slot)` says which group a gene
+ * is in — its cluster in the gene tree, or itself. Each entry sits at its transcripts'
+ * centroid, weighted by how many each stands for; it takes the gene and the cell holding most
+ * of them, each summed over all its transcripts in the entry. `group[i]` is entry i's group.
+ */
+export function groupTranscripts(t, bin, groupOf = (g) => g) {
+    const index = new Map();
+    const sx = [];
+    const sy = [];
+    const sz = [];
+    const w = [];
+    const grp = [];
+    // Per entry, how many transcripts of each gene (the dominant one gives the icon and colour)
+    // and in each cell (the dominant one is the entry's cell).
+    const geneW = [];
+    const obsW = [];
+    for (let i = 0; i < t.count; i++) {
+        const gk = groupOf(t.gene[i]);
+        const key = `${gk}|${Math.floor(t.x[i] / bin)}|${Math.floor(t.y[i] / bin)}`;
+        let k = index.get(key);
+        const wi = t.weight[i] || 1;
+        if (k === undefined) {
+            k = w.length;
+            index.set(key, k);
+            sx.push(0);
+            sy.push(0);
+            sz.push(0);
+            w.push(0);
+            grp.push(gk);
+            geneW.push(new Map());
+            obsW.push(new Map());
+        }
+        sx[k] += t.x[i] * wi;
+        sy[k] += t.y[i] * wi;
+        sz[k] += t.z[i] * wi;
+        w[k] += wi;
+        geneW[k].set(t.gene[i], (geneW[k].get(t.gene[i]) ?? 0) + wi);
+        obsW[k].set(t.observation[i], (obsW[k].get(t.observation[i]) ?? 0) + wi);
+    }
+    const n = w.length;
+    const tile = {
+        count: n, aggregated: true,
+        x: new Float32Array(n), y: new Float32Array(n), z: new Float32Array(n),
+        weight: new Uint32Array(n), observation: new Uint32Array(n), gene: new Uint16Array(n),
+    };
+    const group = new Int32Array(n);
+    for (let k = 0; k < n; k++) {
+        tile.x[k] = sx[k] / w[k];
+        tile.y[k] = sy[k] / w[k];
+        tile.z[k] = sz[k] / w[k];
+        tile.weight[k] = w[k];
+        tile.observation[k] = dominant(obsW[k]);
+        tile.gene[k] = dominant(geneW[k]);
+        group[k] = grp[k];
+    }
+    return { tile, group };
+}
+/** The key with the largest total; the first seen on a tie. */
+function dominant(totals) {
+    let best = 0;
+    let top = -1;
+    for (const [key, v] of totals)
+        if (v > top) {
+            top = v;
+            best = key;
+        }
+    return best;
+}
+/**
+ * The colour of each gene-tree cluster of a selection, for colouring transcripts by cluster: a
+ * cluster named like a group of the cells' grouping takes that group's colour (its cells and its
+ * transcripts agree); the others take palette colours in tree order. Clusters are the tree's
+ * groups holding a selected gene, then each ungrouped selected gene on its own. Every gene of a
+ * cluster gets the same colour — the tree's swatches and the markers use this one map.
+ */
+export function clusterColorMap(genes, groups, cellColors, palette) {
+    const chosen = new Set(genes);
+    const names = [];
+    const grouped = new Set();
+    for (const g of groups) {
+        const mine = g.genes.filter((x) => chosen.has(x) && !grouped.has(x));
+        if (!mine.length)
+            continue;
+        mine.forEach((x) => grouped.add(x));
+        names.push(g.name);
+    }
+    for (const gene of genes)
+        if (!grouped.has(gene))
+            names.push(gene);
+    const out = new Map();
+    let k = 0;
+    for (const name of names) {
+        if (out.has(name))
+            continue;
+        out.set(name, cellColors.get(name) ?? palette[k++ % palette.length]);
+    }
+    return out;
+}
+/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */
+export function clusterOfGene(gene, groups) {
+    return groups.find((g) => g.genes.includes(gene))?.name ?? gene;
+}
+/** Smallest and largest transcript marker, in canvas pixels. */
+export const TRANSCRIPT_MIN_PX = 4;
+export const TRANSCRIPT_MAX_PX = 32;
+/**
+ * Physical diameter a single transcript is drawn at, in µm — clearly larger than the
+ * imaged spot (~0.3 µm) so it stays legible, and small enough that neighbouring
+ * molecules inside one cell stay apart.
+ */
+export const TRANSCRIPT_PHYSICAL_UM = 1.2;
+/**
+ * Marker diameter in canvas pixels for an entry standing for `weight` transcripts.
+ *
+ * The convention spatial viewers share (deck.gl's `radiusMinPixels`/`radiusMaxPixels`,
+ * Xenium Explorer's transcript size): a PHYSICAL size, clamped to a screen-pixel range.
+ * Zoomed out, markers sit at the minimum and never vanish; zoomed in, they grow with the
+ * tissue instead of shrinking to specks next to cells hundreds of pixels wide. A fixed
+ * screen size does the opposite at high zoom, which is what made transcripts disappear
+ * at pixel-level zoom.
+ *
+ * Aggregates grow with the cube root of their count: area ∝ count would let one dense
+ * aggregate swallow its neighbours, the cube root keeps a 1000-transcript cluster clearly
+ * larger than a 10-transcript one without covering the tile.
+ *
+ * `pxPerMicron` is omitted for data with no known physical unit; the marker is then
+ * screen-sized only.
+ */
+export function transcriptMarkerPx(weight, scale = 1, pxPerMicron) {
+    const counted = TRANSCRIPT_MIN_PX * Math.cbrt(Math.max(1, weight));
+    const physical = pxPerMicron ? TRANSCRIPT_PHYSICAL_UM * pxPerMicron : 0;
+    const px = Math.max(counted, physical) * scale;
+    return Math.min(TRANSCRIPT_MAX_PX * Math.max(scale, 1), Math.max(TRANSCRIPT_MIN_PX * scale, px));
+}
+// ── Glyphs ────────────────────────────────────────────────────────────────────────────
+/** Marker shapes for the transcript "icon" mode. All star-convex, so a fan fills them. */
+export const TRANSCRIPT_GLYPHS = [
+    'circle', 'star', 'triangle', 'square', 'diamond', 'cross', 'hexagon', 'triangle-down',
+    'pentagon', 'x',
+];
+// The view state names glyphs without importing this module; keep the two in step.
+const _glyphNamesMatch = true;
+void _glyphNamesMatch;
+/** Unit outline of a glyph, radius ≈ 1, centred on the origin, as `[x0, y0, x1, y1, …]`. */
+export function glyphOutline(glyph) {
+    const poly = (n, rot = -Math.PI / 2, r = 1) => {
+        const out = new Float32Array(n * 2);
+        for (let i = 0; i < n; i++) {
+            const a = rot + (i * 2 * Math.PI) / n;
+            out[2 * i] = Math.cos(a) * r;
+            out[2 * i + 1] = Math.sin(a) * r;
+        }
+        return out;
+    };
+    const star = (points, inner, rot = -Math.PI / 2) => {
+        const out = new Float32Array(points * 4);
+        for (let i = 0; i < points * 2; i++) {
+            const a = rot + (i * Math.PI) / points;
+            const r = i % 2 === 0 ? 1 : inner;
+            out[2 * i] = Math.cos(a) * r;
+            out[2 * i + 1] = Math.sin(a) * r;
+        }
+        return out;
+    };
+    // A plus built as a 12-gon: arms of half-width w.
+    const plus = (w, rotate) => {
+        const pts = [
+            [w, -1], [w, -w], [1, -w], [1, w], [w, w], [w, 1],
+            [-w, 1], [-w, w], [-1, w], [-1, -w], [-w, -w], [-w, -1],
+        ];
+        const out = new Float32Array(pts.length * 2);
+        const c = Math.SQRT1_2;
+        pts.forEach(([x, y], i) => {
+            out[2 * i] = rotate ? (x - y) * c : x;
+            out[2 * i + 1] = rotate ? (x + y) * c : y;
+        });
+        return out;
+    };
+    switch (glyph) {
+        case 'circle': return poly(12);
+        case 'star': return star(5, 0.45);
+        case 'triangle': return poly(3);
+        case 'triangle-down': return poly(3, Math.PI / 2);
+        case 'square': return poly(4, Math.PI / 4, Math.SQRT2 * 0.8);
+        case 'diamond': return poly(4, -Math.PI / 2);
+        case 'hexagon': return poly(6, 0);
+        case 'pentagon': return poly(5);
+        case 'cross': return plus(0.32, false);
+        case 'x': return plus(0.28, true);
+    }
+}
+/** The glyph a gene gets by default: by its position in the selected list. */
+export function defaultGlyphFor(slot) {
+    return TRANSCRIPT_GLYPHS[slot % TRANSCRIPT_GLYPHS.length];
+}
+/**
+ * Expand point markers into glyph rings for a shapes layer: entry `i` becomes a copy of
+ * `glyphs[gene[i]]` scaled to `radius[i]` and centred on `(x[i], y[i])`.
+ */
+export function glyphRings(x, y, radius, glyphOf) {
+    const n = x.length;
+    const offsets = new Uint32Array(n + 1);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        offsets[i] = total;
+        total += glyphOf(i).length / 2;
+    }
+    offsets[n] = total;
+    const coords = new Float32Array(total * 2);
+    for (let i = 0; i < n; i++) {
+        const g = glyphOf(i);
+        const r = radius[i];
+        let o = offsets[i] * 2;
+        for (let k = 0; k < g.length; k += 2) {
+            coords[o++] = x[i] + g[k] * r;
+            coords[o++] = y[i] + g[k + 1] * r;
+        }
+    }
+    return { coords, offsets };
+}
+// ── Discrete colouring through a colormap ─────────────────────────────────────────────
+/**
+ * A shapes layer colours through a colormap LUT, not per-shape RGBA. A categorical
+ * palette becomes a piecewise-constant colormap: category `c` of `n` owns the band
+ * `[c/n, (c+1)/n)`, and a shape takes the value at its band's centre, so the LUT's
+ * linear filtering never blends two categories.
+ *
+ * Returns the stops (linear 0..1 RGB) and a function mapping a category code to the
+ * value to hand the layer. `missing` is the colour of the extra band used for "no
+ * category".
+ */
+export function discreteColormapStops(rgb, missing) {
+    const bands = [...rgb, missing];
+    const n = bands.length;
+    const stops = [];
+    const eps = 1e-6;
+    bands.forEach((c, i) => {
+        const color = [c[0] / 255, c[1] / 255, c[2] / 255];
+        stops.push({ t: i / n + (i === 0 ? 0 : eps), color });
+        stops.push({ t: (i + 1) / n - (i === n - 1 ? 0 : eps), color });
+    });
+    const missingCode = n - 1;
+    return {
+        stops,
+        valueOf: (code) => ((code < 0 || code >= missingCode ? missingCode : code) + 0.5) / n,
+    };
+}
+// ── Density raster ────────────────────────────────────────────────────────────────────
+/**
+ * Separable Gaussian blur of a row-major raster, `sigma` in raster cells.
+ *
+ * A per-gene count raster at 10 µm is mostly zeros and ones — drawn as-is it is speckle,
+ * not a density. A σ of one to two cells (10–20 µm, about a cell diameter) turns it into
+ * a field that reads as territory while keeping structures a few cells wide.
+ */
+export function smoothRaster(values, rows, cols, sigma) {
+    if (!(sigma > 0))
+        return values.slice();
+    const r = Math.max(1, Math.ceil(sigma * 3));
+    const kernel = new Float32Array(2 * r + 1);
+    let sum = 0;
+    for (let i = -r; i <= r; i++)
+        sum += (kernel[i + r] = Math.exp(-(i * i) / (2 * sigma * sigma)));
+    for (let i = 0; i < kernel.length; i++)
+        kernel[i] /= sum;
+    const tmp = new Float32Array(values.length);
+    const out = new Float32Array(values.length);
+    for (let y = 0; y < rows; y++) {
+        const row = y * cols;
+        for (let x = 0; x < cols; x++) {
+            let acc = 0;
+            for (let k = -r; k <= r; k++) {
+                const xx = x + k;
+                if (xx >= 0 && xx < cols)
+                    acc += values[row + xx] * kernel[k + r];
+            }
+            tmp[row + x] = acc;
+        }
+    }
+    for (let y = 0; y < rows; y++) {
+        for (let x = 0; x < cols; x++) {
+            let acc = 0;
+            for (let k = -r; k <= r; k++) {
+                const yy = y + k;
+                if (yy >= 0 && yy < rows)
+                    acc += tmp[yy * cols + x] * kernel[k + r];
+            }
+            out[y * cols + x] = acc;
+        }
+    }
+    return out;
+}
+/**
+ * Colour a density raster as RGBA bytes: log-scaled, windowed at a high percentile of the
+ * non-zero values, and faded in from transparent so empty tissue shows what is under it.
+ */
+export function colorDensity(values, lut, opacity, { log = true, percentile = 0.995 } = {}) {
+    const n = values.length;
+    const t = log ? values.map((v) => Math.log1p(Math.max(0, v))) : values;
+    const positive = [];
+    for (let i = 0; i < n; i++)
+        if (t[i] > 0)
+            positive.push(t[i]);
+    positive.sort((a, b) => a - b);
+    const at = Math.min(positive.length - 1, Math.floor(percentile * positive.length));
+    const hi = positive.length ? positive[at] : 1;
+    const rgba = new Uint8Array(n * 4);
+    for (let i = 0; i < n; i++) {
+        const f = Math.min(1, t[i] / (hi || 1));
+        if (f < 0.02)
+            continue;
+        const c = lut[Math.min(lut.length - 1, Math.round(f * (lut.length - 1)))];
+        rgba[4 * i] = c[0];
+        rgba[4 * i + 1] = c[1];
+        rgba[4 * i + 2] = c[2];
+        rgba[4 * i + 3] = Math.round(255 * opacity * Math.pow(f, 0.6));
+    }
+    return rgba;
+}
+// ── All-gene transcripts: grouping under a marker budget ─────────────────────────────
+/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */
+export const GROUP_MIN_SPACING_PX = 14;
+/** Area of `rect` inside `bounds` (the whole rect when there are none). */
+export function visibleArea(rect, bounds) {
+    const x0 = bounds ? Math.max(rect.x0, bounds[0]) : rect.x0;
+    const y0 = bounds ? Math.max(rect.y0, bounds[1]) : rect.y0;
+    const x1 = bounds ? Math.min(rect.x1, bounds[2]) : rect.x1;
+    const y1 = bounds ? Math.min(rect.y1, bounds[3]) : rect.y1;
+    return Math.max(0, x1 - x0) * Math.max(0, y1 - y0);
+}
+/**
+ * How to draw every transcript in view without exceeding `budget` markers.
+ *
+ * - The transcripts themselves, once the estimated count in view fits the budget.
+ * - Otherwise the finest pyramid level whose bins are at least `minSpacingPx` apart on
+ *   screen and number no more than the budget — groups big enough to read, few enough
+ *   to draw.
+ *
+ * The count in view is estimated from the average density, which over- or under-shoots
+ * locally; the renderer still caps what it draws, so an estimate is enough to choose.
+ */
+export function allGenesPlan(o) {
+    const area = visibleArea(o.rect, o.bounds);
+    if (!(area > 0))
+        return { kind: 'none' };
+    const b = o.bounds;
+    const density = o.total / Math.max(1, (b[2] - b[0]) * (b[3] - b[1]));
+    if (o.canIndividual && density * area <= o.budget)
+        return { kind: 'individual' };
+    if (!o.levels.length)
+        return { kind: 'none' };
+    const spacing = o.minSpacingPx ?? GROUP_MIN_SPACING_PX;
+    for (let l = 0; l < o.levels.length; l++) {
+        const bin = o.levels[l].binSize;
+        // Tissue rarely fills the view; 0.7 of the bins occupied is a fair guess.
+        if (bin * o.pxPerUnit >= spacing && (area / (bin * bin)) * 0.7 <= o.budget) {
+            return { kind: 'bins', level: l };
+        }
+    }
+    return { kind: 'bins', level: o.levels.length - 1 };
+}
+/**
+ * Diameter in px of a group of `count` transcripts in a bin `binPx` wide, where
+ * `refCount` is a typical busy bin in view (its 95th percentile).
+ *
+ * Area grows with the count — a bin with a quarter of the transcripts gets half the
+ * diameter — between a third of the bin (so a sparse bin is still visible) and a little
+ * over the full bin (so dense neighbours just touch rather than pile up).
+ */
+export function groupedMarkerPx(count, refCount, binPx, scale = 1) {
+    const f = Math.sqrt(Math.min(1, count / Math.max(1, refCount)));
+    const d = binPx * (0.35 + 0.75 * f) * scale;
+    return Math.max(TRANSCRIPT_MIN_PX * scale, Math.min(d, binPx * 1.2 * Math.max(scale, 1)));
+}
+/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */
+export function quantileOf(values, p) {
+    const n = values.length;
+    if (!n)
+        return 0;
+    const step = Math.max(1, Math.floor(n / 4096));
+    const sample = [];
+    for (let i = 0; i < n; i += step)
+        sample.push(values[i]);
+    sample.sort((a, b) => a - b);
+    return sample[Math.min(sample.length - 1, Math.floor(p * sample.length))];
+}
+/** {@link tilesInRect} for a grid whose tile (0, 0) starts at `origin`. */
+export function tilesInRectFrom(origin, rect, level, levels, bounds, limit = Infinity) {
+    const [ox, oy] = origin;
+    const shifted = { x0: rect.x0 - ox, y0: rect.y0 - oy, x1: rect.x1 - ox, y1: rect.y1 - oy };
+    const b = bounds ? [bounds[0] - ox, bounds[1] - oy, bounds[2] - ox, bounds[3] - oy] : null;
+    return tilesInRect(shifted, level, levels, b, limit);
+}
+/** A density window from the non-empty bins: 1st to 99th percentile. */
+export function densityAutoRange(values) {
+    const positive = [];
+    for (let i = 0; i < values.length; i++)
+        if (values[i] > 0)
+            positive.push(values[i]);
+    if (!positive.length)
+        return [0, 1];
+    positive.sort((a, b) => a - b);
+    const at = (p) => positive[Math.min(positive.length - 1, Math.floor(p * positive.length))];
+    const lo = at(0.01);
+    const hi = at(0.99);
+    return hi > lo ? [lo, hi] : [0, hi || 1];
+}
+/**
+ * Colour density bins through `lut` over the window `[lo, hi]` — Xenium Explorer's
+ * "scale threshold". Bins at or below `lo` are transparent, so empty tissue shows the
+ * image under it; bins at or above `hi` saturate.
+ */
+export function colorDensityWindow(values, lut, opacity, lo, hi) {
+    const n = values.length;
+    const rgba = new Uint8Array(n * 4);
+    const span = hi > lo ? hi - lo : 1;
+    const a = Math.round(255 * opacity);
+    for (let i = 0; i < n; i++) {
+        const v = values[i];
+        if (!(v > lo))
+            continue;
+        const f = Math.min(1, (v - lo) / span);
+        const c = lut[Math.min(lut.length - 1, Math.round(f * (lut.length - 1)))];
+        rgba[4 * i] = c[0];
+        rgba[4 * i + 1] = c[1];
+        rgba[4 * i + 2] = c[2];
+        rgba[4 * i + 3] = a;
+    }
+    return rgba;
+}
+/**
+ * Inferno (matplotlib), as an inline `[stop, colour]` scale: the density map's default,
+ * as in Xenium Explorer. Inline because the colormap tree's `INFERNO_LUT` key is resolved
+ * at runtime by the store, which the renderer does not see.
+ */
+export const INFERNO_SCALE = [
+    [0, '#000004'], [0.125, '#1b0c41'], [0.25, '#4a0c6b'], [0.375, '#781c6d'], [0.5, '#a52c60'],
+    [0.625, '#cf4446'], [0.75, '#ed6925'], [0.875, '#fb9b06'], [1, '#fcffa4'],
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-tiles.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-tiles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Level-of-detail planning for tiled spatial geometry — cell outlines and transcripts.\n *\n * The renderer knows its camera (a world-space centre, a zoom in canvas pixels per world\n * unit, a canvas size); a tiled dataset knows its grids (one per level, in observation\n * units). This module is the bridge: which level the zoom calls for, which tiles are on\n * screen, how big a transcript marker should be. Everything here is pure, so the policy\n * — the part that decides whether the view is fast and legible — is testable without a\n * GPU.\n *\n * Observation units map onto world units through the dataset's `imageRef` affine\n * (`world = data · scale + translate`), so \"pixels per observation unit\" is\n * `zoom · scale`. For a Xenium bundle the data unit is the micron and the world unit the\n * morphology pixel.\n */\n\nimport type {\n  SpatialBounds, SpatialImageRef, SpatialTileLevel, SpatialTranscriptTile,\n} from '../contracts/spatial-dataset.contract';\nimport type { SpatialViewState, TranscriptGlyphName } from '../contracts/display-types';\nimport type { SpatialDataset } from '../contracts/spatial-dataset.contract';\n\n/** A rectangle in observation coordinates. */\nexport interface DataRect {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/** Tile address. */\nexport interface TileKey {\n  level: number;\n  gx: number;\n  gy: number;\n}\n\n/** Whether cell outlines are drawn: the user's choice, else on when the dataset has any. */\nexport function cellsShown(\n  dataset: Pick<SpatialDataset, 'polygonTiles' | 'polygons'> | null,\n  view: Pick<SpatialViewState, 'showCells'>,\n): boolean {\n  const available = !!(dataset?.polygonTiles || dataset?.polygons);\n  return available && (view.showCells ?? true);\n}\n\n/** A column holding a hand-curated cell-type annotation, by naming convention. */\nexport function isCuratedColumn(name: string): boolean {\n  return /curated/i.test(name);\n}\n\n/**\n * The categorical column that names each cell's type: the view's choice when it is a\n * column of this dataset, else the first categorical column that is not a curated\n * annotation (a pipeline's clustering is the default; curation is opted into), else\n * any categorical column.\n */\nexport function cellTypeColumnFor(\n  dataset: SpatialDataset, view: Pick<SpatialViewState, 'cellTypeColumn'>,\n): string | null {\n  const categorical = dataset.columns.filter((c) => c.kind === 'categorical');\n  if (view.cellTypeColumn && categorical.some((c) => c.name === view.cellTypeColumn)) {\n    return view.cellTypeColumn;\n  }\n  return (categorical.find((c) => !isCuratedColumn(c.name)) ?? categorical[0])?.name ?? null;\n}\n\nexport function tileId(k: TileKey): string {\n  return `${k.level}/${k.gx}/${k.gy}`;\n}\n\n/** Canvas pixels per observation unit along x, for a camera zoom and a data→world affine. */\nexport function pixelsPerDataUnit(zoom: number, ref?: SpatialImageRef | null): number {\n  return zoom * Math.abs(ref?.scale?.[0] ?? 1);\n}\n\n/**\n * The part of observation space the camera shows, padded by `margin` (a fraction of the\n * viewport) so tiles just off screen are already there when a pan brings them in.\n */\nexport function visibleDataRect(\n  center: readonly [number, number], zoom: number, canvasW: number, canvasH: number,\n  ref?: SpatialImageRef | null, margin = 0.15,\n): DataRect | null {\n  if (!(zoom > 0) || !(canvasW > 0) || !(canvasH > 0)) return null;\n  const sx = ref?.scale?.[0] ?? 1;\n  const sy = ref?.scale?.[1] ?? 1;\n  const tx = ref?.translate?.[0] ?? 0;\n  const ty = ref?.translate?.[1] ?? 0;\n  const halfW = (canvasW / zoom / 2) * (1 + 2 * margin);\n  const halfH = (canvasH / zoom / 2) * (1 + 2 * margin);\n  const wx0 = center[0] - halfW;\n  const wx1 = center[0] + halfW;\n  const wy0 = center[1] - halfH;\n  const wy1 = center[1] + halfH;\n  const ax = (wx0 - tx) / sx;\n  const bx = (wx1 - tx) / sx;\n  const ay = (wy0 - ty) / sy;\n  const by = (wy1 - ty) / sy;\n  return { x0: Math.min(ax, bx), y0: Math.min(ay, by), x1: Math.max(ax, bx), y1: Math.max(ay, by) };\n}\n\n/**\n * Tiles of one level intersecting `rect`, clipped to the dataset's `bounds` (so zooming\n * out over empty canvas does not ask for tiles that cannot exist). Ordered from the\n * rectangle's centre outward, so the middle of the screen fills in first.\n */\nexport function tilesInRect(\n  rect: DataRect, level: number, levels: readonly SpatialTileLevel[],\n  bounds?: SpatialBounds | null, limit = Infinity,\n): TileKey[] {\n  const size = levels[level]?.tileSize;\n  if (!(size > 0)) return [];\n  let { x0, y0, x1, y1 } = rect;\n  if (bounds) {\n    x0 = Math.max(x0, bounds[0]);\n    y0 = Math.max(y0, bounds[1]);\n    x1 = Math.min(x1, bounds[2]);\n    y1 = Math.min(y1, bounds[3]);\n    if (x1 < x0 || y1 < y0) return [];\n  }\n  const gx0 = Math.floor(x0 / size);\n  const gx1 = Math.floor(x1 / size);\n  const gy0 = Math.floor(y0 / size);\n  const gy1 = Math.floor(y1 / size);\n  const cx = (rect.x0 + rect.x1) / 2 / size;\n  const cy = (rect.y0 + rect.y1) / 2 / size;\n  const out: TileKey[] = [];\n  for (let gy = gy0; gy <= gy1; gy++) {\n    for (let gx = gx0; gx <= gx1; gx++) out.push({ level, gx, gy });\n  }\n  out.sort((a, b) => ((a.gx + 0.5 - cx) ** 2 + (a.gy + 0.5 - cy) ** 2)\n    - ((b.gx + 0.5 - cx) ** 2 + (b.gy + 0.5 - cy) ** 2));\n  return out.length > limit ? out.slice(0, limit) : out;\n}\n\n/**\n * Typical cell diameter, in observation units, used to judge how large cells appear.\n * Derived from the per-observation radius when there is one; 12 µm otherwise.\n */\nexport function typicalCellDiameter(radius: Float32Array | number | undefined, fallback = 12): number {\n  if (typeof radius === 'number') return radius > 0 ? radius * 2 : fallback;\n  if (!radius?.length) return fallback;\n  // The median of a sample is plenty — this sets a threshold, not a measurement.\n  const step = Math.max(1, Math.floor(radius.length / 2048));\n  const sample: number[] = [];\n  for (let i = 0; i < radius.length; i += step) {\n    if (radius[i] > 0) sample.push(radius[i]);\n  }\n  if (!sample.length) return fallback;\n  sample.sort((a, b) => a - b);\n  return sample[sample.length >> 1] * 2;\n}\n\n/**\n * On-screen cell diameter (px) at or above which each polygon level is used. A level\n * halves the vertices of the one below, so each should take over when the cell is about\n * half as large on screen. Below the last finite threshold outlines are not drawn at\n * all — a cell a few pixels wide is a dot, and the observation markers already draw it\n * as one.\n *\n * Xenium's fourth level (3 vertices per cell) is deliberately never used: seen on\n * screen it is a field of triangles, which reads as an artefact rather than as cells.\n * The dots below 8 px say the same thing more honestly.\n */\nexport const POLYGON_LEVEL_MIN_CELL_PX = [36, 18, 8, Infinity];\n\n/**\n * Which polygon level suits this zoom, or -1 for \"too small to outline\".\n * `detail` > 1 prefers finer levels (sharper, slower); < 1 coarser.\n */\nexport function polygonLevelFor(\n  pxPerUnit: number, cellDiameter: number, levelCount: number, detail = 1,\n): number {\n  const cellPx = pxPerUnit * cellDiameter * detail;\n  const table = POLYGON_LEVEL_MIN_CELL_PX;\n  for (let l = 0; l < levelCount; l++) {\n    // Past the table, keep halving: each level still halves the vertices.\n    const min = table[l] ?? table[table.length - 1] / 2 ** (l - table.length + 1);\n    if (cellPx >= min) return l;\n  }\n  return -1;\n}\n\n/**\n * Which transcript level suits this zoom: the one whose tiles come out closest to\n * `targetTilePx` on screen. Coarser levels aggregate more, so this keeps the number of\n * markers per screen roughly constant however far out the camera is — the property that\n * keeps the view fast.\n */\nexport function transcriptLevelFor(\n  pxPerUnit: number, levels: readonly SpatialTileLevel[], targetTilePx = 512,\n): number {\n  if (!levels.length || !(pxPerUnit > 0)) return 0;\n  let best = 0;\n  let bestErr = Infinity;\n  for (let l = 0; l < levels.length; l++) {\n    const err = Math.abs(Math.log2((levels[l].tileSize * pxPerUnit) / targetTilePx));\n    if (err < bestErr) {\n      bestErr = err;\n      best = l;\n    }\n  }\n  return best;\n}\n\n/**\n * The bin a selection of genes is grouped into at this zoom, in observation units, or null\n * to draw every transcript. Bins follow the all-gene pyramid's ladder (`baseBin` × 2^m) so a\n * gene selection and \"all genes\" group alike: the finest bin whose markers land at least\n * `spacingPx` apart on screen. Once the finest bin is that wide, transcripts are drawn as\n * themselves.\n */\nexport function geneBinSize(\n  pxPerUnit: number, baseBin: number, levels = 7, spacingPx = GROUP_MIN_SPACING_PX,\n): number | null {\n  if (!(pxPerUnit > 0) || !(baseBin > 0)) return null;\n  if (baseBin * pxPerUnit >= spacingPx) return null;\n  for (let m = 1; m < levels; m++) {\n    const bin = baseBin * 2 ** m;\n    if (bin * pxPerUnit >= spacingPx) return bin;\n  }\n  return baseBin * 2 ** (levels - 1);\n}\n\n/** The entries of `t` inside `rect` (observation units). */\nexport function clipTranscripts(t: SpatialTranscriptTile, rect: DataRect): SpatialTranscriptTile {\n  const keep: number[] = [];\n  for (let i = 0; i < t.count; i++) {\n    if (t.x[i] >= rect.x0 && t.x[i] <= rect.x1 && t.y[i] >= rect.y0 && t.y[i] <= rect.y1) keep.push(i);\n  }\n  if (keep.length === t.count) return t;\n  const pick = <A extends Float32Array | Uint32Array | Uint16Array>(a: A): A => {\n    const out = new (a.constructor as new (n: number) => A)(keep.length);\n    keep.forEach((src, i) => { out[i] = a[src]; });\n    return out;\n  };\n  return {\n    count: keep.length, aggregated: t.aggregated,\n    x: pick(t.x), y: pick(t.y), z: pick(t.z), weight: pick(t.weight), observation: pick(t.observation),\n    gene: pick(t.gene),\n  };\n}\n\n/**\n * Group transcripts into `bin`-wide squares of a grid anchored at the origin (so a pan does\n * not move them), one entry per (group, square): `groupOf(gene slot)` says which group a gene\n * is in — its cluster in the gene tree, or itself. Each entry sits at its transcripts'\n * centroid, weighted by how many each stands for; it takes the gene and the cell holding most\n * of them, each summed over all its transcripts in the entry. `group[i]` is entry i's group.\n */\nexport function groupTranscripts(\n  t: SpatialTranscriptTile, bin: number, groupOf: (geneSlot: number) => number = (g) => g,\n): { tile: SpatialTranscriptTile; group: Int32Array } {\n  const index = new Map<string, number>();\n  const sx: number[] = [];\n  const sy: number[] = [];\n  const sz: number[] = [];\n  const w: number[] = [];\n  const grp: number[] = [];\n  // Per entry, how many transcripts of each gene (the dominant one gives the icon and colour)\n  // and in each cell (the dominant one is the entry's cell).\n  const geneW: Map<number, number>[] = [];\n  const obsW: Map<number, number>[] = [];\n  for (let i = 0; i < t.count; i++) {\n    const gk = groupOf(t.gene[i]);\n    const key = `${gk}|${Math.floor(t.x[i] / bin)}|${Math.floor(t.y[i] / bin)}`;\n    let k = index.get(key);\n    const wi = t.weight[i] || 1;\n    if (k === undefined) {\n      k = w.length;\n      index.set(key, k);\n      sx.push(0); sy.push(0); sz.push(0); w.push(0);\n      grp.push(gk); geneW.push(new Map()); obsW.push(new Map());\n    }\n    sx[k] += t.x[i] * wi;\n    sy[k] += t.y[i] * wi;\n    sz[k] += t.z[i] * wi;\n    w[k] += wi;\n    geneW[k].set(t.gene[i], (geneW[k].get(t.gene[i]) ?? 0) + wi);\n    obsW[k].set(t.observation[i], (obsW[k].get(t.observation[i]) ?? 0) + wi);\n  }\n  const n = w.length;\n  const tile: SpatialTranscriptTile = {\n    count: n, aggregated: true,\n    x: new Float32Array(n), y: new Float32Array(n), z: new Float32Array(n),\n    weight: new Uint32Array(n), observation: new Uint32Array(n), gene: new Uint16Array(n),\n  };\n  const group = new Int32Array(n);\n  for (let k = 0; k < n; k++) {\n    tile.x[k] = sx[k] / w[k];\n    tile.y[k] = sy[k] / w[k];\n    tile.z[k] = sz[k] / w[k];\n    tile.weight[k] = w[k];\n    tile.observation[k] = dominant(obsW[k]);\n    tile.gene[k] = dominant(geneW[k]);\n    group[k] = grp[k];\n  }\n  return { tile, group };\n}\n\n/** The key with the largest total; the first seen on a tie. */\nfunction dominant(totals: Map<number, number>): number {\n  let best = 0;\n  let top = -1;\n  for (const [key, v] of totals) if (v > top) { top = v; best = key; }\n  return best;\n}\n\n/**\n * The colour of each gene-tree cluster of a selection, for colouring transcripts by cluster: a\n * cluster named like a group of the cells' grouping takes that group's colour (its cells and its\n * transcripts agree); the others take palette colours in tree order. Clusters are the tree's\n * groups holding a selected gene, then each ungrouped selected gene on its own. Every gene of a\n * cluster gets the same colour — the tree's swatches and the markers use this one map.\n */\nexport function clusterColorMap(\n  genes: readonly string[], groups: readonly { name: string; genes: readonly string[] }[],\n  cellColors: ReadonlyMap<string, string>, palette: readonly string[],\n): Map<string, string> {\n  const chosen = new Set(genes);\n  const names: string[] = [];\n  const grouped = new Set<string>();\n  for (const g of groups) {\n    const mine = g.genes.filter((x) => chosen.has(x) && !grouped.has(x));\n    if (!mine.length) continue;\n    mine.forEach((x) => grouped.add(x));\n    names.push(g.name);\n  }\n  for (const gene of genes) if (!grouped.has(gene)) names.push(gene);\n  const out = new Map<string, string>();\n  let k = 0;\n  for (const name of names) {\n    if (out.has(name)) continue;\n    out.set(name, cellColors.get(name) ?? palette[k++ % palette.length]);\n  }\n  return out;\n}\n\n/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */\nexport function clusterOfGene(\n  gene: string, groups: readonly { name: string; genes: readonly string[] }[],\n): string {\n  return groups.find((g) => g.genes.includes(gene))?.name ?? gene;\n}\n\n/** Smallest and largest transcript marker, in canvas pixels. */\nexport const TRANSCRIPT_MIN_PX = 4;\nexport const TRANSCRIPT_MAX_PX = 32;\n/**\n * Physical diameter a single transcript is drawn at, in µm — clearly larger than the\n * imaged spot (~0.3 µm) so it stays legible, and small enough that neighbouring\n * molecules inside one cell stay apart.\n */\nexport const TRANSCRIPT_PHYSICAL_UM = 1.2;\n\n/**\n * Marker diameter in canvas pixels for an entry standing for `weight` transcripts.\n *\n * The convention spatial viewers share (deck.gl's `radiusMinPixels`/`radiusMaxPixels`,\n * Xenium Explorer's transcript size): a PHYSICAL size, clamped to a screen-pixel range.\n * Zoomed out, markers sit at the minimum and never vanish; zoomed in, they grow with the\n * tissue instead of shrinking to specks next to cells hundreds of pixels wide. A fixed\n * screen size does the opposite at high zoom, which is what made transcripts disappear\n * at pixel-level zoom.\n *\n * Aggregates grow with the cube root of their count: area ∝ count would let one dense\n * aggregate swallow its neighbours, the cube root keeps a 1000-transcript cluster clearly\n * larger than a 10-transcript one without covering the tile.\n *\n * `pxPerMicron` is omitted for data with no known physical unit; the marker is then\n * screen-sized only.\n */\nexport function transcriptMarkerPx(weight: number, scale = 1, pxPerMicron?: number): number {\n  const counted = TRANSCRIPT_MIN_PX * Math.cbrt(Math.max(1, weight));\n  const physical = pxPerMicron ? TRANSCRIPT_PHYSICAL_UM * pxPerMicron : 0;\n  const px = Math.max(counted, physical) * scale;\n  return Math.min(TRANSCRIPT_MAX_PX * Math.max(scale, 1), Math.max(TRANSCRIPT_MIN_PX * scale, px));\n}\n\n// ── Glyphs ────────────────────────────────────────────────────────────────────────────\n\n/** Marker shapes for the transcript \"icon\" mode. All star-convex, so a fan fills them. */\nexport const TRANSCRIPT_GLYPHS = [\n  'circle', 'star', 'triangle', 'square', 'diamond', 'cross', 'hexagon', 'triangle-down',\n  'pentagon', 'x',\n] as const;\nexport type TranscriptGlyph = typeof TRANSCRIPT_GLYPHS[number];\n// The view state names glyphs without importing this module; keep the two in step.\nconst _glyphNamesMatch: TranscriptGlyph extends TranscriptGlyphName\n  ? (TranscriptGlyphName extends TranscriptGlyph ? true : never) : never = true;\nvoid _glyphNamesMatch;\n\n/** Unit outline of a glyph, radius ≈ 1, centred on the origin, as `[x0, y0, x1, y1, …]`. */\nexport function glyphOutline(glyph: TranscriptGlyph): Float32Array {\n  const poly = (n: number, rot = -Math.PI / 2, r = 1) => {\n    const out = new Float32Array(n * 2);\n    for (let i = 0; i < n; i++) {\n      const a = rot + (i * 2 * Math.PI) / n;\n      out[2 * i] = Math.cos(a) * r;\n      out[2 * i + 1] = Math.sin(a) * r;\n    }\n    return out;\n  };\n  const star = (points: number, inner: number, rot = -Math.PI / 2) => {\n    const out = new Float32Array(points * 4);\n    for (let i = 0; i < points * 2; i++) {\n      const a = rot + (i * Math.PI) / points;\n      const r = i % 2 === 0 ? 1 : inner;\n      out[2 * i] = Math.cos(a) * r;\n      out[2 * i + 1] = Math.sin(a) * r;\n    }\n    return out;\n  };\n  // A plus built as a 12-gon: arms of half-width w.\n  const plus = (w: number, rotate: boolean) => {\n    const pts = [\n      [w, -1], [w, -w], [1, -w], [1, w], [w, w], [w, 1],\n      [-w, 1], [-w, w], [-1, w], [-1, -w], [-w, -w], [-w, -1],\n    ];\n    const out = new Float32Array(pts.length * 2);\n    const c = Math.SQRT1_2;\n    pts.forEach(([x, y], i) => {\n      out[2 * i] = rotate ? (x - y) * c : x;\n      out[2 * i + 1] = rotate ? (x + y) * c : y;\n    });\n    return out;\n  };\n  switch (glyph) {\n    case 'circle': return poly(12);\n    case 'star': return star(5, 0.45);\n    case 'triangle': return poly(3);\n    case 'triangle-down': return poly(3, Math.PI / 2);\n    case 'square': return poly(4, Math.PI / 4, Math.SQRT2 * 0.8);\n    case 'diamond': return poly(4, -Math.PI / 2);\n    case 'hexagon': return poly(6, 0);\n    case 'pentagon': return poly(5);\n    case 'cross': return plus(0.32, false);\n    case 'x': return plus(0.28, true);\n  }\n}\n\n/** The glyph a gene gets by default: by its position in the selected list. */\nexport function defaultGlyphFor(slot: number): TranscriptGlyph {\n  return TRANSCRIPT_GLYPHS[slot % TRANSCRIPT_GLYPHS.length];\n}\n\n/**\n * Expand point markers into glyph rings for a shapes layer: entry `i` becomes a copy of\n * `glyphs[gene[i]]` scaled to `radius[i]` and centred on `(x[i], y[i])`.\n */\nexport function glyphRings(\n  x: Float32Array, y: Float32Array, radius: Float32Array, glyphOf: (i: number) => Float32Array,\n): { coords: Float32Array; offsets: Uint32Array } {\n  const n = x.length;\n  const offsets = new Uint32Array(n + 1);\n  let total = 0;\n  for (let i = 0; i < n; i++) {\n    offsets[i] = total;\n    total += glyphOf(i).length / 2;\n  }\n  offsets[n] = total;\n  const coords = new Float32Array(total * 2);\n  for (let i = 0; i < n; i++) {\n    const g = glyphOf(i);\n    const r = radius[i];\n    let o = offsets[i] * 2;\n    for (let k = 0; k < g.length; k += 2) {\n      coords[o++] = x[i] + g[k] * r;\n      coords[o++] = y[i] + g[k + 1] * r;\n    }\n  }\n  return { coords, offsets };\n}\n\n// ── Discrete colouring through a colormap ─────────────────────────────────────────────\n\n/**\n * A shapes layer colours through a colormap LUT, not per-shape RGBA. A categorical\n * palette becomes a piecewise-constant colormap: category `c` of `n` owns the band\n * `[c/n, (c+1)/n)`, and a shape takes the value at its band's centre, so the LUT's\n * linear filtering never blends two categories.\n *\n * Returns the stops (linear 0..1 RGB) and a function mapping a category code to the\n * value to hand the layer. `missing` is the colour of the extra band used for \"no\n * category\".\n */\nexport function discreteColormapStops(\n  rgb: readonly (readonly [number, number, number])[], missing: readonly [number, number, number],\n): { stops: { t: number; color: [number, number, number] }[]; valueOf: (code: number) => number } {\n  const bands = [...rgb, missing];\n  const n = bands.length;\n  const stops: { t: number; color: [number, number, number] }[] = [];\n  const eps = 1e-6;\n  bands.forEach((c, i) => {\n    const color: [number, number, number] = [c[0] / 255, c[1] / 255, c[2] / 255];\n    stops.push({ t: i / n + (i === 0 ? 0 : eps), color });\n    stops.push({ t: (i + 1) / n - (i === n - 1 ? 0 : eps), color });\n  });\n  const missingCode = n - 1;\n  return {\n    stops,\n    valueOf: (code: number) => ((code < 0 || code >= missingCode ? missingCode : code) + 0.5) / n,\n  };\n}\n\n// ── Density raster ────────────────────────────────────────────────────────────────────\n\n/**\n * Separable Gaussian blur of a row-major raster, `sigma` in raster cells.\n *\n * A per-gene count raster at 10 µm is mostly zeros and ones — drawn as-is it is speckle,\n * not a density. A σ of one to two cells (10–20 µm, about a cell diameter) turns it into\n * a field that reads as territory while keeping structures a few cells wide.\n */\nexport function smoothRaster(values: Float32Array, rows: number, cols: number, sigma: number): Float32Array {\n  if (!(sigma > 0)) return values.slice();\n  const r = Math.max(1, Math.ceil(sigma * 3));\n  const kernel = new Float32Array(2 * r + 1);\n  let sum = 0;\n  for (let i = -r; i <= r; i++) sum += (kernel[i + r] = Math.exp(-(i * i) / (2 * sigma * sigma)));\n  for (let i = 0; i < kernel.length; i++) kernel[i] /= sum;\n  const tmp = new Float32Array(values.length);\n  const out = new Float32Array(values.length);\n  for (let y = 0; y < rows; y++) {\n    const row = y * cols;\n    for (let x = 0; x < cols; x++) {\n      let acc = 0;\n      for (let k = -r; k <= r; k++) {\n        const xx = x + k;\n        if (xx >= 0 && xx < cols) acc += values[row + xx] * kernel[k + r];\n      }\n      tmp[row + x] = acc;\n    }\n  }\n  for (let y = 0; y < rows; y++) {\n    for (let x = 0; x < cols; x++) {\n      let acc = 0;\n      for (let k = -r; k <= r; k++) {\n        const yy = y + k;\n        if (yy >= 0 && yy < rows) acc += tmp[yy * cols + x] * kernel[k + r];\n      }\n      out[y * cols + x] = acc;\n    }\n  }\n  return out;\n}\n\n/**\n * Colour a density raster as RGBA bytes: log-scaled, windowed at a high percentile of the\n * non-zero values, and faded in from transparent so empty tissue shows what is under it.\n */\nexport function colorDensity(\n  values: Float32Array, lut: readonly (readonly [number, number, number])[], opacity: number,\n  { log = true, percentile = 0.995 } = {},\n): Uint8Array {\n  const n = values.length;\n  const t = log ? values.map((v) => Math.log1p(Math.max(0, v))) : values;\n  const positive: number[] = [];\n  for (let i = 0; i < n; i++) if (t[i] > 0) positive.push(t[i]);\n  positive.sort((a, b) => a - b);\n  const at = Math.min(positive.length - 1, Math.floor(percentile * positive.length));\n  const hi = positive.length ? positive[at] : 1;\n  const rgba = new Uint8Array(n * 4);\n  for (let i = 0; i < n; i++) {\n    const f = Math.min(1, t[i] / (hi || 1));\n    if (f < 0.02) continue;\n    const c = lut[Math.min(lut.length - 1, Math.round(f * (lut.length - 1)))];\n    rgba[4 * i] = c[0];\n    rgba[4 * i + 1] = c[1];\n    rgba[4 * i + 2] = c[2];\n    rgba[4 * i + 3] = Math.round(255 * opacity * Math.pow(f, 0.6));\n  }\n  return rgba;\n}\n\n// ── All-gene transcripts: grouping under a marker budget ─────────────────────────────\n\n/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */\nexport const GROUP_MIN_SPACING_PX = 14;\n\n/** Area of `rect` inside `bounds` (the whole rect when there are none). */\nexport function visibleArea(rect: DataRect, bounds?: SpatialBounds | null): number {\n  const x0 = bounds ? Math.max(rect.x0, bounds[0]) : rect.x0;\n  const y0 = bounds ? Math.max(rect.y0, bounds[1]) : rect.y0;\n  const x1 = bounds ? Math.min(rect.x1, bounds[2]) : rect.x1;\n  const y1 = bounds ? Math.min(rect.y1, bounds[3]) : rect.y1;\n  return Math.max(0, x1 - x0) * Math.max(0, y1 - y0);\n}\n\nexport type AllGenesPlan = { kind: 'individual' } | { kind: 'bins'; level: number } | { kind: 'none' };\n\n/**\n * How to draw every transcript in view without exceeding `budget` markers.\n *\n * - The transcripts themselves, once the estimated count in view fits the budget.\n * - Otherwise the finest pyramid level whose bins are at least `minSpacingPx` apart on\n *   screen and number no more than the budget — groups big enough to read, few enough\n *   to draw.\n *\n * The count in view is estimated from the average density, which over- or under-shoots\n * locally; the renderer still caps what it draws, so an estimate is enough to choose.\n */\nexport function allGenesPlan(o: {\n  rect: DataRect; bounds: SpatialBounds; total: number; pxPerUnit: number;\n  levels: readonly { binSize: number }[]; budget: number; canIndividual: boolean;\n  minSpacingPx?: number;\n}): AllGenesPlan {\n  const area = visibleArea(o.rect, o.bounds);\n  if (!(area > 0)) return { kind: 'none' };\n  const b = o.bounds;\n  const density = o.total / Math.max(1, (b[2] - b[0]) * (b[3] - b[1]));\n  if (o.canIndividual && density * area <= o.budget) return { kind: 'individual' };\n  if (!o.levels.length) return { kind: 'none' };\n  const spacing = o.minSpacingPx ?? GROUP_MIN_SPACING_PX;\n  for (let l = 0; l < o.levels.length; l++) {\n    const bin = o.levels[l].binSize;\n    // Tissue rarely fills the view; 0.7 of the bins occupied is a fair guess.\n    if (bin * o.pxPerUnit >= spacing && (area / (bin * bin)) * 0.7 <= o.budget) {\n      return { kind: 'bins', level: l };\n    }\n  }\n  return { kind: 'bins', level: o.levels.length - 1 };\n}\n\n/**\n * Diameter in px of a group of `count` transcripts in a bin `binPx` wide, where\n * `refCount` is a typical busy bin in view (its 95th percentile).\n *\n * Area grows with the count — a bin with a quarter of the transcripts gets half the\n * diameter — between a third of the bin (so a sparse bin is still visible) and a little\n * over the full bin (so dense neighbours just touch rather than pile up).\n */\nexport function groupedMarkerPx(count: number, refCount: number, binPx: number, scale = 1): number {\n  const f = Math.sqrt(Math.min(1, count / Math.max(1, refCount)));\n  const d = binPx * (0.35 + 0.75 * f) * scale;\n  return Math.max(TRANSCRIPT_MIN_PX * scale, Math.min(d, binPx * 1.2 * Math.max(scale, 1)));\n}\n\n/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */\nexport function quantileOf(values: ArrayLike<number>, p: number): number {\n  const n = values.length;\n  if (!n) return 0;\n  const step = Math.max(1, Math.floor(n / 4096));\n  const sample: number[] = [];\n  for (let i = 0; i < n; i += step) sample.push(values[i]);\n  sample.sort((a, b) => a - b);\n  return sample[Math.min(sample.length - 1, Math.floor(p * sample.length))];\n}\n\n/** {@link tilesInRect} for a grid whose tile (0, 0) starts at `origin`. */\nexport function tilesInRectFrom(\n  origin: readonly [number, number], rect: DataRect, level: number,\n  levels: readonly SpatialTileLevel[], bounds?: SpatialBounds | null, limit = Infinity,\n): TileKey[] {\n  const [ox, oy] = origin;\n  const shifted = { x0: rect.x0 - ox, y0: rect.y0 - oy, x1: rect.x1 - ox, y1: rect.y1 - oy };\n  const b: SpatialBounds | null = bounds ? [bounds[0] - ox, bounds[1] - oy, bounds[2] - ox, bounds[3] - oy] : null;\n  return tilesInRect(shifted, level, levels, b, limit);\n}\n\n/** A density window from the non-empty bins: 1st to 99th percentile. */\nexport function densityAutoRange(values: ArrayLike<number>): [number, number] {\n  const positive: number[] = [];\n  for (let i = 0; i < values.length; i++) if (values[i] > 0) positive.push(values[i]);\n  if (!positive.length) return [0, 1];\n  positive.sort((a, b) => a - b);\n  const at = (p: number) => positive[Math.min(positive.length - 1, Math.floor(p * positive.length))];\n  const lo = at(0.01);\n  const hi = at(0.99);\n  return hi > lo ? [lo, hi] : [0, hi || 1];\n}\n\n/**\n * Colour density bins through `lut` over the window `[lo, hi]` — Xenium Explorer's\n * \"scale threshold\". Bins at or below `lo` are transparent, so empty tissue shows the\n * image under it; bins at or above `hi` saturate.\n */\nexport function colorDensityWindow(\n  values: ArrayLike<number>, lut: readonly (readonly [number, number, number])[],\n  opacity: number, lo: number, hi: number,\n): Uint8Array {\n  const n = values.length;\n  const rgba = new Uint8Array(n * 4);\n  const span = hi > lo ? hi - lo : 1;\n  const a = Math.round(255 * opacity);\n  for (let i = 0; i < n; i++) {\n    const v = values[i];\n    if (!(v > lo)) continue;\n    const f = Math.min(1, (v - lo) / span);\n    const c = lut[Math.min(lut.length - 1, Math.round(f * (lut.length - 1)))];\n    rgba[4 * i] = c[0];\n    rgba[4 * i + 1] = c[1];\n    rgba[4 * i + 2] = c[2];\n    rgba[4 * i + 3] = a;\n  }\n  return rgba;\n}\n\n/**\n * Inferno (matplotlib), as an inline `[stop, colour]` scale: the density map's default,\n * as in Xenium Explorer. Inline because the colormap tree's `INFERNO_LUT` key is resolved\n * at runtime by the store, which the renderer does not see.\n */\nexport const INFERNO_SCALE: [number, string][] = [\n  [0, '#000004'], [0.125, '#1b0c41'], [0.25, '#4a0c6b'], [0.375, '#781c6d'], [0.5, '#a52c60'],\n  [0.625, '#cf4446'], [0.75, '#ed6925'], [0.875, '#fb9b06'], [1, '#fcffa4'],\n];\n"]}