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

package/lib/spatial/spatial-tiles.d.ts

@@ -0,0 +1,259 @@
+/**
+ * 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.
+ */
+import type { SpatialBounds, SpatialImageRef, SpatialTileLevel, SpatialTranscriptTile } from '../contracts/spatial-dataset.contract';
+import type { SpatialViewState } from '../contracts/display-types';
+import type { SpatialDataset } from '../contracts/spatial-dataset.contract';
+/** A rectangle in observation coordinates. */
+export interface DataRect {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** Tile address. */
+export interface TileKey {
+    level: number;
+    gx: number;
+    gy: number;
+}
+/** Whether cell outlines are drawn: the user's choice, else on when the dataset has any. */
+export declare function cellsShown(dataset: Pick<SpatialDataset, 'polygonTiles' | 'polygons'> | null, view: Pick<SpatialViewState, 'showCells'>): boolean;
+/** A column holding a hand-curated cell-type annotation, by naming convention. */
+export declare function isCuratedColumn(name: string): boolean;
+/**
+ * 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 declare function cellTypeColumnFor(dataset: SpatialDataset, view: Pick<SpatialViewState, 'cellTypeColumn'>): string | null;
+export declare function tileId(k: TileKey): string;
+/** Canvas pixels per observation unit along x, for a camera zoom and a data→world affine. */
+export declare function pixelsPerDataUnit(zoom: number, ref?: SpatialImageRef | null): number;
+/**
+ * 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 declare function visibleDataRect(center: readonly [number, number], zoom: number, canvasW: number, canvasH: number, ref?: SpatialImageRef | null, margin?: number): DataRect | null;
+/**
+ * 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 declare function tilesInRect(rect: DataRect, level: number, levels: readonly SpatialTileLevel[], bounds?: SpatialBounds | null, limit?: number): TileKey[];
+/**
+ * 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 declare function typicalCellDiameter(radius: Float32Array | number | undefined, fallback?: number): number;
+/**
+ * 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 declare const POLYGON_LEVEL_MIN_CELL_PX: number[];
+/**
+ * Which polygon level suits this zoom, or -1 for "too small to outline".
+ * `detail` > 1 prefers finer levels (sharper, slower); < 1 coarser.
+ */
+export declare function polygonLevelFor(pxPerUnit: number, cellDiameter: number, levelCount: number, detail?: number): number;
+/**
+ * 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 declare function transcriptLevelFor(pxPerUnit: number, levels: readonly SpatialTileLevel[], targetTilePx?: number): number;
+/**
+ * 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 declare function geneBinSize(pxPerUnit: number, baseBin: number, levels?: number, spacingPx?: number): number | null;
+/** The entries of `t` inside `rect` (observation units). */
+export declare function clipTranscripts(t: SpatialTranscriptTile, rect: DataRect): SpatialTranscriptTile;
+/**
+ * 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 declare function groupTranscripts(t: SpatialTranscriptTile, bin: number, groupOf?: (geneSlot: number) => number): {
+    tile: SpatialTranscriptTile;
+    group: Int32Array;
+};
+/**
+ * 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 declare function clusterColorMap(genes: readonly string[], groups: readonly {
+    name: string;
+    genes: readonly string[];
+}[], cellColors: ReadonlyMap<string, string>, palette: readonly string[]): Map<string, string>;
+/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */
+export declare function clusterOfGene(gene: string, groups: readonly {
+    name: string;
+    genes: readonly string[];
+}[]): string;
+/** Smallest and largest transcript marker, in canvas pixels. */
+export declare const TRANSCRIPT_MIN_PX = 4;
+export declare 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 declare 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 declare function transcriptMarkerPx(weight: number, scale?: number, pxPerMicron?: number): number;
+/** Marker shapes for the transcript "icon" mode. All star-convex, so a fan fills them. */
+export declare const TRANSCRIPT_GLYPHS: readonly ["circle", "star", "triangle", "square", "diamond", "cross", "hexagon", "triangle-down", "pentagon", "x"];
+export type TranscriptGlyph = typeof TRANSCRIPT_GLYPHS[number];
+/** Unit outline of a glyph, radius ≈ 1, centred on the origin, as `[x0, y0, x1, y1, …]`. */
+export declare function glyphOutline(glyph: TranscriptGlyph): Float32Array;
+/** The glyph a gene gets by default: by its position in the selected list. */
+export declare function defaultGlyphFor(slot: number): TranscriptGlyph;
+/**
+ * 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 declare function glyphRings(x: Float32Array, y: Float32Array, radius: Float32Array, glyphOf: (i: number) => Float32Array): {
+    coords: Float32Array;
+    offsets: Uint32Array;
+};
+/**
+ * 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 declare function discreteColormapStops(rgb: readonly (readonly [number, number, number])[], missing: readonly [number, number, number]): {
+    stops: {
+        t: number;
+        color: [number, number, number];
+    }[];
+    valueOf: (code: number) => number;
+};
+/**
+ * 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 declare function smoothRaster(values: Float32Array, rows: number, cols: number, sigma: number): Float32Array;
+/**
+ * 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 declare function colorDensity(values: Float32Array, lut: readonly (readonly [number, number, number])[], opacity: number, { log, percentile }?: {
+    log?: boolean | undefined;
+    percentile?: number | undefined;
+}): Uint8Array;
+/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */
+export declare const GROUP_MIN_SPACING_PX = 14;
+/** Area of `rect` inside `bounds` (the whole rect when there are none). */
+export declare function visibleArea(rect: DataRect, bounds?: SpatialBounds | null): number;
+export type AllGenesPlan = {
+    kind: 'individual';
+} | {
+    kind: 'bins';
+    level: number;
+} | {
+    kind: 'none';
+};
+/**
+ * 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 declare function allGenesPlan(o: {
+    rect: DataRect;
+    bounds: SpatialBounds;
+    total: number;
+    pxPerUnit: number;
+    levels: readonly {
+        binSize: number;
+    }[];
+    budget: number;
+    canIndividual: boolean;
+    minSpacingPx?: number;
+}): AllGenesPlan;
+/**
+ * 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 declare function groupedMarkerPx(count: number, refCount: number, binPx: number, scale?: number): number;
+/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */
+export declare function quantileOf(values: ArrayLike<number>, p: number): number;
+/** {@link tilesInRect} for a grid whose tile (0, 0) starts at `origin`. */
+export declare function tilesInRectFrom(origin: readonly [number, number], rect: DataRect, level: number, levels: readonly SpatialTileLevel[], bounds?: SpatialBounds | null, limit?: number): TileKey[];
+/** A density window from the non-empty bins: 1st to 99th percentile. */
+export declare function densityAutoRange(values: ArrayLike<number>): [number, number];
+/**
+ * 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 declare function colorDensityWindow(values: ArrayLike<number>, lut: readonly (readonly [number, number, number])[], opacity: number, lo: number, hi: number): Uint8Array;
+/**
+ * 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 declare const INFERNO_SCALE: [number, string][];

package/lib/spatial-controls/spatial-controls.component.d.ts

@@ -1,7 +1,7 @@
-import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { EventEmitter, NgZone, OnDestroy, OnInit } from '@angular/core';
 import { IVisualizer, ISpatialControls } from '../contracts/visualizer.contract';
 import { SpatialDataset } from '../contracts/spatial-dataset.contract';
-import { ColormapNode, SpatialViewState } from '../contracts/display-types';
+import { ColormapNode, SpatialViewState, TranscriptGlyphName } from '../contracts/display-types';
 import { SpatialSelectionMask } from '../spatial/spatial-selection';
 import * as i0 from "@angular/core";
 /** One legend row for a categorical colouring. */
@@ -9,6 +9,14 @@ export interface SpatialLegendEntry {
     label: string;
     color: string;
 }
+/**
+ * `group,gene` rows (CSV or TSV, header optional) → gene groups, in file order.
+ * Exported for tests.
+ */
+export declare function parseGeneGroups(text: string): {
+    name: string;
+    genes: string[];
+}[];
 /**
  * Spatial-omics controls: a non-modal, resizable, draggable dialog for choosing
  * what the observation markers are coloured by, and how they are drawn.
@@ -25,6 +33,7 @@ export interface SpatialLegendEntry {
  */
 export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     private readonly viz;
+    private readonly zone;
     /** The embedded chart, so a dialog resize can re-fit it. */
     private charts?;
     /**
@@ -130,7 +139,7 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     private geneSearchToken;
     private keyToken;
     private readonly subs;
-    constructor(viz: IVisualizer);
+    constructor(viz: IVisualizer, zone: NgZone);
     ngOnInit(): void;
     ngOnDestroy(): void;
     onVisibleChange(value: boolean): void;
@@ -145,6 +154,23 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
      * hop further away.
      */
     onGeneFilter(query: string): Promise<void>;
+    /**
+     * Opening either gene dropdown — "Colour by gene" or the transcript genes. Both share
+     * one list and one search, so each opens on the head of the full list rather than on
+     * whatever the other was last filtered to.
+     *
+     * A whole-transcriptome dataset does not inline its ~30k names; they are fetched here,
+     * once, on first open — the list is then resident and every keystroke filters locally,
+     * exactly as for a targeted panel. Until it arrives the dropdown falls back to asking
+     * the server per keystroke.
+     */
+    ensureGeneList(): Promise<void>;
+    /** Most names fetched for the lazy list — well above any panel, whole-transcriptome included. */
+    private static readonly GENE_LIST_MAX;
+    private geneListLoading;
+    /** Options for `names`, plus the genes already chosen (a multi-select shows a chip only
+     *  for a value it can find among its options). */
+    private withSelected;
     /** A gene was picked; it supersedes any column selection. */
     onGene(name: string | null): void;
     /** Select every observation inside the drawn regions (their union). */
@@ -221,6 +247,265 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     /** Mirrors the renderer's cap, for the note only. */
     private static readonly DENSITY_MAX_CLUSTERS;
     onClip(value: [number, number]): void;
+    readonly cellDrawOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly transcriptColorOptions: {
+        label: string;
+        value: string;
+    }[];
+    readonly glyphOptions: {
+        label: string;
+        value: TranscriptGlyphName;
+        points: string;
+    }[];
+    readonly budgetOptions: {
+        label: string;
+        value: number;
+    }[];
+    /** Boundaries on offer: tiled (level-of-detail) or whole-dataset rings. */
+    get hasCells(): boolean;
+    get hasTranscripts(): boolean;
+    /** Whether outlines are on — the explicit choice, or automatically for data that has them. */
+    get cellsOn(): boolean;
+    get activeCellSet(): string | null;
+    /**
+     * Option lists for the cell/transcript controls. Built once per dataset rather than in
+     * getters: a getter returns a fresh array on every change-detection pass, and PrimeNG
+     * re-renders its buttons whenever the array identity changes — which made them
+     * impossible to click.
+     */
+    cellSetOptions: {
+        label: string;
+        value: string;
+    }[];
+    transcriptModeOptions: {
+        label: string;
+        value: SpatialViewState['transcriptMode'];
+    }[];
+    private buildTileOptions;
+    /** Cell colour modes on offer (Xenium Explorer's "Cell Color"). */
+    cellColorOptions: {
+        label: string;
+        value: SpatialViewState['cellColorMode'];
+    }[];
+    /**
+     * The group picker: categorical columns under their section heading, a family of
+     * variants (k-means at k = 2…10) listed once. Values are a column name, or
+     * `family:<id>` for a family.
+     */
+    groupOptions: {
+        label: string;
+        items: {
+            label: string;
+            value: string;
+        }[];
+    }[];
+    /** Variants of the active family (k = 2…10), when a family is active. */
+    groupVariantOptions: {
+        label: string;
+        value: string;
+    }[];
+    /** The last variant chosen per family, so switching away and back keeps k. */
+    private familyChoice;
+    private buildGroupOptions;
+    /** The picker's value for the active group column. */
+    get activeGroupEntry(): string | null;
+    private refreshVariants;
+    onGroupEntry(value: string): void;
+    onGroupVariant(name: string): void;
+    /** The active grouping's categories with colours and cell counts, largest first. */
+    groupRows: {
+        label: string;
+        color: string;
+        count: number;
+    }[];
+    groupTotal: number;
+    groupsExpanded: boolean;
+    private groupRowsFor;
+    groupImportError: string | null;
+    groupImporting: boolean;
+    private refreshGroups;
+    isGroupShown(label: string): boolean;
+    get allGroupsShown(): boolean;
+    onGroupShown(label: string, on: boolean): void;
+    onAllGroupsShown(on: boolean): void;
+    get canImportGroups(): boolean;
+    /** '+': a CSV/TSV of `cell_id` and group, named after the file. */
+    onImportGroupsFile(input: HTMLInputElement): Promise<void>;
+    get activeCellTypeColumn(): string | null;
+    onShowCells(on: boolean): void;
+    onCellSet(set: string): void;
+    onCellDraw(draw: SpatialViewState['cellDraw']): void;
+    onCellOpacity(value: number | undefined): void;
+    onCellTypeColumn(name: string | null): void;
+    onCellColorMode(mode: SpatialViewState['cellColorMode']): void;
+    onCellColorGene(gene: string | null): void;
+    onCellSingleColor(hex: string): void;
+    /** Fill opacity as a 0–100 number, for the box beside the slider. */
+    onCellOpacityPercent(v: number | null): void;
+    onShowImage(on: boolean): void;
+    onShowAnnotations(on: boolean): void;
+    /** Which collapsible sections are open. Per dialog instance, not persisted. */
+    open: Record<'images' | 'cells' | 'transcripts' | 'annotations' | 'observations', boolean>;
+    toggleSection(name: keyof SpatialControlsComponent['open']): void;
+    /** The mode the section header's switch turns back on. */
+    private lastTranscriptMode;
+    onTranscriptsOn(on: boolean): void;
+    /** Estimated transcripts in view, against the budget — Explorer's points bar. */
+    estimate: {
+        points: number;
+        max: number;
+    } | null;
+    /** The density window in use and its densest bin, for the threshold control. */
+    densityStats: {
+        lo: number;
+        hi: number;
+        max: number;
+    } | null;
+    get estimatePercent(): number;
+    get estimateOverMax(): boolean;
+    editingMax: boolean;
+    /** The selected genes as Explorer's tree: named groups, then the ungrouped ones. */
+    /** Rebuilt when the view changes — never per change-detection pass (see buildTileOptions). */
+    geneTree: {
+        name: string | null;
+        genes: string[];
+    }[];
+    geneMenu: {
+        label: string;
+        icon: string;
+        command: () => void;
+        disabled?: boolean;
+    }[];
+    private buildGeneTree;
+    /** Real genes in the panel — the tree's denominator. */
+    get geneTotal(): number;
+    collapsedGeneGroups: Set<string>;
+    geneTreeOpen: boolean;
+    toggleGeneGroup(name: string): void;
+    isGeneShown(gene: string): boolean;
+    areGenesShown(genes: string[]): boolean;
+    /** The eye toggle: hide or show genes without removing them from the selection. */
+    onGenesShown(genes: string[], on: boolean): void;
+    onGeneColor(gene: string, hex: string): void;
+    /** Swatches in the picker: the categorical palette genes are coloured from by default. */
+    readonly colorPresets: string[];
+    /** The gene the open picker edits. */
+    styleGene: string | null;
+    openGeneStyle(event: Event, gene: string, panel: {
+        toggle(e: Event): void;
+        hide(): void;
+    }): void;
+    /** The icon the open picker shows as chosen. */
+    get styleGlyph(): TranscriptGlyphName | null;
+    glyphPoints(glyph: TranscriptGlyphName): string;
+    /** A typed hex colour, accepted as `#rrggbb` or `rrggbb`; anything else is ignored. */
+    onGeneHex(gene: string, text: string): void;
+    /** Back to the gene's default icon and colour (by its position in the list). */
+    resetGeneStyle(gene: string): void;
+    /** '±': every gene, or back to the chosen list. */
+    onToggleAllGenes(): void;
+    /** '⋮' menu. */
+    private buildGeneMenu;
+    /** The hidden file input the menu's import opens. */
+    private geneGroupFileRef?;
+    private get geneGroupInput();
+    trackByLabel: (_i: number, row: {
+        label: string;
+    }) => string;
+    trackByNode: (_i: number, node: {
+        name: string | null;
+    }) => string;
+    trackByLabelString: (_i: number, s: string) => string;
+    get cellOpacityPercent(): number;
+    get densityOpacityPercent(): number;
+    geneGroupError: string | null;
+    /** Transcripts of each selected gene in the current view, from the renderer. */
+    geneCounts: Record<string, number> | null;
+    geneCountOf(gene: string): number | null;
+    markersOpen: boolean;
+    markerColumn: string | null;
+    markerPerGroup: number;
+    readonly markerPerGroupOptions: {
+        label: string;
+        value: number;
+    }[];
+    markerClusters: string[];
+    markerClusterOptions: {
+        label: string;
+        value: string;
+    }[];
+    markerLoading: boolean;
+    markerError: string | null;
+    get canAddMarkers(): boolean;
+    /** Every categorical column but the segmentation method, which says nothing about genes. */
+    get markerColumnOptions(): {
+        label: string;
+        value: string;
+    }[];
+    openMarkers(): void;
+    onMarkerColumn(column: string): void;
+    /** The clusters of the chosen column, all picked to start with. */
+    private refreshMarkerClusters;
+    /**
+     * Add each picked cluster's top marker genes as a gene group named after it, and select
+     * them. A gene that marks several clusters goes to the one it is most specific to, so the
+     * tree lists it once.
+     */
+    addMarkerGenes(): Promise<void>;
+    onNewGeneGroup(): void;
+    /**
+     * Import gene groups: CSV/TSV with a group and a gene column (header optional), e.g.
+     * marker genes per cell type. The genes are added to the selection.
+     */
+    onImportGeneGroups(input: HTMLInputElement): Promise<void>;
+    readonly densityBins: number[];
+    get densityBinIndex(): number;
+    onDensityBinIndex(i: number | undefined): void;
+    onDensityOpacityPercent(v: number | null): void;
+    /**
+     * The threshold window shown: the one set, else the one derived. A stored array, not a
+     * getter: a range slider's `ngModel` given a fresh array every change-detection pass
+     * schedules another pass, forever — which hung the page the moment the density
+     * controls appeared.
+     */
+    densityWindow: [number, number];
+    densitySliderMax: number;
+    densityStep: number;
+    private refreshDensityWindow;
+    onDensityRange(range: [number, number] | number[] | undefined): void;
+    onDensityRangeEnd(which: 0 | 1, v: number | null): void;
+    onDensityAuto(): void;
+    selectedDensityColormapNode: ColormapNode | null;
+    onDensityColormap(node: ColormapNode | null): void;
+    get densityColorBarCss(): string;
+    onTranscriptMode(mode: SpatialViewState['transcriptMode']): void;
+    onTranscriptGenes(genes: string[] | null): void;
+    /** "All genes" needs the grouping pyramid, or at least tiles to draw individually. */
+    get canShowAllGenes(): boolean;
+    /** Why "All genes" is not offered yet, while the server builds its pyramid. */
+    get allGenesPreparing(): string | null;
+    get showingAllGenes(): boolean;
+    onTranscriptAllGenes(on: boolean): void;
+    onTranscriptBudget(n: number): void;
+    onTranscriptColorBy(by: SpatialViewState['transcriptColorBy']): void;
+    onTranscriptScale(value: number | undefined): void;
+    onTranscriptOpacity(value: number | undefined): void;
+    onTranscriptQuality(includeLow: boolean): void;
+    onDensityOpacity(value: number | undefined): void;
+    glyphOf(gene: string, slot: number): TranscriptGlyphName;
+    onGlyph(gene: string, glyph: TranscriptGlyphName): void;
+    /** The colour gene `slot` is drawn in when transcripts are coloured by gene. */
+    geneColor(slot: number): string;
+    /** Colours of the cells' groups, by name — what a cluster of the same name is drawn in. */
+    private cellGroupColors;
+    private cellGroupColorsFor;
+    private refreshCellGroupColors;
+    /** In Cluster colouring, a gene's swatch is its cluster's colour, as its markers are. */
+    geneSwatchOf(gene: string): string;
+    geneColorOf(gene: string): string;
     reset(): void;
     /**
      * Description of the active column, when it has one. Surfaced because a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jax-data-science/sci-image-visualizer",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "engines": {
     "node": ">=20.9.0"
   },