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

package/esm2022/lib/implementations/napari-js/spatial-tiles/transcript-layers.mjs

@@ -0,0 +1,306 @@
+import { pointSymbolCode } from 'napari-js';
+import { ALL_GENES } from '../../../contracts/ports/spatial-data.port';
+import { NO_CATEGORY, NO_OBSERVATION, } from '../../../contracts/spatial-dataset.contract';
+import { DEFAULT_CATEGORICAL_PALETTE, parseHex, resolveCategoryColors } from '../../../spatial/spatial-encoding';
+import { cellTypeColumnFor } from '../../../spatial/lod';
+import { clusterColorMap } from '../../../spatial/transcript-grouping';
+import { defaultGlyphFor } from '../../../spatial/glyphs';
+import { filterTranscripts, hiddenGeneSlots, median } from '../../../spatial/spatial-tile-merge';
+import { groupSelection } from './transcript-jobs';
+/** Icons get a dark rim only while there are at most this many, at least this big (px). */
+const GLYPH_OUTLINE_MAX = 20_000;
+const GLYPH_OUTLINE_MIN_PX = 8;
+/** The dark rim of a marker. */
+const RIM_COLOR = [0.04, 0.04, 0.05, 0.9];
+/**
+ * The napari-js point symbol each transcript icon is drawn as. Every icon has a counterpart of
+ * the same outline (`circle` is napari's `disc`); see {@link GLYPH_SIZE} for the one whose size
+ * differs.
+ */
+export const GLYPH_SYMBOLS = {
+    circle: 'disc',
+    star: 'star',
+    triangle: 'triangle_up',
+    square: 'square',
+    diamond: 'diamond',
+    cross: 'cross',
+    hexagon: 'hexagon',
+    'triangle-down': 'triangle_down',
+    pentagon: 'pentagon',
+    x: 'x',
+};
+/**
+ * Marker diameter per icon, as a fraction of the entry's: napari's `square` fills the marker's
+ * whole box, where the icon it replaces had a 0.8 half-side, as heavy as the other icons.
+ */
+const GLYPH_SIZE = { square: 0.8 };
+/**
+ * What a transcript plan draws, as a key: an unchanged one is a no-op. Marker sizes follow the
+ * zoom, so the zoom is part of it; a pan that keeps the same tiles on screen changes nothing.
+ */
+function transcriptPlanKey(dataset, view, job, pxPerUnit) {
+    return [
+        dataset.id,
+        view.transcriptMode,
+        job.key,
+        view.transcriptColorBy,
+        cellTypeColumnFor(dataset, view),
+        view.transcriptScale,
+        view.transcriptOpacity,
+        JSON.stringify(view.transcriptGlyphs),
+        pxPerUnit.toPrecision(4),
+        view.hiddenGroups.join('\u0001'),
+        view.transcriptHiddenGenes.join(','),
+        JSON.stringify(view.transcriptGeneColors),
+        JSON.stringify(view.transcriptGeneGroups),
+    ].join('|');
+}
+/** The view the markers are coloured by, for what was loaded. */
+function colorViewFor(view, kind, clustered) {
+    // A bin of the all-gene pyramid mixes genes and carries none, so it cannot be coloured
+    // by gene: colour it by its dominant cell's type until individual transcripts show.
+    if (kind === 'bins' && view.transcriptColorBy !== 'cellType')
+        return { ...view, transcriptColorBy: 'cellType' };
+    // Density-grid markers have no cell to take a type from: they take their cluster's colour.
+    if (clustered && view.transcriptColorBy === 'cellType')
+        return { ...view, transcriptColorBy: 'cluster' };
+    return view;
+}
+const UNASSIGNED_RGBA = [0.62, 0.62, 0.62, 0.55];
+/**
+ * The transcript markers of the 2D spatial view: runs the planner's job, drops hidden groups
+ * and genes, groups a selection under the marker budget, colours the entries and draws them as
+ * one points layer: sized circles, or gene icons as per-point symbols (with a dark rim while
+ * there are few enough).
+ *
+ * Hands what it drew to the hover one way ({@link TranscriptHover.setDrawn}), and keeps the
+ * loaded per-gene transcripts the in-view gene counts are taken from.
+ */
+export class TranscriptLayers {
+    constructor(groups, jobs, lookup, hover) {
+        this.groups = groups;
+        this.jobs = jobs;
+        this.lookup = lookup;
+        this.hover = hover;
+        /** The loaded per-gene transcripts the in-view counts are taken from. */
+        this.countSource = null;
+    }
+    /**
+     * Transcripts of each selected gene inside `rect`: each entry counts for the transcripts it
+     * stands for (an aggregate at a coarse level holds several). Null without per-gene data.
+     */
+    geneCountsIn(rect) {
+        const src = this.countSource;
+        if (!src)
+            return null;
+        const out = {};
+        for (const g of src.genes)
+            out[g] = 0;
+        const { x, y, weight, gene } = src.merged;
+        for (let i = 0; i < src.merged.count; i++) {
+            if (x[i] < rect.x0 || x[i] > rect.x1 || y[i] < rect.y0 || y[i] > rect.y1)
+                continue;
+            const name = src.genes[gene[i]];
+            if (name !== undefined)
+                out[name] += weight[i];
+        }
+        return out;
+    }
+    /** The viewer went away: no counts until the next plan. */
+    detached() {
+        this.countSource = null;
+    }
+    /** Draw the view's transcript markers (or drop them); an unchanged plan key is a no-op. */
+    async plan(dataset, view, rect, pxPerUnit, ctx) {
+        const mode = view.transcriptMode;
+        const job = this.jobs.jobFor(dataset, view, rect, pxPerUnit);
+        if (!job) {
+            this.groups.drop('transcripts');
+            this.hover.clear();
+            this.countSource = null;
+            return;
+        }
+        const planKey = transcriptPlanKey(dataset, view, job, pxPerUnit);
+        if (planKey === this.groups.key('transcripts') && this.groups.shown('transcripts')) {
+            return;
+        }
+        const loaded = await ctx.track('Transcripts', job.load(ctx));
+        if (ctx.stale())
+            return;
+        // Per-gene counts in view come from what was loaded, before hidden genes are dropped:
+        // a hidden gene still has transcripts there. Summed density grids (no per-gene levels,
+        // zoomed out) hold clusters, not genes: no per-gene counts there, rather than a guess.
+        this.countSource =
+            (loaded.kind ?? job.kind) === 'genes' && !loaded.clustered
+                ? { merged: loaded.merged, genes: [...view.transcriptGenes] }
+                : null;
+        const hidden = await this.lookup.hiddenCodes(dataset, view);
+        if (ctx.stale())
+            return;
+        // Density-grid markers carry no cells and were built from the visible genes only.
+        const filtered = loaded.clustered
+            ? { merged: loaded.merged, px: loaded.px }
+            : filterTranscripts(loaded.merged, loaded.px, hidden, (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null);
+        let { merged, px } = filtered;
+        let selectionBin = loaded.clustered?.bin ?? null;
+        let entryGroup = loaded.clustered?.group ?? null;
+        let groupNames = loaded.clustered?.names ?? null;
+        if (loaded.ladder) {
+            const g = groupSelection(merged, view, loaded.ladder, pxPerUnit);
+            if (g)
+                ({ merged, px, bin: selectionBin, group: entryGroup, names: groupNames } = g);
+        }
+        const kind = loaded.kind ?? job.kind;
+        const colorView = colorViewFor(view, kind, !!loaded.clustered);
+        // Each entry's cluster: its marker's group, or the gene-tree group its gene is in.
+        const geneCluster = view.transcriptGenes.map((g) => view.transcriptGeneGroups.find((x) => x.genes.includes(g))?.name ?? g);
+        const clusterOf = (i) => entryGroup && groupNames ? (groupNames[entryGroup[i]] ?? null) : (geneCluster[merged.gene[i]] ?? null);
+        const rgba = await this.transcriptColors(dataset, colorView, merged, kind === 'genes' ? clusterOf : undefined);
+        const typeColumn = cellTypeColumnFor(dataset, view);
+        const types = typeColumn ? await this.lookup.codes(typeColumn).catch(() => null) : null;
+        // Nothing is recorded before the last await: a superseded plan that had already keyed the
+        // group would make the newer plan of the same view take the old layer for its own.
+        if (ctx.stale())
+            return;
+        if (ctx.incomplete)
+            this.groups.forgetKey('transcripts');
+        else
+            this.groups.setKey('transcripts', planKey);
+        const diam = px.map((d) => d / pxPerUnit);
+        const ref = dataset.imageRef;
+        const place = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };
+        const layer = mode === 'circles'
+            ? // A dark rim: a transcript coloured by its cell's type is otherwise the same colour as
+                // the cell fill it sits on, and vanishes into it.
+                this.drawTranscripts(merged, diam, rgba, view, place, null, 0.18 * median(diam))
+            : this.drawTranscriptGlyphs(merged, diam, rgba, view, place, pxPerUnit);
+        this.hover.setDrawn({
+            kind: loaded.kind ?? job.kind,
+            bin: selectionBin
+                ? { size: selectionBin, origin: loaded.clustered?.origin ?? [0, 0] }
+                : loaded.kind
+                    ? loaded.bin
+                    : job.bin,
+            merged,
+            layer,
+            genes: [...view.transcriptGenes],
+            ...(entryGroup && groupNames ? { entryGroup, groupNames } : {}),
+            ...(loaded.clustered ? { groupGenes: loaded.clustered.genes } : {}),
+        }, dataset.micronsPerUnit ?? null);
+        this.hover.setTypes(types);
+    }
+    /**
+     * Gene icons: each entry drawn as its gene's napari-js point symbol, in the same one points
+     * layer as the circles. With every gene drawn there is one icon for all of them — 18,000
+     * shapes would say nothing.
+     */
+    drawTranscriptGlyphs(merged, diam, rgba, view, place, pxPerUnit) {
+        const genes = view.transcriptGenes;
+        const glyphFor = (slot) => view.transcriptGlyphs[genes[slot]] ?? defaultGlyphFor(slot);
+        const single = view.transcriptAllGenes
+            ? (view.transcriptGlyphs[ALL_GENES] ?? 'circle')
+            : null;
+        const slots = single ? [single] : genes.map((_g, slot) => glyphFor(slot));
+        const codes = slots.map((g) => pointSymbolCode(GLYPH_SYMBOLS[g]));
+        const sizes = slots.map((g) => GLYPH_SIZE[g] ?? 1);
+        const symbols = new Uint8Array(merged.count);
+        const size = new Float32Array(merged.count);
+        for (let i = 0; i < merged.count; i++) {
+            const slot = single ? 0 : merged.gene[i];
+            symbols[i] = codes[slot];
+            size[i] = diam[i] * sizes[slot];
+        }
+        // A dark rim, one screen pixel wide, keeps a few large icons readable over the tissue; on
+        // many small ones the rims merge into a solid dark sheet that hides every colour, so they
+        // are left off.
+        const medianPx = median(diam) * pxPerUnit;
+        const rim = merged.count > GLYPH_OUTLINE_MAX || medianPx < GLYPH_OUTLINE_MIN_PX ? 0 : 1 / pxPerUnit;
+        return this.drawTranscripts(merged, size, rgba, view, place, symbols, rim);
+    }
+    /**
+     * The one transcripts layer: a marker per entry, `size` saying how many transcripts it stands
+     * for, drawn as the layer's disc or as each entry's `symbols` code.
+     */
+    drawTranscripts(merged, size, rgba, view, { scale, translate }, symbols, borderWidth) {
+        const positions = new Float32Array(merged.count * 2);
+        for (let i = 0; i < merged.count; i++) {
+            positions[2 * i] = merged.x[i];
+            positions[2 * i + 1] = merged.y[i];
+        }
+        const layer = this.groups.viewer.addPoints(positions, {
+            name: 'transcripts',
+            size,
+            faceColor: rgba,
+            borderColor: RIM_COLOR,
+            borderWidth,
+            symbols,
+            opacity: view.transcriptOpacity,
+            scale,
+            translate,
+        });
+        this.groups.replace('transcripts', layer);
+        return layer;
+    }
+    /** Per-entry colours, as packed RGBA. */
+    async transcriptColors(dataset, view, t, clusterOf) {
+        let rgb;
+        let codeOf;
+        if (view.transcriptColorBy === 'cluster' && clusterOf) {
+            // A cluster named like a group of the cells' grouping takes that group's colour, so a
+            // cluster's transcripts and its cells agree; any other cluster takes a palette colour.
+            const name = cellTypeColumnFor(dataset, view);
+            const codes = name ? await this.lookup.codes(name).catch(() => null) : null;
+            const cellColor = new Map();
+            if (codes?.meta.kind === 'categorical') {
+                const colors = resolveCategoryColors(codes.meta);
+                codes.meta.categories.forEach((c, k) => cellColor.set(c, colors[k]));
+            }
+            const colors = clusterColorMap(view.transcriptGenes, view.transcriptGeneGroups, cellColor, DEFAULT_CATEGORICAL_PALETTE);
+            const index = new Map();
+            const hex = [];
+            const codeFor = (cluster) => {
+                let k = index.get(cluster);
+                if (k === undefined) {
+                    k = hex.length;
+                    index.set(cluster, k);
+                    hex.push(colors.get(cluster) ?? cellColor.get(cluster) ?? DEFAULT_CATEGORICAL_PALETTE[0]);
+                }
+                return k;
+            };
+            const code = new Int32Array(t.count);
+            for (let i = 0; i < t.count; i++) {
+                const c = clusterOf(i);
+                code[i] = c === null ? -1 : codeFor(c);
+            }
+            rgb = hex.map(parseHex);
+            codeOf = (i) => code[i];
+        }
+        else if (view.transcriptColorBy === 'gene' || view.transcriptColorBy === 'cluster') {
+            // All genes: codes are the dataset's gene indices, folded onto the palette.
+            const n = view.transcriptAllGenes ? DEFAULT_CATEGORICAL_PALETTE.length : view.transcriptGenes.length;
+            rgb = Array.from({ length: n }, (_g, i) => parseHex((!view.transcriptAllGenes && view.transcriptGeneColors[view.transcriptGenes[i]]) ||
+                DEFAULT_CATEGORICAL_PALETTE[i % DEFAULT_CATEGORICAL_PALETTE.length]));
+            codeOf = view.transcriptAllGenes ? (i) => t.gene[i] % n : (i) => t.gene[i];
+        }
+        else {
+            const name = cellTypeColumnFor(dataset, view);
+            const codes = name ? await this.lookup.codes(name) : null;
+            rgb = codes?.meta.kind === 'categorical' ? resolveCategoryColors(codes.meta).map(parseHex) : [];
+            codeOf = (i) => {
+                const o = t.observation[i];
+                if (!codes || o === NO_OBSERVATION)
+                    return -1;
+                const c = codes.codes[o];
+                return c === NO_CATEGORY ? -1 : c;
+            };
+        }
+        const rgba = new Float32Array(t.count * 4);
+        const tuples = rgb.map(([r, g, b]) => [r / 255, g / 255, b / 255, 1]);
+        for (let i = 0; i < t.count; i++) {
+            const c = codeOf(i);
+            rgba.set(c < 0 ? UNASSIGNED_RGBA : tuples[c], i * 4);
+        }
+        return rgba;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcript-layers.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/transcript-layers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAI5C,OAAO,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAEvE,OAAO,EACL,WAAW,EACX,cAAc,GAGf,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,2BAA2B,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AACjH,OAAO,EAAY,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAmB,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAKjG,OAAO,EAAiD,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAElG,2FAA2F;AAC3F,MAAM,iBAAiB,GAAG,MAAM,CAAC;AACjC,MAAM,oBAAoB,GAAG,CAAC,CAAC;AAE/B,gCAAgC;AAChC,MAAM,SAAS,GAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAmD;IAC3E,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,aAAa;IACvB,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,OAAO,EAAE,SAAS;IAClB,eAAe,EAAE,eAAe;IAChC,QAAQ,EAAE,UAAU;IACpB,CAAC,EAAE,GAAG;CACP,CAAC;AAEF;;;GAGG;AACH,MAAM,UAAU,GAAuD,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;AAEvF;;;GAGG;AACH,SAAS,iBAAiB,CACxB,OAAuB,EACvB,IAAsB,EACtB,GAAkB,EAClB,SAAiB;IAEjB,OAAO;QACL,OAAO,CAAC,EAAE;QACV,IAAI,CAAC,cAAc;QACnB,GAAG,CAAC,GAAG;QACP,IAAI,CAAC,iBAAiB;QACtB,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC;QAChC,IAAI,CAAC,eAAe;QACpB,IAAI,CAAC,iBAAiB;QACtB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC;QACrC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC;QACpC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC;QACzC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC;KAC1C,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACd,CAAC;AAED,iEAAiE;AACjE,SAAS,YAAY,CAAC,IAAsB,EAAE,IAAoB,EAAE,SAAkB;IACpF,uFAAuF;IACvF,oFAAoF;IACpF,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,CAAC,iBAAiB,KAAK,UAAU;QAAE,OAAO,EAAE,GAAG,IAAI,EAAE,iBAAiB,EAAE,UAAU,EAAE,CAAC;IAChH,2FAA2F;IAC3F,IAAI,SAAS,IAAI,IAAI,CAAC,iBAAiB,KAAK,UAAU;QAAE,OAAO,EAAE,GAAG,IAAI,EAAE,iBAAiB,EAAE,SAAS,EAAE,CAAC;IACzG,OAAO,IAAI,CAAC;AACd,CAAC;AAQD,MAAM,eAAe,GAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAEvD;;;;;;;;GAQG;AACH,MAAM,OAAO,gBAAgB;IAI3B,YACmB,MAAqC,EACrC,IAA0B,EAC1B,MAAyB,EACzB,KAAsB;QAHtB,WAAM,GAAN,MAAM,CAA+B;QACrC,SAAI,GAAJ,IAAI,CAAsB;QAC1B,WAAM,GAAN,MAAM,CAAmB;QACzB,UAAK,GAAL,KAAK,CAAiB;QAPzC,yEAAyE;QACjE,gBAAW,GAA8D,IAAI,CAAC;IAOnF,CAAC;IAEJ;;;OAGG;IACH,YAAY,CAAC,IAAc;QACzB,MAAM,GAAG,GAAG,IAAI,CAAC,WAAW,CAAC;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO,IAAI,CAAC;QACtB,MAAM,GAAG,GAA2B,EAAE,CAAC;QACvC,KAAK,MAAM,CAAC,IAAI,GAAG,CAAC,KAAK;YAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACtC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC;QAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE;gBAAE,SAAS;YACnF,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAChC,IAAI,IAAI,KAAK,SAAS;gBAAE,GAAG,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;QACjD,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,2DAA2D;IAC3D,QAAQ;QACN,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;IAC1B,CAAC;IAED,2FAA2F;IAC3F,KAAK,CAAC,IAAI,CACR,OAAuB,EACvB,IAAsB,EACtB,IAAc,EACd,SAAiB,EACjB,GAAgB;QAEhB,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC;QACjC,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YAChC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;YACnB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;YACxB,OAAO;QACT,CAAC;QACD,MAAM,OAAO,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC;QACjE,IAAI,OAAO,KAAK,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;YACnF,OAAO;QACT,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,aAAa,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC7D,IAAI,GAAG,CAAC,KAAK,EAAE;YAAE,OAAO;QACxB,sFAAsF;QACtF,uFAAuF;QACvF,uFAAuF;QACvF,IAAI,CAAC,WAAW;YACd,CAAC,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS;gBACxD,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC,EAAE;gBAC7D,CAAC,CAAC,IAAI,CAAC;QACX,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC5D,IAAI,GAAG,CAAC,KAAK,EAAE;YAAE,OAAO;QACxB,kFAAkF;QAClF,MAAM,QAAQ,GAAG,MAAM,CAAC,SAAS;YAC/B,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE;YAC1C,CAAC,CAAC,iBAAiB,CACf,MAAM,CAAC,MAAM,EACb,MAAM,CAAC,EAAE,EACT,MAAM,EACN,CAAC,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CACrE,CAAC;QACN,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,QAAQ,CAAC;QAC9B,IAAI,YAAY,GAAkB,MAAM,CAAC,SAAS,EAAE,GAAG,IAAI,IAAI,CAAC;QAChE,IAAI,UAAU,GAAsB,MAAM,CAAC,SAAS,EAAE,KAAK,IAAI,IAAI,CAAC;QACpE,IAAI,UAAU,GAAoB,MAAM,CAAC,SAAS,EAAE,KAAK,IAAI,IAAI,CAAC;QAClE,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,MAAM,CAAC,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;YACjE,IAAI,CAAC;gBAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC;QACvF,CAAC;QACD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC;QACrC,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QAC/D,mFAAmF;QACnF,MAAM,WAAW,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAC1C,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC,CAC7E,CAAC;QACF,MAAM,SAAS,GAAG,CAAC,CAAS,EAAiB,EAAE,CAC7C,UAAU,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;QACzG,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAC/G,MAAM,UAAU,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACpD,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxF,0FAA0F;QAC1F,mFAAmF;QACnF,IAAI,GAAG,CAAC,KAAK,EAAE;YAAE,OAAO;QAExB,IAAI,GAAG,CAAC,UAAU;YAAE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;;YACpD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QAChD,MAAM,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QAC1C,MAAM,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;QAC7B,MAAM,KAAK,GAAc,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC9F,MAAM,KAAK,GACT,IAAI,KAAK,SAAS;YAChB,CAAC,CAAC,uFAAuF;gBACvF,kDAAkD;gBAClD,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;YAClF,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;QAC5E,IAAI,CAAC,KAAK,CAAC,QAAQ,CACjB;YACE,IAAI,EAAE,MAAM,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI;YAC7B,GAAG,EAAE,YAAY;gBACf,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;gBACpE,CAAC,CAAC,MAAM,CAAC,IAAI;oBACX,CAAC,CAAC,MAAM,CAAC,GAAG;oBACZ,CAAC,CAAC,GAAG,CAAC,GAAG;YACb,MAAM;YACN,KAAK;YACL,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,eAAe,CAAC;YAChC,GAAG,CAAC,UAAU,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC/D,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACpE,EACD,OAAO,CAAC,cAAc,IAAI,IAAI,CAC/B,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACK,oBAAoB,CAC1B,MAA6B,EAC7B,IAAkB,EAClB,IAAkB,EAClB,IAAsB,EACtB,KAAgB,EAChB,SAAiB;QAEjB,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC;QACnC,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAmB,EAAE,CAChD,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAiC,IAAI,eAAe,CAAC,IAAI,CAAC,CAAC;QAC/F,MAAM,MAAM,GAAG,IAAI,CAAC,kBAAkB;YACpC,CAAC,CAAC,CAAE,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAiC,IAAI,QAAQ,CAAC;YACjF,CAAC,CAAC,IAAI,CAAC;QACT,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QAC1E,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClE,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QACnD,MAAM,OAAO,GAAG,IAAI,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACzC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QACD,0FAA0F;QAC1F,0FAA0F;QAC1F,gBAAgB;QAChB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;QAC1C,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,GAAG,iBAAiB,IAAI,QAAQ,GAAG,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACpG,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IAC7E,CAAC;IAED;;;OAGG;IACK,eAAe,CACrB,MAA6B,EAC7B,IAAkB,EAClB,IAAkB,EAClB,IAAsB,EACtB,EAAE,KAAK,EAAE,SAAS,EAAa,EAC/B,OAA0B,EAC1B,WAAmB;QAEnB,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QACrD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/B,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAO,CAAC,SAAS,CAAC,SAAS,EAAE;YACrD,IAAI,EAAE,aAAa;YACnB,IAAI;YACJ,SAAS,EAAE,IAAI;YACf,WAAW,EAAE,SAAS;YACtB,WAAW;YACX,OAAO;YACP,OAAO,EAAE,IAAI,CAAC,iBAAiB;YAC/B,KAAK;YACL,SAAS;SACV,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QAC1C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,yCAAyC;IACjC,KAAK,CAAC,gBAAgB,CAC5B,OAAuB,EACvB,IAAsB,EACtB,CAAwB,EACxB,SAAwC;QAExC,IAAI,GAAU,CAAC;QACf,IAAI,MAA6B,CAAC;QAClC,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,IAAI,SAAS,EAAE,CAAC;YACtD,sFAAsF;YACtF,uFAAuF;YACvF,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAC5E,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;YAC5C,IAAI,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;gBACvC,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACjD,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,CAAC;YACD,MAAM,MAAM,GAAG,eAAe,CAC5B,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,oBAAoB,EACzB,SAAS,EACT,2BAA2B,CAC5B,CAAC;YACF,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;YACxC,MAAM,GAAG,GAAa,EAAE,CAAC;YACzB,MAAM,OAAO,GAAG,CAAC,OAAe,EAAE,EAAE;gBAClC,IAAI,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;gBAC3B,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;oBACpB,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;oBACf,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;oBACtB,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5F,CAAC;gBACD,OAAO,CAAC,CAAC;YACX,CAAC,CAAC;YACF,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;YACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;gBACjC,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBACvB,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACzC,CAAC;YACD,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACxB,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1B,CAAC;aAAM,IAAI,IAAI,CAAC,iBAAiB,KAAK,MAAM,IAAI,IAAI,CAAC,iBAAiB,KAAK,SAAS,EAAE,CAAC;YACrF,4EAA4E;YAC5E,MAAM,CAAC,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;YACrG,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CACxC,QAAQ,CACN,CAAC,CAAC,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9E,2BAA2B,CAAC,CAAC,GAAG,2BAA2B,CAAC,MAAM,CAAC,CACtE,CACF,CAAC;YACF,MAAM,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7E,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;YAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAC1D,GAAG,GAAG,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAChG,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE;gBACb,MAAM,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;gBAC3B,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,cAAc;oBAAE,OAAO,CAAC,CAAC,CAAC;gBAC9C,MAAM,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gBACzB,OAAO,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACpC,CAAC,CAAC;QACJ,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAW,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import { pointSymbolCode } from 'napari-js';\nimport type { PointSymbol, PointsLayer, RGBA } from 'napari-js';\n\nimport type { Rgb } from '../../../contracts/colormap-lut';\nimport { ALL_GENES } from '../../../contracts/ports/spatial-data.port';\nimport type { SpatialViewState } from '../../../contracts/display-types';\nimport {\n  NO_CATEGORY,\n  NO_OBSERVATION,\n  SpatialDataset,\n  SpatialTranscriptTile,\n} from '../../../contracts/spatial-dataset.contract';\nimport { DEFAULT_CATEGORICAL_PALETTE, parseHex, resolveCategoryColors } from '../../../spatial/spatial-encoding';\nimport { DataRect, cellTypeColumnFor } from '../../../spatial/lod';\nimport { clusterColorMap } from '../../../spatial/transcript-grouping';\nimport { TranscriptGlyph, defaultGlyphFor } from '../../../spatial/glyphs';\nimport { filterTranscripts, hiddenGeneSlots, median } from '../../../spatial/spatial-tile-merge';\nimport type { CategoricalLookup } from './categorical-lookup';\nimport type { OrderedLayerGroups, TileGroup } from './layer-groups';\nimport type { PlanContext } from './plan-context';\nimport type { TranscriptHover, TranscriptKind } from './transcript-hover';\nimport { type TranscriptJob, type TranscriptJobPlanner, groupSelection } from './transcript-jobs';\n\n/** Icons get a dark rim only while there are at most this many, at least this big (px). */\nconst GLYPH_OUTLINE_MAX = 20_000;\nconst GLYPH_OUTLINE_MIN_PX = 8;\n\n/** The dark rim of a marker. */\nconst RIM_COLOR: RGBA = [0.04, 0.04, 0.05, 0.9];\n\n/**\n * The napari-js point symbol each transcript icon is drawn as. Every icon has a counterpart of\n * the same outline (`circle` is napari's `disc`); see {@link GLYPH_SIZE} for the one whose size\n * differs.\n */\nexport const GLYPH_SYMBOLS: Readonly<Record<TranscriptGlyph, PointSymbol>> = {\n  circle: 'disc',\n  star: 'star',\n  triangle: 'triangle_up',\n  square: 'square',\n  diamond: 'diamond',\n  cross: 'cross',\n  hexagon: 'hexagon',\n  'triangle-down': 'triangle_down',\n  pentagon: 'pentagon',\n  x: 'x',\n};\n\n/**\n * Marker diameter per icon, as a fraction of the entry's: napari's `square` fills the marker's\n * whole box, where the icon it replaces had a 0.8 half-side, as heavy as the other icons.\n */\nconst GLYPH_SIZE: Readonly<Partial<Record<TranscriptGlyph, number>>> = { square: 0.8 };\n\n/**\n * What a transcript plan draws, as a key: an unchanged one is a no-op. Marker sizes follow the\n * zoom, so the zoom is part of it; a pan that keeps the same tiles on screen changes nothing.\n */\nfunction transcriptPlanKey(\n  dataset: SpatialDataset,\n  view: SpatialViewState,\n  job: TranscriptJob,\n  pxPerUnit: number,\n): string {\n  return [\n    dataset.id,\n    view.transcriptMode,\n    job.key,\n    view.transcriptColorBy,\n    cellTypeColumnFor(dataset, view),\n    view.transcriptScale,\n    view.transcriptOpacity,\n    JSON.stringify(view.transcriptGlyphs),\n    pxPerUnit.toPrecision(4),\n    view.hiddenGroups.join('\\u0001'),\n    view.transcriptHiddenGenes.join(','),\n    JSON.stringify(view.transcriptGeneColors),\n    JSON.stringify(view.transcriptGeneGroups),\n  ].join('|');\n}\n\n/** The view the markers are coloured by, for what was loaded. */\nfunction colorViewFor(view: SpatialViewState, kind: TranscriptKind, clustered: boolean): SpatialViewState {\n  // A bin of the all-gene pyramid mixes genes and carries none, so it cannot be coloured\n  // by gene: colour it by its dominant cell's type until individual transcripts show.\n  if (kind === 'bins' && view.transcriptColorBy !== 'cellType') return { ...view, transcriptColorBy: 'cellType' };\n  // Density-grid markers have no cell to take a type from: they take their cluster's colour.\n  if (clustered && view.transcriptColorBy === 'cellType') return { ...view, transcriptColorBy: 'cluster' };\n  return view;\n}\n\n/** Where a layer sits in world space: the dataset's affine onto its tissue image. */\ninterface Placement {\n  scale: [number, number];\n  translate: [number, number];\n}\n\nconst UNASSIGNED_RGBA: RGBA = [0.62, 0.62, 0.62, 0.55];\n\n/**\n * The transcript markers of the 2D spatial view: runs the planner's job, drops hidden groups\n * and genes, groups a selection under the marker budget, colours the entries and draws them as\n * one points layer: sized circles, or gene icons as per-point symbols (with a dark rim while\n * there are few enough).\n *\n * Hands what it drew to the hover one way ({@link TranscriptHover.setDrawn}), and keeps the\n * loaded per-gene transcripts the in-view gene counts are taken from.\n */\nexport class TranscriptLayers {\n  /** The loaded per-gene transcripts the in-view counts are taken from. */\n  private countSource: { merged: SpatialTranscriptTile; genes: string[] } | null = null;\n\n  constructor(\n    private readonly groups: OrderedLayerGroups<TileGroup>,\n    private readonly jobs: TranscriptJobPlanner,\n    private readonly lookup: CategoricalLookup,\n    private readonly hover: TranscriptHover,\n  ) {}\n\n  /**\n   * Transcripts of each selected gene inside `rect`: each entry counts for the transcripts it\n   * stands for (an aggregate at a coarse level holds several). Null without per-gene data.\n   */\n  geneCountsIn(rect: DataRect): Record<string, number> | null {\n    const src = this.countSource;\n    if (!src) return null;\n    const out: Record<string, number> = {};\n    for (const g of src.genes) out[g] = 0;\n    const { x, y, weight, gene } = src.merged;\n    for (let i = 0; i < src.merged.count; i++) {\n      if (x[i] < rect.x0 || x[i] > rect.x1 || y[i] < rect.y0 || y[i] > rect.y1) continue;\n      const name = src.genes[gene[i]];\n      if (name !== undefined) out[name] += weight[i];\n    }\n    return out;\n  }\n\n  /** The viewer went away: no counts until the next plan. */\n  detached(): void {\n    this.countSource = null;\n  }\n\n  /** Draw the view's transcript markers (or drop them); an unchanged plan key is a no-op. */\n  async plan(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    rect: DataRect,\n    pxPerUnit: number,\n    ctx: PlanContext,\n  ): Promise<void> {\n    const mode = view.transcriptMode;\n    const job = this.jobs.jobFor(dataset, view, rect, pxPerUnit);\n    if (!job) {\n      this.groups.drop('transcripts');\n      this.hover.clear();\n      this.countSource = null;\n      return;\n    }\n    const planKey = transcriptPlanKey(dataset, view, job, pxPerUnit);\n    if (planKey === this.groups.key('transcripts') && this.groups.shown('transcripts')) {\n      return;\n    }\n    const loaded = await ctx.track('Transcripts', job.load(ctx));\n    if (ctx.stale()) return;\n    // Per-gene counts in view come from what was loaded, before hidden genes are dropped:\n    // a hidden gene still has transcripts there. Summed density grids (no per-gene levels,\n    // zoomed out) hold clusters, not genes: no per-gene counts there, rather than a guess.\n    this.countSource =\n      (loaded.kind ?? job.kind) === 'genes' && !loaded.clustered\n        ? { merged: loaded.merged, genes: [...view.transcriptGenes] }\n        : null;\n    const hidden = await this.lookup.hiddenCodes(dataset, view);\n    if (ctx.stale()) return;\n    // Density-grid markers carry no cells and were built from the visible genes only.\n    const filtered = loaded.clustered\n      ? { merged: loaded.merged, px: loaded.px }\n      : filterTranscripts(\n          loaded.merged,\n          loaded.px,\n          hidden,\n          (loaded.kind ?? job.kind) === 'genes' ? hiddenGeneSlots(view) : null,\n        );\n    let { merged, px } = filtered;\n    let selectionBin: number | null = loaded.clustered?.bin ?? null;\n    let entryGroup: Int32Array | null = loaded.clustered?.group ?? null;\n    let groupNames: string[] | null = loaded.clustered?.names ?? null;\n    if (loaded.ladder) {\n      const g = groupSelection(merged, view, loaded.ladder, pxPerUnit);\n      if (g) ({ merged, px, bin: selectionBin, group: entryGroup, names: groupNames } = g);\n    }\n    const kind = loaded.kind ?? job.kind;\n    const colorView = colorViewFor(view, kind, !!loaded.clustered);\n    // Each entry's cluster: its marker's group, or the gene-tree group its gene is in.\n    const geneCluster = view.transcriptGenes.map(\n      (g) => view.transcriptGeneGroups.find((x) => x.genes.includes(g))?.name ?? g,\n    );\n    const clusterOf = (i: number): string | null =>\n      entryGroup && groupNames ? (groupNames[entryGroup[i]] ?? null) : (geneCluster[merged.gene[i]] ?? null);\n    const rgba = await this.transcriptColors(dataset, colorView, merged, kind === 'genes' ? clusterOf : undefined);\n    const typeColumn = cellTypeColumnFor(dataset, view);\n    const types = typeColumn ? await this.lookup.codes(typeColumn).catch(() => null) : null;\n    // Nothing is recorded before the last await: a superseded plan that had already keyed the\n    // group would make the newer plan of the same view take the old layer for its own.\n    if (ctx.stale()) return;\n\n    if (ctx.incomplete) this.groups.forgetKey('transcripts');\n    else this.groups.setKey('transcripts', planKey);\n    const diam = px.map((d) => d / pxPerUnit);\n    const ref = dataset.imageRef;\n    const place: Placement = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };\n    const layer =\n      mode === 'circles'\n        ? // A dark rim: a transcript coloured by its cell's type is otherwise the same colour as\n          // the cell fill it sits on, and vanishes into it.\n          this.drawTranscripts(merged, diam, rgba, view, place, null, 0.18 * median(diam))\n        : this.drawTranscriptGlyphs(merged, diam, rgba, view, place, pxPerUnit);\n    this.hover.setDrawn(\n      {\n        kind: loaded.kind ?? job.kind,\n        bin: selectionBin\n          ? { size: selectionBin, origin: loaded.clustered?.origin ?? [0, 0] }\n          : loaded.kind\n            ? loaded.bin\n            : job.bin,\n        merged,\n        layer,\n        genes: [...view.transcriptGenes],\n        ...(entryGroup && groupNames ? { entryGroup, groupNames } : {}),\n        ...(loaded.clustered ? { groupGenes: loaded.clustered.genes } : {}),\n      },\n      dataset.micronsPerUnit ?? null,\n    );\n    this.hover.setTypes(types);\n  }\n\n  /**\n   * Gene icons: each entry drawn as its gene's napari-js point symbol, in the same one points\n   * layer as the circles. With every gene drawn there is one icon for all of them — 18,000\n   * shapes would say nothing.\n   */\n  private drawTranscriptGlyphs(\n    merged: SpatialTranscriptTile,\n    diam: Float32Array,\n    rgba: Float32Array,\n    view: SpatialViewState,\n    place: Placement,\n    pxPerUnit: number,\n  ): PointsLayer {\n    const genes = view.transcriptGenes;\n    const glyphFor = (slot: number): TranscriptGlyph =>\n      (view.transcriptGlyphs[genes[slot]] as TranscriptGlyph | undefined) ?? defaultGlyphFor(slot);\n    const single = view.transcriptAllGenes\n      ? ((view.transcriptGlyphs[ALL_GENES] as TranscriptGlyph | undefined) ?? 'circle')\n      : null;\n    const slots = single ? [single] : genes.map((_g, slot) => glyphFor(slot));\n    const codes = slots.map((g) => pointSymbolCode(GLYPH_SYMBOLS[g]));\n    const sizes = slots.map((g) => GLYPH_SIZE[g] ?? 1);\n    const symbols = new Uint8Array(merged.count);\n    const size = new Float32Array(merged.count);\n    for (let i = 0; i < merged.count; i++) {\n      const slot = single ? 0 : merged.gene[i];\n      symbols[i] = codes[slot];\n      size[i] = diam[i] * sizes[slot];\n    }\n    // A dark rim, one screen pixel wide, keeps a few large icons readable over the tissue; on\n    // many small ones the rims merge into a solid dark sheet that hides every colour, so they\n    // are left off.\n    const medianPx = median(diam) * pxPerUnit;\n    const rim = merged.count > GLYPH_OUTLINE_MAX || medianPx < GLYPH_OUTLINE_MIN_PX ? 0 : 1 / pxPerUnit;\n    return this.drawTranscripts(merged, size, rgba, view, place, symbols, rim);\n  }\n\n  /**\n   * The one transcripts layer: a marker per entry, `size` saying how many transcripts it stands\n   * for, drawn as the layer's disc or as each entry's `symbols` code.\n   */\n  private drawTranscripts(\n    merged: SpatialTranscriptTile,\n    size: Float32Array,\n    rgba: Float32Array,\n    view: SpatialViewState,\n    { scale, translate }: Placement,\n    symbols: Uint8Array | null,\n    borderWidth: number,\n  ): PointsLayer {\n    const positions = new Float32Array(merged.count * 2);\n    for (let i = 0; i < merged.count; i++) {\n      positions[2 * i] = merged.x[i];\n      positions[2 * i + 1] = merged.y[i];\n    }\n    const layer = this.groups.viewer!.addPoints(positions, {\n      name: 'transcripts',\n      size,\n      faceColor: rgba,\n      borderColor: RIM_COLOR,\n      borderWidth,\n      symbols,\n      opacity: view.transcriptOpacity,\n      scale,\n      translate,\n    });\n    this.groups.replace('transcripts', layer);\n    return layer;\n  }\n\n  /** Per-entry colours, as packed RGBA. */\n  private async transcriptColors(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    t: SpatialTranscriptTile,\n    clusterOf?: (i: number) => string | null,\n  ): Promise<Float32Array> {\n    let rgb: Rgb[];\n    let codeOf: (i: number) => number;\n    if (view.transcriptColorBy === 'cluster' && clusterOf) {\n      // A cluster named like a group of the cells' grouping takes that group's colour, so a\n      // cluster's transcripts and its cells agree; any other cluster takes a palette colour.\n      const name = cellTypeColumnFor(dataset, view);\n      const codes = name ? await this.lookup.codes(name).catch(() => null) : null;\n      const cellColor = new Map<string, string>();\n      if (codes?.meta.kind === 'categorical') {\n        const colors = resolveCategoryColors(codes.meta);\n        codes.meta.categories.forEach((c, k) => cellColor.set(c, colors[k]));\n      }\n      const colors = clusterColorMap(\n        view.transcriptGenes,\n        view.transcriptGeneGroups,\n        cellColor,\n        DEFAULT_CATEGORICAL_PALETTE,\n      );\n      const index = new Map<string, number>();\n      const hex: string[] = [];\n      const codeFor = (cluster: string) => {\n        let k = index.get(cluster);\n        if (k === undefined) {\n          k = hex.length;\n          index.set(cluster, k);\n          hex.push(colors.get(cluster) ?? cellColor.get(cluster) ?? DEFAULT_CATEGORICAL_PALETTE[0]);\n        }\n        return k;\n      };\n      const code = new Int32Array(t.count);\n      for (let i = 0; i < t.count; i++) {\n        const c = clusterOf(i);\n        code[i] = c === null ? -1 : codeFor(c);\n      }\n      rgb = hex.map(parseHex);\n      codeOf = (i) => code[i];\n    } else if (view.transcriptColorBy === 'gene' || view.transcriptColorBy === 'cluster') {\n      // All genes: codes are the dataset's gene indices, folded onto the palette.\n      const n = view.transcriptAllGenes ? DEFAULT_CATEGORICAL_PALETTE.length : view.transcriptGenes.length;\n      rgb = Array.from({ length: n }, (_g, i) =>\n        parseHex(\n          (!view.transcriptAllGenes && view.transcriptGeneColors[view.transcriptGenes[i]]) ||\n            DEFAULT_CATEGORICAL_PALETTE[i % DEFAULT_CATEGORICAL_PALETTE.length],\n        ),\n      );\n      codeOf = view.transcriptAllGenes ? (i) => t.gene[i] % n : (i) => t.gene[i];\n    } else {\n      const name = cellTypeColumnFor(dataset, view);\n      const codes = name ? await this.lookup.codes(name) : null;\n      rgb = codes?.meta.kind === 'categorical' ? resolveCategoryColors(codes.meta).map(parseHex) : [];\n      codeOf = (i) => {\n        const o = t.observation[i];\n        if (!codes || o === NO_OBSERVATION) return -1;\n        const c = codes.codes[o];\n        return c === NO_CATEGORY ? -1 : c;\n      };\n    }\n    const rgba = new Float32Array(t.count * 4);\n    const tuples: RGBA[] = rgb.map(([r, g, b]) => [r / 255, g / 255, b / 255, 1]);\n    for (let i = 0; i < t.count; i++) {\n      const c = codeOf(i);\n      rgba.set(c < 0 ? UNASSIGNED_RGBA : tuples[c], i * 4);\n    }\n    return rgba;\n  }\n}\n"]}