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

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

@@ -0,0 +1,274 @@
+import { colormapFromLut } from 'napari-js';
+import { NO_CATEGORY, isCategoricalColumn, } from '../../../contracts/spatial-dataset.contract';
+import { DEFAULT_CATEGORICAL_PALETTE, MISSING_COLOR, contrastWindow, parseHex, resolveCategoryColors, } from '../../../spatial/spatial-encoding';
+import { POLYGON_LEVEL_MIN_CELL_PX, cellTypeColumnFor, cellsShown, polygonLevelFor, tileId, tilesInRect, typicalCellDiameter, } from '../../../spatial/lod';
+import { filterRings, mergePolygonTiles } from '../../../spatial/spatial-tile-merge';
+import { ContrastWindowCache } from '../napari-spatial-encoding';
+const MAX_CELL_TILES = 48;
+/**
+ * The cell outlines of the 2D spatial view, at the polygon level the zoom calls for: a fill,
+ * an outline or both (plus nucleus outlines for the "both" cell set), coloured by the view's
+ * cell-colour mode, with switched-off groups left out of the geometry.
+ *
+ * Geometry and style are keyed apart, so a recolour (a new cell-type column, a selection)
+ * rewrites the per-shape values of the existing layers and never re-expands the rings.
+ */
+export class CellLayers {
+    constructor(port, groups, lookup, host) {
+        this.port = port;
+        this.groups = groups;
+        this.lookup = lookup;
+        this.host = host;
+        this.polygonsShown = false;
+        /** Rings currently drawn and the (dataset, set, tiles) they came from. */
+        this.currentRings = null;
+        this.cellGeometryKey = null;
+        this.currentNuclei = null;
+        this.cellStyleKey = null;
+        /** Selection identity → revision, so a change key can name a selection cheaply. */
+        this.lastSelection = null;
+        this.selectionRevision = 0;
+        /** Continuous colourings' windows, per (vector, clip, log): `contrastWindow` sorts every
+         *  value, and a selection or opacity change recolours with the vector unchanged (SPATIAL-12). */
+        this.contrastWindows = new ContrastWindowCache();
+    }
+    /** True while outlines are on screen — the service hides its dots then. */
+    get outlinesShown() {
+        return this.polygonsShown;
+    }
+    /** The viewer went away (its layers with it): the outlines are no longer shown. */
+    detached() {
+        this.setPolygonsShown(false);
+    }
+    /** Draw the cells covering `rect` at the level `pxPerUnit` calls for, or drop them. */
+    async plan(dataset, view, selection, rect, pxPerUnit, ctx) {
+        const tiled = dataset.polygonTiles;
+        const whole = !tiled && dataset.polygons && this.port.getPolygons;
+        if (!cellsShown(dataset, view) || (!tiled && !whole)) {
+            this.drop();
+            return;
+        }
+        const diameter = typicalCellDiameter(dataset.observations.radius);
+        // Whole-dataset rings have one level and no coarser fallback, so they are drawn as
+        // soon as a cell is big enough to read as a shape rather than a dot.
+        const level = tiled
+            ? polygonLevelFor(pxPerUnit, diameter, tiled.levels.length)
+            : pxPerUnit * diameter >= POLYGON_LEVEL_MIN_CELL_PX[2]
+                ? 0
+                : -1;
+        if (level < 0) {
+            this.drop();
+            return;
+        }
+        // Groups switched off in the list: their cells are left out of the geometry.
+        const hidden = await this.lookup.hiddenCodes(dataset, view);
+        if (ctx.stale())
+            return;
+        const label = view.cellSet === 'both' ? 'Cells and nuclei' : view.cellSet === 'nucleus' ? 'Nuclei' : 'Cells';
+        const geometry = await ctx.track(label, this.cellGeometry(dataset, view, rect, level, hidden, ctx));
+        if (!geometry)
+            return;
+        const { rings, nuclei, geometryKey } = geometry;
+        const geometryChanged = geometryKey !== this.cellGeometryKey;
+        const styleKey = [
+            geometryKey,
+            view.cellColorMode,
+            view.cellColorGene,
+            view.cellSingleColor,
+            cellTypeColumnFor(dataset, view),
+            this.selectionRev(selection),
+            view.logScale,
+            view.percentileClip.join(),
+            JSON.stringify(view.continuousColormap),
+            view.cellDraw,
+            view.cellOpacity,
+        ].join('|');
+        const present = ['cellFill', 'cellOutline', 'nucleusOutline'].some((g) => this.groups.shown(g));
+        if (!geometryChanged && styleKey === this.cellStyleKey && present) {
+            this.setPolygonsShown(true);
+            return;
+        }
+        const colors = await this.cellColors(dataset, view, selection, rings.observation);
+        if (ctx.stale())
+            return;
+        this.currentRings = rings;
+        this.currentNuclei = nuclei;
+        // A geometry missing a failed tile is drawn but not remembered, so the retry refetches it.
+        this.cellGeometryKey = ctx.incomplete ? null : geometryKey;
+        this.cellStyleKey = styleKey;
+        this.drawCells(dataset, view, geometry, colors, geometryChanged);
+        this.setPolygonsShown(true);
+    }
+    /**
+     * The cell layers: the fill and the outline the view's draw mode asks for, and with "both" the
+     * nucleus outlines over them. A geometry change builds new layers; a style change restyles them.
+     */
+    drawCells(dataset, view, { rings, nuclei }, colors, geometryChanged) {
+        const ref = dataset.imageRef;
+        const common = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] };
+        const fill = view.cellDraw !== 'outline';
+        const outline = view.cellDraw !== 'fill';
+        this.groups.upsertShapes('cellFill', fill, geometryChanged, rings, {
+            name: 'cells',
+            draw: 'fill',
+            opacity: view.cellOpacity,
+            ...colors,
+            ...common,
+        });
+        this.groups.upsertShapes('cellOutline', outline, geometryChanged, rings, fill
+            ? // Over a fill, a dark outline separates neighbours of the same type.
+                { name: 'cell outlines', draw: 'outline', color: [0.08, 0.08, 0.1, 1], opacity: 0.7, ...common }
+            : { name: 'cell outlines', draw: 'outline', opacity: 1, ...colors, ...common });
+        // "Both": nuclei outlined over the cells, light so they read against any fill.
+        if (nuclei) {
+            this.groups.upsertShapes('nucleusOutline', true, geometryChanged, nuclei, {
+                name: 'nucleus outlines',
+                draw: 'outline',
+                color: [0.95, 0.95, 0.98, 1],
+                opacity: 0.8,
+                ...common,
+            });
+        }
+        else {
+            this.groups.drop('nucleusOutline');
+        }
+    }
+    selectionRev(selection) {
+        if (selection !== this.lastSelection) {
+            this.lastSelection = selection;
+            this.selectionRevision++;
+        }
+        return this.selectionRevision;
+    }
+    /**
+     * The rings' colours by their owners, by the view's cell-colour mode (Xenium Explorer's "Cell
+     * Color"): one RGBA per shape for a grouping, values + colormap for a measurement, one colour
+     * for "single". A selection mutes what it leaves out.
+     */
+    async cellColors(dataset, view, selection, owners) {
+        const muted = selection.count > 0 ? selection.mask : null;
+        const mode = view.cellColorMode;
+        if (mode === 'single') {
+            const [r, g, b] = parseHex(view.cellSingleColor);
+            return { color: [r / 255, g / 255, b / 255, 1] };
+        }
+        const continuous = async (raw, log) => {
+            const values = new Float32Array(owners.length);
+            for (let i = 0; i < owners.length; i++) {
+                const v = raw[owners[i]] ?? NaN;
+                values[i] = log ? Math.log1p(Math.max(0, v)) : v;
+            }
+            const [clipLo, clipHi] = view.percentileClip;
+            // Keyed by the SOURCE vector (the log copy would be new on every call), as the 3D cloud's.
+            const [lo, hi] = this.contrastWindows.get(raw, clipLo, clipHi, log, () => contrastWindow(log ? raw.map((v) => Math.log1p(Math.max(0, v))) : raw, clipLo, clipHi));
+            return {
+                values,
+                colormap: colormapFromLut('spatial-continuous', this.host.continuousLut(view)),
+                contrastLimits: [lo, hi],
+            };
+        };
+        if (mode === 'gene' && view.cellColorGene) {
+            return continuous(await this.port.getFeatureVector(view.cellColorGene), true);
+        }
+        if (mode === 'transcriptDensity' && dataset.columns.some((c) => c.name === 'transcript_density')) {
+            const column = await this.port.getColumn('transcript_density');
+            if (!isCategoricalColumn(column))
+                return continuous(column.values, false);
+        }
+        const name = mode === 'segmentation' && dataset.columns.some((c) => c.name === 'segmentation_method')
+            ? 'segmentation_method'
+            : cellTypeColumnFor(dataset, view);
+        const codes = name ? await this.lookup.codes(name) : null;
+        const palette = categoryRgba(codes?.meta ?? null);
+        const missing = rgba01(MISSING_COLOR);
+        // One RGBA per shape (napari Shapes' `face_color`): any number of categories keeps its own
+        // colour, where a colormap band per category ran out of LUT entries past ~127.
+        const faceColor = new Float32Array(owners.length * 4);
+        for (let i = 0; i < owners.length; i++) {
+            const o = owners[i];
+            const code = !codes || (muted && !muted[o]) ? NO_CATEGORY : codes.codes[o];
+            faceColor.set(palette[code] ?? missing, i * 4);
+        }
+        return { faceColor };
+    }
+    /**
+     * The cell rings (and, for "both", the nucleus rings) covering `rect` at `level`, minus
+     * the hidden groups — reused when nothing that decides them changed. Null when the
+     * view went stale or the dataset has no set to draw.
+     */
+    async cellGeometry(dataset, view, rect, level, hidden, ctx) {
+        const tiled = dataset.polygonTiles;
+        const hiddenKey = view.hiddenGroups.join('\u0001');
+        let rings;
+        let nuclei = null;
+        let geometryKey;
+        if (tiled) {
+            const both = view.cellSet === 'both';
+            const set = !both && view.cellSet && tiled.sets.some((s) => s.name === view.cellSet)
+                ? view.cellSet
+                : (tiled.defaultSet ?? tiled.sets[0]?.name);
+            if (!set)
+                return null;
+            const nucleusSet = both ? tiled.sets.find((s) => s.name !== set)?.name : undefined;
+            const keys = tilesInRect(rect, level, tiled.levels, tiled.bounds, MAX_CELL_TILES);
+            geometryKey = `${dataset.id}|${set}|${nucleusSet ?? ''}|${hiddenKey}|${keys.map(tileId).join(',')}`;
+            if (geometryKey === this.cellGeometryKey && this.currentRings) {
+                rings = this.currentRings;
+                nuclei = this.currentNuclei;
+            }
+            else {
+                const [tiles, nucleusTiles] = await Promise.all([
+                    ctx.fetchAll(keys, (k) => this.port.getPolygonTile(set, k.level, k.gx, k.gy)),
+                    nucleusSet
+                        ? ctx.fetchAll(keys, (k) => this.port.getPolygonTile(nucleusSet, k.level, k.gx, k.gy))
+                        : Promise.resolve(null),
+                ]);
+                if (ctx.stale())
+                    return null;
+                rings = filterRings(mergePolygonTiles(tiles), hidden);
+                nuclei = nucleusTiles ? filterRings(mergePolygonTiles(nucleusTiles), hidden) : null;
+            }
+        }
+        else {
+            geometryKey = `${dataset.id}|whole|${hiddenKey}`;
+            if (geometryKey === this.cellGeometryKey && this.currentRings) {
+                rings = this.currentRings;
+            }
+            else {
+                const polys = await this.port.getPolygons();
+                if (ctx.stale())
+                    return null;
+                // Whole-dataset rings are index-aligned with the observations.
+                rings = filterRings({ ...polys, observation: Uint32Array.from({ length: polys.count }, (_v, i) => i) }, hidden);
+            }
+        }
+        return { rings, nuclei, geometryKey };
+    }
+    /** Remove the cell layers and forget what they showed. */
+    drop() {
+        this.groups.drop('cellFill');
+        this.groups.drop('cellOutline');
+        this.groups.drop('nucleusOutline');
+        this.currentNuclei = null;
+        this.cellGeometryKey = null;
+        this.cellStyleKey = null;
+        this.currentRings = null;
+        this.setPolygonsShown(false);
+    }
+    setPolygonsShown(shown) {
+        if (shown === this.polygonsShown)
+            return;
+        this.polygonsShown = shown;
+        this.host.polygonsShownChanged(shown);
+    }
+}
+/** An 8-bit RGB as an opaque 0..1 RGBA. */
+function rgba01([r, g, b]) {
+    return [r / 255, g / 255, b / 255, 1];
+}
+/** A grouping's category colours, as 0..1 RGBA by category code (one default without a grouping). */
+function categoryRgba(meta) {
+    const hex = meta && meta.kind === 'categorical' ? resolveCategoryColors(meta) : [DEFAULT_CATEGORICAL_PALETTE[0]];
+    return hex.map((h) => rgba01(parseHex(h)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cell-layers.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/cell-layers.ts"],"names":[],"mappings":"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","sourcesContent":["import { colormapFromLut } from 'napari-js';\nimport type { Colormap, RGBA } from 'napari-js';\n\nimport type { Rgb } from '../../../contracts/colormap-lut';\nimport type { SpatialDataPort } from '../../../contracts/ports/spatial-data.port';\nimport type { SpatialViewState } from '../../../contracts/display-types';\nimport {\n  NO_CATEGORY,\n  SpatialColumn,\n  SpatialDataset,\n  SpatialPolygonTile,\n  SpatialPolygons,\n  isCategoricalColumn,\n} from '../../../contracts/spatial-dataset.contract';\nimport {\n  DEFAULT_CATEGORICAL_PALETTE,\n  MISSING_COLOR,\n  contrastWindow,\n  parseHex,\n  resolveCategoryColors,\n} from '../../../spatial/spatial-encoding';\nimport { SpatialSelectionMask } from '../../../spatial/spatial-selection';\nimport {\n  DataRect,\n  POLYGON_LEVEL_MIN_CELL_PX,\n  cellTypeColumnFor,\n  cellsShown,\n  polygonLevelFor,\n  tileId,\n  tilesInRect,\n  typicalCellDiameter,\n} from '../../../spatial/lod';\nimport { filterRings, mergePolygonTiles } from '../../../spatial/spatial-tile-merge';\nimport { ContrastWindowCache } from '../napari-spatial-encoding';\nimport type { CategoricalLookup, HiddenCodes } from './categorical-lookup';\nimport type { OrderedLayerGroups, TileGroup } from './layer-groups';\nimport type { PlanContext } from './plan-context';\n\nconst MAX_CELL_TILES = 48;\n\n/** The cells' colours as a shapes layer takes them: per-shape RGBA, values over a colormap, or\n *  one colour. */\ninterface CellColors {\n  values?: Float32Array;\n  colormap?: Colormap;\n  contrastLimits?: [number, number];\n  color?: RGBA;\n  faceColor?: Float32Array;\n}\n\n/** What the cell layers need from the service. */\nexport interface CellLayersHost {\n  /** The continuous LUT the view is using (so cells coloured by a gene match the markers). */\n  continuousLut(view: SpatialViewState): Rgb[];\n  /** Outlines appeared or disappeared: the markers' visibility follows. */\n  polygonsShownChanged(shown: boolean): void;\n}\n\n/**\n * The cell outlines of the 2D spatial view, at the polygon level the zoom calls for: a fill,\n * an outline or both (plus nucleus outlines for the \"both\" cell set), coloured by the view's\n * cell-colour mode, with switched-off groups left out of the geometry.\n *\n * Geometry and style are keyed apart, so a recolour (a new cell-type column, a selection)\n * rewrites the per-shape values of the existing layers and never re-expands the rings.\n */\nexport class CellLayers {\n  private polygonsShown = false;\n  /** Rings currently drawn and the (dataset, set, tiles) they came from. */\n  private currentRings: SpatialPolygonTile | null = null;\n  private cellGeometryKey: string | null = null;\n  private currentNuclei: SpatialPolygonTile | null = null;\n  private cellStyleKey: string | null = null;\n  /** Selection identity → revision, so a change key can name a selection cheaply. */\n  private lastSelection: SpatialSelectionMask | null = null;\n  private selectionRevision = 0;\n  /** Continuous colourings' windows, per (vector, clip, log): `contrastWindow` sorts every\n   *  value, and a selection or opacity change recolours with the vector unchanged (SPATIAL-12). */\n  private readonly contrastWindows = new ContrastWindowCache();\n\n  constructor(\n    private readonly port: SpatialDataPort,\n    private readonly groups: OrderedLayerGroups<TileGroup>,\n    private readonly lookup: CategoricalLookup,\n    private readonly host: CellLayersHost,\n  ) {}\n\n  /** True while outlines are on screen — the service hides its dots then. */\n  get outlinesShown(): boolean {\n    return this.polygonsShown;\n  }\n\n  /** The viewer went away (its layers with it): the outlines are no longer shown. */\n  detached(): void {\n    this.setPolygonsShown(false);\n  }\n\n  /** Draw the cells covering `rect` at the level `pxPerUnit` calls for, or drop them. */\n  async plan(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n    rect: DataRect,\n    pxPerUnit: number,\n    ctx: PlanContext,\n  ): Promise<void> {\n    const tiled = dataset.polygonTiles;\n    const whole = !tiled && dataset.polygons && this.port.getPolygons;\n    if (!cellsShown(dataset, view) || (!tiled && !whole)) {\n      this.drop();\n      return;\n    }\n    const diameter = typicalCellDiameter(dataset.observations.radius);\n    // Whole-dataset rings have one level and no coarser fallback, so they are drawn as\n    // soon as a cell is big enough to read as a shape rather than a dot.\n    const level = tiled\n      ? polygonLevelFor(pxPerUnit, diameter, tiled.levels.length)\n      : pxPerUnit * diameter >= POLYGON_LEVEL_MIN_CELL_PX[2]\n        ? 0\n        : -1;\n    if (level < 0) {\n      this.drop();\n      return;\n    }\n\n    // Groups switched off in the list: their cells are left out of the geometry.\n    const hidden = await this.lookup.hiddenCodes(dataset, view);\n    if (ctx.stale()) return;\n    const label = view.cellSet === 'both' ? 'Cells and nuclei' : view.cellSet === 'nucleus' ? 'Nuclei' : 'Cells';\n    const geometry = await ctx.track(label, this.cellGeometry(dataset, view, rect, level, hidden, ctx));\n    if (!geometry) return;\n    const { rings, nuclei, geometryKey } = geometry;\n\n    const geometryChanged = geometryKey !== this.cellGeometryKey;\n    const styleKey = [\n      geometryKey,\n      view.cellColorMode,\n      view.cellColorGene,\n      view.cellSingleColor,\n      cellTypeColumnFor(dataset, view),\n      this.selectionRev(selection),\n      view.logScale,\n      view.percentileClip.join(),\n      JSON.stringify(view.continuousColormap),\n      view.cellDraw,\n      view.cellOpacity,\n    ].join('|');\n    const present = (['cellFill', 'cellOutline', 'nucleusOutline'] as const).some((g) => this.groups.shown(g));\n    if (!geometryChanged && styleKey === this.cellStyleKey && present) {\n      this.setPolygonsShown(true);\n      return;\n    }\n    const colors = await this.cellColors(dataset, view, selection, rings.observation);\n    if (ctx.stale()) return;\n\n    this.currentRings = rings;\n    this.currentNuclei = nuclei;\n    // A geometry missing a failed tile is drawn but not remembered, so the retry refetches it.\n    this.cellGeometryKey = ctx.incomplete ? null : geometryKey;\n    this.cellStyleKey = styleKey;\n    this.drawCells(dataset, view, geometry, colors, geometryChanged);\n    this.setPolygonsShown(true);\n  }\n\n  /**\n   * The cell layers: the fill and the outline the view's draw mode asks for, and with \"both\" the\n   * nucleus outlines over them. A geometry change builds new layers; a style change restyles them.\n   */\n  private drawCells(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    { rings, nuclei }: { rings: SpatialPolygonTile; nuclei: SpatialPolygonTile | null },\n    colors: CellColors,\n    geometryChanged: boolean,\n  ): void {\n    const ref = dataset.imageRef;\n    const common = { scale: ref?.scale ?? [1, 1], translate: ref?.translate ?? [0, 0] } as const;\n    const fill = view.cellDraw !== 'outline';\n    const outline = view.cellDraw !== 'fill';\n\n    this.groups.upsertShapes('cellFill', fill, geometryChanged, rings, {\n      name: 'cells',\n      draw: 'fill',\n      opacity: view.cellOpacity,\n      ...colors,\n      ...common,\n    });\n    this.groups.upsertShapes(\n      'cellOutline',\n      outline,\n      geometryChanged,\n      rings,\n      fill\n        ? // Over a fill, a dark outline separates neighbours of the same type.\n          { name: 'cell outlines', draw: 'outline', color: [0.08, 0.08, 0.1, 1], opacity: 0.7, ...common }\n        : { name: 'cell outlines', draw: 'outline', opacity: 1, ...colors, ...common },\n    );\n    // \"Both\": nuclei outlined over the cells, light so they read against any fill.\n    if (nuclei) {\n      this.groups.upsertShapes('nucleusOutline', true, geometryChanged, nuclei, {\n        name: 'nucleus outlines',\n        draw: 'outline',\n        color: [0.95, 0.95, 0.98, 1],\n        opacity: 0.8,\n        ...common,\n      });\n    } else {\n      this.groups.drop('nucleusOutline');\n    }\n  }\n\n  private selectionRev(selection: SpatialSelectionMask): number {\n    if (selection !== this.lastSelection) {\n      this.lastSelection = selection;\n      this.selectionRevision++;\n    }\n    return this.selectionRevision;\n  }\n\n  /**\n   * The rings' colours by their owners, by the view's cell-colour mode (Xenium Explorer's \"Cell\n   * Color\"): one RGBA per shape for a grouping, values + colormap for a measurement, one colour\n   * for \"single\". A selection mutes what it leaves out.\n   */\n  private async cellColors(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    selection: SpatialSelectionMask,\n    owners: Uint32Array,\n  ): Promise<CellColors> {\n    const muted = selection.count > 0 ? selection.mask : null;\n    const mode = view.cellColorMode;\n\n    if (mode === 'single') {\n      const [r, g, b] = parseHex(view.cellSingleColor);\n      return { color: [r / 255, g / 255, b / 255, 1] };\n    }\n\n    const continuous = async (raw: Float32Array, log: boolean) => {\n      const values = new Float32Array(owners.length);\n      for (let i = 0; i < owners.length; i++) {\n        const v = raw[owners[i]] ?? NaN;\n        values[i] = log ? Math.log1p(Math.max(0, v)) : v;\n      }\n      const [clipLo, clipHi] = view.percentileClip;\n      // Keyed by the SOURCE vector (the log copy would be new on every call), as the 3D cloud's.\n      const [lo, hi] = this.contrastWindows.get(raw, clipLo, clipHi, log, () =>\n        contrastWindow(log ? raw.map((v) => Math.log1p(Math.max(0, v))) : raw, clipLo, clipHi),\n      );\n      return {\n        values,\n        colormap: colormapFromLut('spatial-continuous', this.host.continuousLut(view)),\n        contrastLimits: [lo, hi] as [number, number],\n      };\n    };\n    if (mode === 'gene' && view.cellColorGene) {\n      return continuous(await this.port.getFeatureVector(view.cellColorGene), true);\n    }\n    if (mode === 'transcriptDensity' && dataset.columns.some((c) => c.name === 'transcript_density')) {\n      const column = await this.port.getColumn('transcript_density');\n      if (!isCategoricalColumn(column)) return continuous(column.values, false);\n    }\n\n    const name =\n      mode === 'segmentation' && dataset.columns.some((c) => c.name === 'segmentation_method')\n        ? 'segmentation_method'\n        : cellTypeColumnFor(dataset, view);\n    const codes = name ? await this.lookup.codes(name) : null;\n    const palette = categoryRgba(codes?.meta ?? null);\n    const missing = rgba01(MISSING_COLOR);\n    // One RGBA per shape (napari Shapes' `face_color`): any number of categories keeps its own\n    // colour, where a colormap band per category ran out of LUT entries past ~127.\n    const faceColor = new Float32Array(owners.length * 4);\n    for (let i = 0; i < owners.length; i++) {\n      const o = owners[i];\n      const code = !codes || (muted && !muted[o]) ? NO_CATEGORY : codes.codes[o];\n      faceColor.set(palette[code] ?? missing, i * 4);\n    }\n    return { faceColor };\n  }\n\n  /**\n   * The cell rings (and, for \"both\", the nucleus rings) covering `rect` at `level`, minus\n   * the hidden groups — reused when nothing that decides them changed. Null when the\n   * view went stale or the dataset has no set to draw.\n   */\n  private async cellGeometry(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    rect: DataRect,\n    level: number,\n    hidden: HiddenCodes | null,\n    ctx: PlanContext,\n  ): Promise<{ rings: SpatialPolygonTile; nuclei: SpatialPolygonTile | null; geometryKey: string } | null> {\n    const tiled = dataset.polygonTiles;\n    const hiddenKey = view.hiddenGroups.join('\\u0001');\n    let rings: SpatialPolygonTile;\n    let nuclei: SpatialPolygonTile | null = null;\n    let geometryKey: string;\n    if (tiled) {\n      const both = view.cellSet === 'both';\n      const set =\n        !both && view.cellSet && tiled.sets.some((s) => s.name === view.cellSet)\n          ? view.cellSet\n          : (tiled.defaultSet ?? tiled.sets[0]?.name);\n      if (!set) return null;\n      const nucleusSet = both ? tiled.sets.find((s) => s.name !== set)?.name : undefined;\n      const keys = tilesInRect(rect, level, tiled.levels, tiled.bounds, MAX_CELL_TILES);\n      geometryKey = `${dataset.id}|${set}|${nucleusSet ?? ''}|${hiddenKey}|${keys.map(tileId).join(',')}`;\n      if (geometryKey === this.cellGeometryKey && this.currentRings) {\n        rings = this.currentRings;\n        nuclei = this.currentNuclei;\n      } else {\n        const [tiles, nucleusTiles] = await Promise.all([\n          ctx.fetchAll(keys, (k) => this.port.getPolygonTile!(set, k.level, k.gx, k.gy)),\n          nucleusSet\n            ? ctx.fetchAll(keys, (k) => this.port.getPolygonTile!(nucleusSet, k.level, k.gx, k.gy))\n            : Promise.resolve(null),\n        ]);\n        if (ctx.stale()) return null;\n        rings = filterRings(mergePolygonTiles(tiles), hidden);\n        nuclei = nucleusTiles ? filterRings(mergePolygonTiles(nucleusTiles), hidden) : null;\n      }\n    } else {\n      geometryKey = `${dataset.id}|whole|${hiddenKey}`;\n      if (geometryKey === this.cellGeometryKey && this.currentRings) {\n        rings = this.currentRings;\n      } else {\n        const polys: SpatialPolygons = await this.port.getPolygons!();\n        if (ctx.stale()) return null;\n        // Whole-dataset rings are index-aligned with the observations.\n        rings = filterRings(\n          { ...polys, observation: Uint32Array.from({ length: polys.count }, (_v, i) => i) },\n          hidden,\n        );\n      }\n    }\n    return { rings, nuclei, geometryKey };\n  }\n\n  /** Remove the cell layers and forget what they showed. */\n  drop(): void {\n    this.groups.drop('cellFill');\n    this.groups.drop('cellOutline');\n    this.groups.drop('nucleusOutline');\n    this.currentNuclei = null;\n    this.cellGeometryKey = null;\n    this.cellStyleKey = null;\n    this.currentRings = null;\n    this.setPolygonsShown(false);\n  }\n\n  private setPolygonsShown(shown: boolean): void {\n    if (shown === this.polygonsShown) return;\n    this.polygonsShown = shown;\n    this.host.polygonsShownChanged(shown);\n  }\n}\n\n/** An 8-bit RGB as an opaque 0..1 RGBA. */\nfunction rgba01([r, g, b]: readonly [number, number, number]): RGBA {\n  return [r / 255, g / 255, b / 255, 1];\n}\n\n/** A grouping's category colours, as 0..1 RGBA by category code (one default without a grouping). */\nfunction categoryRgba(meta: SpatialColumn['meta'] | null): RGBA[] {\n  const hex = meta && meta.kind === 'categorical' ? resolveCategoryColors(meta) : [DEFAULT_CATEGORICAL_PALETTE[0]];\n  return hex.map((h) => rgba01(parseHex(h)));\n}\n"]}

package/esm2022/lib/implementations/napari-js/spatial-tiles/density-layer.mjs

@@ -0,0 +1,144 @@
+import { colormapFromLut } from 'napari-js';
+import { INFERNO_LUT } from 'napari-js/colormaps';
+import { ALL_GENES } from '../../../contracts/ports/spatial-data.port';
+import { lutFor } from '../../../spatial/spatial-encoding';
+import { visibleArea, visibleDataRect } from '../../../spatial/lod';
+import { densityAutoRange } from '../../../spatial/density-raster';
+/**
+ * The transcript density image of the 2D spatial view: the visible genes' summed density
+ * raster, one scalar layer in the `density` group, windowed and coloured on the GPU.
+ *
+ * Bins at or below the window's low end are transparent (`transparentBelow`), so a window,
+ * colormap or opacity change is a uniform or LUT update of the same layer: only new genes or a
+ * new bin size fetch and upload a raster.
+ */
+export class DensityLayer {
+    constructor(port, groups, changed) {
+        this.port = port;
+        this.groups = groups;
+        this.changed = changed;
+        /** The density window in use and the densest bin, for the panel's threshold control. */
+        this.stats = null;
+        /** The drawn raster in transcripts per unit area, its densest bin and its auto window. */
+        this.raster = null;
+        /** The colormap the layer was given, so an unchanged one does not rebuild its LUT. */
+        this.colormapKey = null;
+    }
+    /** Draw the view's density, or drop it; an unchanged (genes, bin, window, colormap) is a no-op. */
+    async plan(dataset, view, ctx) {
+        const hiddenGenes = new Set(view.transcriptHiddenGenes);
+        const genes = view.transcriptAllGenes ? [ALL_GENES] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));
+        if (!dataset.density || !this.port.getDensity || view.transcriptMode !== 'density' || !genes.length) {
+            this.groups.drop('density');
+            this.stats = null;
+            this.raster = null;
+            return;
+        }
+        // The raster's key: what it is a raster OF. Window, colormap and opacity are the layer's style.
+        const key = [dataset.id, genes.join(','), view.densityBin].join('|');
+        // `shown`, not `has`: a stitched slice re-render clears the layer list, and the key alone
+        // would call the cleared layer drawn.
+        if (key !== this.groups.key('density') || !this.groups.shown('density') || !this.raster) {
+            const raster = await ctx.track('Transcript density', this.port.getDensity(genes, view.densityBin));
+            if (ctx.stale())
+                return;
+            // Bins drawn as squares, as Xenium Explorer does; the window is in transcripts/µm².
+            const meta = raster.meta;
+            const area = meta.gridSize[0] * meta.gridSize[1];
+            const perArea = raster.values.map((v) => v / area);
+            this.raster = {
+                perArea,
+                max: perArea.reduce((m, v) => (v > m ? v : m), 0),
+                auto: densityAutoRange(perArea),
+            };
+            const ref = dataset.imageRef;
+            const sx = ref?.scale?.[0] ?? 1;
+            const sy = ref?.scale?.[1] ?? 1;
+            const layer = this.groups.viewer.addImage({ kind: 'typed', width: meta.cols, height: meta.rows, channels: 1, dtype: 'float32', data: perArea }, {
+                name: `density · ${view.transcriptAllGenes ? 'all genes' : genes.join(', ')}`,
+                scale: [meta.gridSize[0] * sx, meta.gridSize[1] * sy],
+                translate: [
+                    meta.origin[0] * sx + (ref?.translate?.[0] ?? 0),
+                    meta.origin[1] * sy + (ref?.translate?.[1] ?? 0),
+                ],
+                // Xenium Explorer's "scale threshold": empty tissue shows the image under it.
+                transparentBelow: true,
+                blending: 'translucent',
+                interpolation: 'nearest',
+            });
+            this.colormapKey = null;
+            this.groups.setKey('density', key);
+            this.groups.replace('density', layer);
+        }
+        this.restyle(this.groups.layer('density'), view);
+    }
+    /** Window, colour and opacity onto the drawn layer: uniforms and a LUT, no re-upload. */
+    restyle(layer, view) {
+        const raster = this.raster;
+        const [lo, hi] = view.densityRange ?? raster.auto;
+        layer.contrastLimits = [lo, hi];
+        layer.opacity = view.densityOpacity;
+        const colormapKey = JSON.stringify(view.densityColormap ?? null);
+        if (colormapKey !== this.colormapKey) {
+            this.colormapKey = colormapKey;
+            layer.colormap = colormapFromLut('transcript-density', lutFor(view.densityColormap ?? INFERNO_LUT));
+        }
+        this.groups.viewer.requestRender();
+        const stats = { lo, hi, max: raster.max };
+        if (this.stats?.lo === lo && this.stats.hi === hi && this.stats.max === raster.max)
+            return;
+        this.stats = stats;
+        this.changed(stats);
+    }
+}
+/**
+ * Transcripts in view for the visible genes, against the marker budget — it tells the user
+ * whether the budget will force grouping. Caches the per-gene dataset totals for the latest
+ * gene set.
+ */
+export class TranscriptEstimator {
+    constructor(port, changed) {
+        this.port = port;
+        this.changed = changed;
+        /** Per-gene dataset totals for the in-view estimate, for the latest gene set. */
+        this.countsCache = null;
+    }
+    /**
+     * Transcripts in view for the visible genes: each gene's dataset total times the share
+     * of the tissue on screen. An estimate — expression is not uniform — which is also what
+     * Xenium Explorer shows; it tells the user whether the budget will force grouping.
+     */
+    async plan(dataset, view, viewer, w, h, ctx) {
+        const tiles = dataset.transcriptTiles;
+        if (!tiles || !this.port.getTranscriptCounts || view.transcriptMode === 'off') {
+            this.changed(null);
+            return;
+        }
+        const hiddenGenes = new Set(view.transcriptHiddenGenes);
+        const genes = view.transcriptAllGenes ? [] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));
+        const key = `${dataset.id}|${genes.join(',')}`;
+        if (this.countsCache?.key !== key) {
+            this.countsCache = { key, counts: this.port.getTranscriptCounts(genes) };
+        }
+        let counts;
+        try {
+            counts = await this.countsCache.counts;
+        }
+        catch {
+            this.countsCache = null;
+            return;
+        }
+        if (ctx.stale())
+            return;
+        const inView = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, dataset.imageRef, 0);
+        if (!inView)
+            return;
+        const b = counts.bounds;
+        const share = Math.min(1, visibleArea(inView, b) / Math.max(1, (b[2] - b[0]) * (b[3] - b[1])));
+        const selected = view.transcriptAllGenes
+            ? counts.total
+            : genes.reduce((sum, g) => sum + (counts.counts[g] ?? 0), 0);
+        this.changed({ points: Math.round(selected * share), max: view.transcriptBudget });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"density-layer.js","sourceRoot":"","sources":["../../../../../../src/lib/implementations/napari-js/spatial-tiles/density-layer.ts"],"names":[],"mappings":"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","sourcesContent":["import { colormapFromLut } from 'napari-js';\nimport type { ImageLayer, Viewer } from 'napari-js';\nimport { INFERNO_LUT } from 'napari-js/colormaps';\n\nimport { ALL_GENES, type SpatialDataPort } from '../../../contracts/ports/spatial-data.port';\nimport type { SpatialViewState } from '../../../contracts/display-types';\nimport type { SpatialDataset, SpatialTranscriptCounts } from '../../../contracts/spatial-dataset.contract';\nimport { lutFor } from '../../../spatial/spatial-encoding';\nimport { visibleArea, visibleDataRect } from '../../../spatial/lod';\nimport { densityAutoRange } from '../../../spatial/density-raster';\nimport type { OrderedLayerGroups, TileGroup } from './layer-groups';\nimport type { PlanContext } from './plan-context';\n\n/** The density window in use and the densest bin (transcripts per unit area). */\nexport interface DensityStats {\n  lo: number;\n  hi: number;\n  max: number;\n}\n\n/** Xenium Explorer's \"Estimated Transcript Points\". */\nexport interface TranscriptEstimate {\n  /** Transcripts of the visible genes estimated to be in view. */\n  points: number;\n  /** The marker budget. */\n  max: number;\n}\n\n/**\n * The transcript density image of the 2D spatial view: the visible genes' summed density\n * raster, one scalar layer in the `density` group, windowed and coloured on the GPU.\n *\n * Bins at or below the window's low end are transparent (`transparentBelow`), so a window,\n * colormap or opacity change is a uniform or LUT update of the same layer: only new genes or a\n * new bin size fetch and upload a raster.\n */\nexport class DensityLayer {\n  /** The density window in use and the densest bin, for the panel's threshold control. */\n  stats: DensityStats | null = null;\n  /** The drawn raster in transcripts per unit area, its densest bin and its auto window. */\n  private raster: { perArea: Float32Array; max: number; auto: [number, number] } | null = null;\n  /** The colormap the layer was given, so an unchanged one does not rebuild its LUT. */\n  private colormapKey: string | null = null;\n\n  constructor(\n    private readonly port: SpatialDataPort,\n    private readonly groups: OrderedLayerGroups<TileGroup>,\n    private readonly changed: (stats: DensityStats) => void,\n  ) {}\n\n  /** Draw the view's density, or drop it; an unchanged (genes, bin, window, colormap) is a no-op. */\n  async plan(dataset: SpatialDataset, view: SpatialViewState, ctx: PlanContext): Promise<void> {\n    const hiddenGenes = new Set(view.transcriptHiddenGenes);\n    const genes = view.transcriptAllGenes ? [ALL_GENES] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));\n    if (!dataset.density || !this.port.getDensity || view.transcriptMode !== 'density' || !genes.length) {\n      this.groups.drop('density');\n      this.stats = null;\n      this.raster = null;\n      return;\n    }\n    // The raster's key: what it is a raster OF. Window, colormap and opacity are the layer's style.\n    const key = [dataset.id, genes.join(','), view.densityBin].join('|');\n    // `shown`, not `has`: a stitched slice re-render clears the layer list, and the key alone\n    // would call the cleared layer drawn.\n    if (key !== this.groups.key('density') || !this.groups.shown('density') || !this.raster) {\n      const raster = await ctx.track('Transcript density', this.port.getDensity(genes, view.densityBin));\n      if (ctx.stale()) return;\n\n      // Bins drawn as squares, as Xenium Explorer does; the window is in transcripts/µm².\n      const meta = raster.meta;\n      const area = meta.gridSize[0] * meta.gridSize[1];\n      const perArea = raster.values.map((v) => v / area);\n      this.raster = {\n        perArea,\n        max: perArea.reduce((m, v) => (v > m ? v : m), 0),\n        auto: densityAutoRange(perArea),\n      };\n      const ref = dataset.imageRef;\n      const sx = ref?.scale?.[0] ?? 1;\n      const sy = ref?.scale?.[1] ?? 1;\n      const layer: ImageLayer = this.groups.viewer!.addImage(\n        { kind: 'typed', width: meta.cols, height: meta.rows, channels: 1, dtype: 'float32', data: perArea },\n        {\n          name: `density · ${view.transcriptAllGenes ? 'all genes' : genes.join(', ')}`,\n          scale: [meta.gridSize[0] * sx, meta.gridSize[1] * sy],\n          translate: [\n            meta.origin[0] * sx + (ref?.translate?.[0] ?? 0),\n            meta.origin[1] * sy + (ref?.translate?.[1] ?? 0),\n          ],\n          // Xenium Explorer's \"scale threshold\": empty tissue shows the image under it.\n          transparentBelow: true,\n          blending: 'translucent',\n          interpolation: 'nearest',\n        },\n      );\n      this.colormapKey = null;\n      this.groups.setKey('density', key);\n      this.groups.replace('density', layer);\n    }\n    this.restyle(this.groups.layer('density') as ImageLayer, view);\n  }\n\n  /** Window, colour and opacity onto the drawn layer: uniforms and a LUT, no re-upload. */\n  private restyle(layer: ImageLayer, view: SpatialViewState): void {\n    const raster = this.raster!;\n    const [lo, hi] = view.densityRange ?? raster.auto;\n    layer.contrastLimits = [lo, hi];\n    layer.opacity = view.densityOpacity;\n    const colormapKey = JSON.stringify(view.densityColormap ?? null);\n    if (colormapKey !== this.colormapKey) {\n      this.colormapKey = colormapKey;\n      layer.colormap = colormapFromLut('transcript-density', lutFor(view.densityColormap ?? INFERNO_LUT));\n    }\n    this.groups.viewer!.requestRender();\n    const stats = { lo, hi, max: raster.max };\n    if (this.stats?.lo === lo && this.stats.hi === hi && this.stats.max === raster.max) return;\n    this.stats = stats;\n    this.changed(stats);\n  }\n}\n\n/**\n * Transcripts in view for the visible genes, against the marker budget — it tells the user\n * whether the budget will force grouping. Caches the per-gene dataset totals for the latest\n * gene set.\n */\nexport class TranscriptEstimator {\n  /** Per-gene dataset totals for the in-view estimate, for the latest gene set. */\n  private countsCache: { key: string; counts: Promise<SpatialTranscriptCounts> } | null = null;\n\n  constructor(\n    private readonly port: SpatialDataPort,\n    private readonly changed: (estimate: TranscriptEstimate | null) => void,\n  ) {}\n\n  /**\n   * Transcripts in view for the visible genes: each gene's dataset total times the share\n   * of the tissue on screen. An estimate — expression is not uniform — which is also what\n   * Xenium Explorer shows; it tells the user whether the budget will force grouping.\n   */\n  async plan(\n    dataset: SpatialDataset,\n    view: SpatialViewState,\n    viewer: Viewer,\n    w: number,\n    h: number,\n    ctx: PlanContext,\n  ): Promise<void> {\n    const tiles = dataset.transcriptTiles;\n    if (!tiles || !this.port.getTranscriptCounts || view.transcriptMode === 'off') {\n      this.changed(null);\n      return;\n    }\n    const hiddenGenes = new Set(view.transcriptHiddenGenes);\n    const genes = view.transcriptAllGenes ? [] : view.transcriptGenes.filter((g) => !hiddenGenes.has(g));\n    const key = `${dataset.id}|${genes.join(',')}`;\n    if (this.countsCache?.key !== key) {\n      this.countsCache = { key, counts: this.port.getTranscriptCounts(genes) };\n    }\n    let counts: SpatialTranscriptCounts;\n    try {\n      counts = await this.countsCache.counts;\n    } catch {\n      this.countsCache = null;\n      return;\n    }\n    if (ctx.stale()) return;\n    const inView = visibleDataRect(viewer.camera.center, viewer.camera.zoom, w, h, dataset.imageRef, 0);\n    if (!inView) return;\n    const b = counts.bounds;\n    const share = Math.min(1, visibleArea(inView, b) / Math.max(1, (b[2] - b[0]) * (b[3] - b[1])));\n    const selected = view.transcriptAllGenes\n      ? counts.total\n      : genes.reduce((sum, g) => sum + (counts.counts[g] ?? 0), 0);\n    this.changed({ points: Math.round(selected * share), max: view.transcriptBudget });\n  }\n}\n"]}