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

package/lib/contracts/display-types.d.ts

@@ -252,8 +252,10 @@ export interface SpatialViewState {
      * level-of-detail — aggregated when zoomed out, one per transcript at the finest zoom.
      */
     transcriptMode: 'off' | 'circles' | 'glyphs' | 'density';
-    /** Colour transcripts by the type of the cell they fall in, or by gene. */
-    transcriptColorBy: 'cellType' | 'gene';
+    /** Colour transcripts by the type of the cell they fall in, by gene, or by the gene-tree
+     *  cluster their gene is in (in the colour that cluster's cells have, when a cell grouping
+     *  names it). */
+    transcriptColorBy: 'cellType' | 'gene' | 'cluster';
     /** Glyph per gene for `glyphs` mode; genes not listed take one by position. */
     transcriptGlyphs: Record<string, TranscriptGlyphName>;
     /** Multiplier on transcript marker size. */

package/lib/contracts/plot-type-contribution.contract.d.ts

@@ -102,6 +102,15 @@ export interface PlotModeViewport {
     /** Same rect, emitted once the viewport settles (existing getViewportChange$ semantics).
      *  A new subscriber first receives the current rect when the viewport is ready. */
     settled$: Observable<PlotModeRect>;
+    /**
+     * Pan and zoom so a level-0 image rect fills the view (within the viewer's zoom
+     * constraints), e.g. to take the user to a region a mode proposes. Animated unless
+     * `immediately`. A no-op while the viewport is not ready. Optional: backends without
+     * a 2D image viewport leave it out, so callers feature-detect it.
+     */
+    fitBounds?(rect: PlotModeRect, options?: {
+        immediately?: boolean;
+    }): void;
 }
 /** The class a {@link PlotModeTools.armBrush} stroke paints. */
 export interface PlotModeBrushClass {

package/lib/contracts/ports/spatial-data.port.d.ts

@@ -1,6 +1,6 @@
 import { InjectionToken } from '@angular/core';
 import { Observable } from 'rxjs';
-import { SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialEmbedding, SpatialPolygonTile, CategoricalColumnMeta, SpatialPolygons, SpatialTranscriptCounts, SpatialTranscriptSummary, SpatialTranscriptTile } from '../spatial-dataset.contract';
+import { SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialEmbedding, SpatialPolygonTile, CategoricalColumnMeta, SpatialMarkerGenes, SpatialPolygons, SpatialTranscriptCounts, SpatialTranscriptSummary, SpatialTranscriptTile } from '../spatial-dataset.contract';
 /** Options for {@link SpatialDataPort.getTranscriptTile}. */
 export interface TranscriptTileQuery {
     /**
@@ -97,6 +97,11 @@ export interface SpatialDataPort {
      * `weight` its transcript count and `observation` its dominant cell.
      */
     getTranscriptBins?(level: number, tx: number, ty: number): Promise<SpatialTranscriptTile>;
+    /**
+     * One tile of the per-gene levels for `genes`: each entry is one gene's transcripts in one bin
+     * (centroid, count, dominant cell); its `gene` is the position in `genes`. Optional.
+     */
+    getTranscriptGeneBins?(level: number, tx: number, ty: number, genes: string[]): Promise<SpatialTranscriptTile>;
     /**
      * What is inside `box` (observation units): transcript count, distinct genes and cells,
      * the most frequent of each — optionally restricted to `genes` — plus display ids for
@@ -124,6 +129,12 @@ export interface SpatialDataPort {
     }>;
     /** Transcript totals per gene, for estimating how many markers a selection draws. */
     getTranscriptCounts?(genes: string[]): Promise<SpatialTranscriptCounts>;
+    /**
+     * The top `perGroup` marker genes of every group of categorical `column`, for building
+     * gene groups from cell clusters ("Macrophages: CD163, MRC1, …"). Optional, and possibly
+     * slow the first time: the server makes one pass over the expression matrix.
+     */
+    getMarkerGenes?(column: string, perGroup?: number): Promise<SpatialMarkerGenes>;
     /**
      * The reference volume's voxels: a uint8 scalar field, x-fastest, of exactly
      * `width * height * depth` bytes as the dataset's {@link SpatialVolumeMeta}

package/lib/contracts/spatial-dataset.contract.d.ts

@@ -371,6 +371,34 @@ export interface SpatialTranscriptTile {
     gene: Uint16Array;
 }
 /** Transcript totals for an estimate of how many markers a selection would draw. */
+/** The per-gene levels: each level's bin and tile size, on the all-gene pyramid's grid. */
+export interface SpatialTranscriptGeneBinsMeta {
+    origin: [number, number];
+    levels: {
+        binSize: number;
+        tileSize: number;
+    }[];
+}
+/**
+ * Marker genes of each group of a categorical column: per group, the real genes most
+ * specific to it, best first. A gene's score is its mean `log1p(count)` in the group minus
+ * that in every other cell; it must be detected in at least 10% of the group's cells, and
+ * in more of them than elsewhere.
+ */
+export interface SpatialMarkerGenes {
+    column: string;
+    groups: {
+        name: string;
+        /** Cells in the group. */
+        cells: number;
+        genes: {
+            name: string;
+            score: number;
+            pctIn: number;
+            pctOut: number;
+        }[];
+    }[];
+}
 export interface SpatialTranscriptCounts {
     /** Total transcripts per requested gene, over the whole dataset. */
     counts: Record<string, number>;
@@ -408,6 +436,8 @@ export interface SpatialDataset {
     density?: SpatialDensityMeta;
     /** The all-gene transcript grouping pyramid, when it has been built. */
     transcriptBins?: SpatialTranscriptBinsMeta;
+    /** Per-gene levels of the transcript pyramid (same bins): a gene selection at any zoom. */
+    transcriptGeneBins?: SpatialTranscriptGeneBinsMeta;
     /** Present while the server is still building {@link transcriptBins}. */
     transcriptBinsStatus?: SpatialTranscriptBinsStatus;
     /**

package/lib/contracts/visualizer.contract.d.ts

@@ -8,7 +8,7 @@ import { ViewerCapabilities } from './capabilities.contract';
 import { IRegionOverlay } from './region-overlay.contract';
 import { IHistogram } from './channel-histogram-api.contract';
 import { ColormapNode, IWandOptions, IBrushOptions, SpatialViewState, SpatialColorBy } from './display-types';
-import { CategoricalColumnMeta, SpatialDataset, SpatialEmbedding, SpatialTranscriptCounts } from './spatial-dataset.contract';
+import { CategoricalColumnMeta, SpatialDataset, SpatialEmbedding, SpatialMarkerGenes, SpatialTranscriptCounts } from './spatial-dataset.contract';
 import { SpatialSelectionMask } from '../spatial/spatial-selection';
 import type { PlotModeViewport } from './plot-type-contribution.contract';
 /**
@@ -344,6 +344,12 @@ export interface ISpatialControls {
     }>;
     /** Transcript totals per gene — for the points estimate. Optional. */
     transcriptCounts?(genes: string[]): Promise<SpatialTranscriptCounts>;
+    /** Marker genes of each group of a categorical column. Optional (see the port). */
+    markerGenes?(column: string, perGroup?: number): Promise<SpatialMarkerGenes>;
+    /** Transcripts of each selected gene in the current view, or null when not known
+     *  (all genes at once, transcripts off, or a selection zoomed out on a dataset without the
+     *  pyramid's per-gene levels, where clusters are drawn from summed density grids). */
+    getGeneCountsInView$?(): Observable<Record<string, number> | null>;
     /** Estimated transcripts in view for the current selection, against the marker budget. */
     getTranscriptEstimate$?(): Observable<{
         points: number;

package/lib/implementations/napari-js/napari-loading-badge.d.ts

@@ -0,0 +1,20 @@
+/**
+ * "Transcripts reloading…" at the bottom of the canvas while a layer's data is in flight: one
+ * line naming every layer still loading, on a semi-opaque backing so it reads over any tissue.
+ *
+ * Shown only once something has been loading for {@link SHOW_AFTER_MS}, so a redraw served from
+ * cache does not flash it.
+ */
+export declare const SHOW_AFTER_MS = 150;
+export declare class NapariLoadingBadge {
+    private readonly host;
+    private readonly el;
+    private names;
+    private timer;
+    constructor(host: HTMLElement);
+    /** The layers loading now; empty hides the badge. */
+    set(names: readonly string[]): void;
+    /** The text currently set (shown or about to be). */
+    get text(): string;
+    destroy(): void;
+}

package/lib/implementations/napari-js/napari-spatial-tiles.d.ts

@@ -2,8 +2,9 @@ import type { Layer, Viewer } from 'napari-js';
 import type { Rgb } from '../../contracts/colormap-lut';
 import { type SpatialDataPort } from '../../contracts/ports/spatial-data.port';
 import type { SpatialViewState } from '../../contracts/display-types';
-import { SpatialDataset, SpatialImageRef, SpatialPolygonTile, SpatialTranscriptTile } from '../../contracts/spatial-dataset.contract';
+import { SpatialDataset, SpatialDensityRaster, SpatialImageRef, SpatialPolygonTile, SpatialTranscriptTile } from '../../contracts/spatial-dataset.contract';
 import { SpatialSelectionMask } from '../../spatial/spatial-selection';
+import { DataRect } from '../../spatial/spatial-tiles';
 /**
  * Level-of-detail cell outlines, transcripts and transcript density for the 2D spatial view.
  *
@@ -47,6 +48,10 @@ export interface SpatialTileHost {
     }): void;
     /** Estimated transcripts in view for the current selection, against the budget. */
     estimateChanged?(estimate: TranscriptEstimate | null): void;
+    /** Transcripts of each selected gene inside the view, or null when not known. */
+    geneCountsChanged?(counts: Record<string, number> | null): void;
+    /** The layers whose data is in flight now ("Transcripts", "Cells"…); empty when none. */
+    loadingChanged?(layers: string[]): void;
 }
 /** Xenium Explorer's "Estimated Transcript Points". */
 export interface TranscriptEstimate {
@@ -73,6 +78,20 @@ interface TranscriptJob {
 interface TranscriptLoad {
     merged: SpatialTranscriptTile;
     px: Float32Array;
+    /** For a gene selection: group it on this bin ladder once hidden genes are dropped. */
+    ladder?: {
+        baseBin: number;
+        levels: number;
+        start: number | null;
+    };
+    /** Already one marker per cluster per bin (zoomed out, from the density grids): no cells. */
+    clustered?: {
+        group: Int32Array;
+        names: string[];
+        genes: string[][];
+        bin: number;
+        origin: [number, number];
+    };
     kind?: TranscriptJob['kind'];
     bin?: TranscriptJob['bin'];
 }
@@ -101,6 +120,26 @@ export declare class NapariSpatialTileLayers {
     private selectionRevision;
     constructor(port: SpatialDataPort, host: SpatialTileHost);
     attach(viewer: Viewer): void;
+    /**
+     * Group a gene selection for the zoom: one marker per gene-tree cluster (a gene in no
+     * cluster is its own) per bin of the pyramid ladder, starting at the finest bin whose
+     * markers are 14 px apart and stepping up while the markers would exceed the budget.
+     * Null to draw every transcript: zoomed in, with the selection within the budget.
+     */
+    private groupSelection;
+    /** µm per observation unit of the drawn dataset, for describing a grouped marker's area. */
+    private micronsPerUnit;
+    /** Loads in flight, per layer label, for the loading badge. */
+    private readonly loading;
+    /** Report `label` loading while `work` is in flight. */
+    private track;
+    /** The loaded per-gene transcripts the in-view counts are taken from. */
+    private countSource;
+    /**
+     * 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: DataRect): Record<string, number> | null;
     /** Whether `layer` is one of the overlays drawn here (density, cells, transcripts). */
     owns(layer: Layer): boolean;
     detach(): void;
@@ -159,6 +198,28 @@ export declare class NapariSpatialTileLayers {
      * view would exceed the budget.
      */
     private geneJob;
+    /**
+     * A gene selection from the pyramid's per-gene levels: starting at the level whose bins are
+     * `startBin`, fetch the view's tiles for the selected genes and step to a coarser level while
+     * one marker per cluster per bin would exceed the max. Hidden genes are fetched too (their
+     * counts in view still show) and dropped before drawing; grouping by cluster happens there.
+     */
+    private geneBinsJob;
+    /** The selection's clusters: each gene-tree group's visible genes, then each ungrouped gene. */
+    private selectionClusters;
+    /**
+     * Per-gene density grids summed for `genes`, cached (a cluster is asked for once per bin).
+     * Keyed by dataset too: this manager outlives a dataset, and another may share gene names.
+     */
+    private densityFor;
+    private readonly densityCache;
+    /**
+     * A gene selection zoomed out: one marker per cluster per bin, from the per-gene density
+     * grids. The bin starts where markers are 14 px apart and doubles until the markers fit the
+     * max; each marker sits at the count-weighted centre of the finer grid inside it, so markers
+     * follow the tissue rather than a lattice.
+     */
+    private clusterDensityJob;
     /**
      * Every gene: the transcripts themselves once they fit the budget, else bins of the
      * all-gene pyramid sized by how many transcripts each holds.
@@ -211,6 +272,11 @@ interface DrawnTranscripts {
     radius: Float32Array;
     genes: string[];
     ref: SpatialImageRef | null;
+    /** For a grouped gene selection: each entry's group, and the groups' names. */
+    entryGroup?: Int32Array;
+    groupNames?: string[];
+    /** Each group's genes, when the markers came from the density grids (for the hover). */
+    groupGenes?: string[][];
     /** Lazily built spatial index: bucket → entry indices. */
     grid: {
         size: number;
@@ -237,4 +303,13 @@ export declare function filterTranscripts(t: SpatialTranscriptTile, px: Float32A
 export declare function mergePolygonTiles(tiles: SpatialPolygonTile[]): SpatialPolygonTile;
 /** Concatenate transcript tiles, stopping at `limit` entries. */
 export declare function mergeTranscriptTiles(tiles: SpatialTranscriptTile[], limit?: number): SpatialTranscriptTile;
+/**
+ * One marker per (cluster, `bin` square) from per-cluster density grids: the counts of the grid
+ * cells inside `area` summed per square, at their count-weighted centre. `slots[c]` is the gene
+ * slot whose icon cluster c's markers take.
+ */
+export declare function clusterMarkers(rasters: SpatialDensityRaster[], slots: number[], bin: number, area: DataRect): {
+    tile: SpatialTranscriptTile;
+    group: Int32Array;
+};
 export {};

package/lib/implementations/napari-js/napari-visualizer.service.d.ts

@@ -168,6 +168,8 @@ export declare class NapariVisualizerService extends BaseStoreVisualizer impleme
     private spatialTilesMgr;
     /** For the panel: the transcripts-in-view estimate and the density window in use. */
     readonly transcriptEstimate$: BehaviorSubject<TranscriptEstimate | null>;
+    /** Transcripts of each selected gene in view (see NapariSpatialTileLayers.geneCountsIn). */
+    readonly geneCountsInView$: BehaviorSubject<Record<string, number> | null>;
     readonly densityStats$: BehaviorSubject<{
         lo: number;
         hi: number;
@@ -183,6 +185,10 @@ export declare class NapariVisualizerService extends BaseStoreVisualizer impleme
      *  round-trip, so a fast sequence of colour-by changes can resolve out of
      *  order. Only the newest rebuild is allowed to touch the layer. */
     private spatialRebuildToken;
+    /** "x reloading…" at the bottom of the canvas: the tile layers' loads and the observations'. */
+    private loadingBadge;
+    private tileLoading;
+    private observationsLoading;
     /** Monotonic load generation. Bumped by {@link reset} and {@link cancelLoading}; the frame-loading
      *  loops (volume assembly, surface preload) capture it and bail when it changes, so a Cancel (or a
      *  new plot) actually stops fetching frames instead of running to completion in the background. */
@@ -352,6 +358,7 @@ export declare class NapariVisualizerService extends BaseStoreVisualizer impleme
      * The overview navigator for a 2D view with an image: a coarse thumbnail of the whole
      * image with the viewport on it; click or drag to pan at the current zoom (as OSD).
      */
+    private showLoading;
     private installNavigator;
     /**
      * Draw the navigator's thumbnail from the coarsest pyramid level. A multichannel image

package/lib/implementations/spatial-data-http/spatial-data-http.service.d.ts

@@ -1,7 +1,7 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { SpatialDataPort, TranscriptTileQuery } from '../../contracts/ports/spatial-data.port';
-import { SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialEmbedding, SpatialPolygonTile, SpatialPolygons, CategoricalColumnMeta, SpatialTranscriptCounts, SpatialTranscriptSummary, SpatialTranscriptTile } from '../../contracts/spatial-dataset.contract';
+import { SpatialColumn, SpatialDataset, SpatialDensityRaster, SpatialEmbedding, SpatialPolygonTile, SpatialPolygons, CategoricalColumnMeta, SpatialMarkerGenes, SpatialTranscriptCounts, SpatialTranscriptSummary, SpatialTranscriptTile } from '../../contracts/spatial-dataset.contract';
 import { SpatialDatasetSummary, SpatialManifest } from './spatial-wire';
 import * as i0 from "@angular/core";
 /**
@@ -97,6 +97,7 @@ export declare class SpatialDataHttpService implements SpatialDataPort {
     getPolygons(): Promise<SpatialPolygons>;
     getPolygonTile(set: string, level: number, gx: number, gy: number): Promise<SpatialPolygonTile>;
     getTranscriptTile(level: number, gx: number, gy: number, query: TranscriptTileQuery): Promise<SpatialTranscriptTile>;
+    getTranscriptGeneBins(level: number, tx: number, ty: number, genes: string[]): Promise<SpatialTranscriptTile>;
     getTranscriptBins(level: number, tx: number, ty: number): Promise<SpatialTranscriptTile>;
     /** Small JSON answers, keyed by URL — hovering back and forth must not refetch. */
     private readonly summaryCache;
@@ -110,6 +111,7 @@ export declare class SpatialDataHttpService implements SpatialDataPort {
         column: CategoricalColumnMeta;
         matched: number;
     }>;
+    getMarkerGenes(column: string, perGroup?: number): Promise<SpatialMarkerGenes>;
     getTranscriptCounts(genes: string[]): Promise<SpatialTranscriptCounts>;
     /** LRU over tile promises, so concurrent asks share one request and a failure is not kept. */
     private cachedTile;

package/lib/implementations/spatial-data-http/spatial-wire.d.ts

@@ -1,4 +1,4 @@
-import { SpatialColumn, SpatialColumnMeta, SpatialDataset, SpatialDensityMeta, SpatialDensityRaster, SpatialEmbedding, SpatialEmbeddingMeta, SpatialFeatureMeta, SpatialImageRef, SpatialObservations, SpatialPolygonTile, SpatialPolygonTilesMeta, SpatialPolygons, SpatialTranscriptBinsMeta, SpatialTranscriptBinsStatus, SpatialTranscriptTile, SpatialTranscriptTilesMeta, SpatialVolumeMeta } from '../../contracts/spatial-dataset.contract';
+import { SpatialColumn, SpatialColumnMeta, SpatialDataset, SpatialDensityMeta, SpatialDensityRaster, SpatialEmbedding, SpatialEmbeddingMeta, SpatialFeatureMeta, SpatialImageRef, SpatialObservations, SpatialPolygonTile, SpatialPolygonTilesMeta, SpatialPolygons, SpatialTranscriptBinsMeta, SpatialTranscriptGeneBinsMeta, SpatialTranscriptBinsStatus, SpatialTranscriptTile, SpatialTranscriptTilesMeta, SpatialVolumeMeta } from '../../contracts/spatial-dataset.contract';
 /**
  * The wire format the bundled example server speaks, and its decoders.
  *
@@ -79,6 +79,7 @@ export interface SpatialManifest {
     density?: SpatialDensityMeta;
     transcriptBins?: SpatialTranscriptBinsMeta;
     transcriptBinsStatus?: SpatialTranscriptBinsStatus;
+    transcriptGeneBins?: SpatialTranscriptGeneBinsMeta;
 }
 /** `GET /spatial/datasets` */
 export interface SpatialDatasetSummary {

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

@@ -13,7 +13,7 @@
  * `zoom · scale`. For a Xenium bundle the data unit is the micron and the world unit the
  * morphology pixel.
  */
-import type { SpatialBounds, SpatialImageRef, SpatialTileLevel } from '../contracts/spatial-dataset.contract';
+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. */
@@ -83,6 +83,43 @@ export declare function polygonLevelFor(pxPerUnit: number, cellDiameter: number,
  * 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;

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

@@ -390,6 +390,21 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     /** 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. */
@@ -407,6 +422,39 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     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.
@@ -451,6 +499,12 @@ export declare class SpatialControlsComponent implements OnInit, OnDestroy {
     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;
     /**

package/package.json

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