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

package/esm2022/lib/spatial/lod.mjs

@@ -0,0 +1,187 @@
+/**
+ * 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 and which tiles are on
+ * screen. 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 { worldViewport } from 'napari-js';
+import { quantile } from './stats';
+// ── What the view draws ───────────────────────────────────────────────────────────────
+/** Whether cell outlines are drawn: the user's choice, else on when the dataset has any. */
+export function cellsShown(dataset, view) {
+    const available = !!(dataset?.polygonTiles || dataset?.polygons);
+    return available && (view.showCells ?? true);
+}
+/** A column holding a hand-curated cell-type annotation, by naming convention. */
+export function isCuratedColumn(name) {
+    return /curated/i.test(name);
+}
+/**
+ * The categorical column that names each cell's type: the view's choice when it is a
+ * column of this dataset, else the first categorical column that is not a curated
+ * annotation (a pipeline's clustering is the default; curation is opted into), else
+ * any categorical column.
+ */
+export function cellTypeColumnFor(dataset, view) {
+    const categorical = dataset.columns.filter((c) => c.kind === 'categorical');
+    if (view.cellTypeColumn && categorical.some((c) => c.name === view.cellTypeColumn)) {
+        return view.cellTypeColumn;
+    }
+    return (categorical.find((c) => !isCuratedColumn(c.name)) ?? categorical[0])?.name ?? null;
+}
+// ── Tiles in view ─────────────────────────────────────────────────────────────────────
+/** A stable string id for a tile key, `level/gx/gy` — usable as a Map key. */
+export function tileId(k) {
+    return `${k.level}/${k.gx}/${k.gy}`;
+}
+/** Canvas pixels per observation unit along x, for a camera zoom and a data→world affine. */
+export function pixelsPerDataUnit(zoom, ref) {
+    return zoom * Math.abs(ref?.scale?.[0] ?? 1);
+}
+/**
+ * The part of observation space the camera shows, padded by `margin` (a fraction of the
+ * viewport) so tiles just off screen are already there when a pan brings them in: napari-js's
+ * `worldViewport`, mapped back through the inverse of the data→world affine.
+ */
+export function visibleDataRect(center, zoom, canvasW, canvasH, ref, margin = 0.15) {
+    if (!(zoom > 0) || !(canvasW > 0) || !(canvasH > 0))
+        return null;
+    const sx = ref?.scale?.[0] ?? 1;
+    const sy = ref?.scale?.[1] ?? 1;
+    const tx = ref?.translate?.[0] ?? 0;
+    const ty = ref?.translate?.[1] ?? 0;
+    // The world rect of a canvas grown by the margin on each side (napari-js's worldViewport).
+    const v = worldViewport(center[0], center[1], zoom, canvasW * (1 + 2 * margin), canvasH * (1 + 2 * margin));
+    const wx0 = v.x;
+    const wx1 = v.x + v.width;
+    const wy0 = v.y;
+    const wy1 = v.y + v.height;
+    const ax = (wx0 - tx) / sx;
+    const bx = (wx1 - tx) / sx;
+    const ay = (wy0 - ty) / sy;
+    const by = (wy1 - ty) / sy;
+    return { x0: Math.min(ax, bx), y0: Math.min(ay, by), x1: Math.max(ax, bx), y1: Math.max(ay, by) };
+}
+/**
+ * Tiles of one level intersecting `rect`, clipped to the dataset's `bounds` (so zooming
+ * out over empty canvas does not ask for tiles that cannot exist). Ordered from the
+ * rectangle's centre outward, so the middle of the screen fills in first.
+ *
+ * Tile `g` covers `[g·s, (g+1)·s)`. The view's far edge is open — a tile starting exactly
+ * at `rect.x1` shows nothing — but the bounds' far edge is closed: the bounds are the
+ * extreme observations' coordinates, so one sits exactly on `bounds[2]`, in the tile
+ * starting there.
+ */
+export function tilesInRect(rect, level, levels, bounds, limit = Infinity) {
+    const size = levels[level]?.tileSize;
+    if (!(size > 0))
+        return [];
+    let { x0, y0 } = rect;
+    // Last tile along an axis: the one before the open view edge, at most the closed bound's.
+    let gx1 = Math.ceil(rect.x1 / size) - 1;
+    let gy1 = Math.ceil(rect.y1 / size) - 1;
+    if (bounds) {
+        x0 = Math.max(x0, bounds[0]);
+        y0 = Math.max(y0, bounds[1]);
+        if (Math.min(rect.x1, bounds[2]) < x0 || Math.min(rect.y1, bounds[3]) < y0)
+            return [];
+        gx1 = Math.min(gx1, Math.floor(bounds[2] / size));
+        gy1 = Math.min(gy1, Math.floor(bounds[3] / size));
+    }
+    const gx0 = Math.floor(x0 / size);
+    const gy0 = Math.floor(y0 / size);
+    const cx = (rect.x0 + rect.x1) / 2 / size;
+    const cy = (rect.y0 + rect.y1) / 2 / size;
+    const out = [];
+    for (let gy = gy0; gy <= gy1; gy++) {
+        for (let gx = gx0; gx <= gx1; gx++)
+            out.push({ level, gx, gy });
+    }
+    out.sort((a, b) => (a.gx + 0.5 - cx) ** 2 + (a.gy + 0.5 - cy) ** 2 - ((b.gx + 0.5 - cx) ** 2 + (b.gy + 0.5 - cy) ** 2));
+    return out.length > limit ? out.slice(0, limit) : out;
+}
+/** {@link tilesInRect} for a grid whose tile (0, 0) starts at `origin`. */
+export function tilesInRectFrom(origin, rect, level, levels, bounds, limit = Infinity) {
+    const [ox, oy] = origin;
+    const shifted = { x0: rect.x0 - ox, y0: rect.y0 - oy, x1: rect.x1 - ox, y1: rect.y1 - oy };
+    const b = bounds ? [bounds[0] - ox, bounds[1] - oy, bounds[2] - ox, bounds[3] - oy] : null;
+    return tilesInRect(shifted, level, levels, b, limit);
+}
+/** Area of `rect` inside `bounds` (the whole rect when there are none). */
+export function visibleArea(rect, bounds) {
+    const x0 = bounds ? Math.max(rect.x0, bounds[0]) : rect.x0;
+    const y0 = bounds ? Math.max(rect.y0, bounds[1]) : rect.y0;
+    const x1 = bounds ? Math.min(rect.x1, bounds[2]) : rect.x1;
+    const y1 = bounds ? Math.min(rect.y1, bounds[3]) : rect.y1;
+    return Math.max(0, x1 - x0) * Math.max(0, y1 - y0);
+}
+// ── Levels ────────────────────────────────────────────────────────────────────────────
+/**
+ * Typical cell diameter, in observation units, used to judge how large cells appear.
+ * Derived from the per-observation radius when there is one; 12 µm otherwise.
+ */
+export function typicalCellDiameter(radius, fallback = 12) {
+    if (typeof radius === 'number')
+        return radius > 0 ? radius * 2 : fallback;
+    if (!radius?.length)
+        return fallback;
+    // The median of a sample is plenty — this sets a threshold, not a measurement.
+    const median = quantile(radius, 0.5, { filter: 'positive', sampleSize: 2048 });
+    return median === null ? fallback : median * 2;
+}
+/**
+ * On-screen cell diameter (px) at or above which each polygon level is used. A level
+ * halves the vertices of the one below, so each should take over when the cell is about
+ * half as large on screen. Below the last finite threshold outlines are not drawn at
+ * all — a cell a few pixels wide is a dot, and the observation markers already draw it
+ * as one.
+ *
+ * Xenium's fourth level (3 vertices per cell) is deliberately never used: seen on
+ * screen it is a field of triangles, which reads as an artefact rather than as cells.
+ * The dots below 8 px say the same thing more honestly.
+ */
+export const POLYGON_LEVEL_MIN_CELL_PX = [36, 18, 8, Infinity];
+/**
+ * Which polygon level suits this zoom, or -1 for "too small to outline".
+ * `detail` > 1 prefers finer levels (sharper, slower); < 1 coarser.
+ */
+export function polygonLevelFor(pxPerUnit, cellDiameter, levelCount, detail = 1) {
+    const cellPx = pxPerUnit * cellDiameter * detail;
+    const table = POLYGON_LEVEL_MIN_CELL_PX;
+    for (let l = 0; l < levelCount; l++) {
+        // Past the table, keep halving: each level still halves the vertices.
+        const min = table[l] ?? table[table.length - 1] / 2 ** (l - table.length + 1);
+        if (cellPx >= min)
+            return l;
+    }
+    return -1;
+}
+/**
+ * Which transcript level suits this zoom: the one whose tiles come out closest to
+ * `targetTilePx` on screen. Coarser levels aggregate more, so this keeps the number of
+ * markers per screen roughly constant however far out the camera is — the property that
+ * keeps the view fast.
+ */
+export function transcriptLevelFor(pxPerUnit, levels, targetTilePx = 512) {
+    if (!levels.length || !(pxPerUnit > 0))
+        return 0;
+    let best = 0;
+    let bestErr = Infinity;
+    for (let l = 0; l < levels.length; l++) {
+        const err = Math.abs(Math.log2((levels[l].tileSize * pxPerUnit) / targetTilePx));
+        if (err < bestErr) {
+            bestErr = err;
+            best = l;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lod.js","sourceRoot":"","sources":["../../../../src/lib/spatial/lod.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Level-of-detail planning for tiled spatial geometry — cell outlines and transcripts.\n *\n * The renderer knows its camera (a world-space centre, a zoom in canvas pixels per world\n * unit, a canvas size); a tiled dataset knows its grids (one per level, in observation\n * units). This module is the bridge: which level the zoom calls for and which tiles are on\n * screen. Everything here is pure, so the policy — the part that decides whether the view\n * is fast and legible — is testable without a GPU.\n *\n * Observation units map onto world units through the dataset's `imageRef` affine\n * (`world = data · scale + translate`), so \"pixels per observation unit\" is\n * `zoom · scale`. For a Xenium bundle the data unit is the micron and the world unit the\n * morphology pixel.\n */\n\nimport { worldViewport } from 'napari-js';\n\nimport type {\n  SpatialBounds,\n  SpatialDataset,\n  SpatialImageRef,\n  SpatialTileLevel,\n} from '../contracts/spatial-dataset.contract';\nimport type { SpatialViewState } from '../contracts/display-types';\nimport { quantile } from './stats';\n\n/** A rectangle in observation coordinates. */\nexport interface DataRect {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/** Tile address. */\nexport interface TileKey {\n  level: number;\n  gx: number;\n  gy: number;\n}\n\n// ── What the view draws ───────────────────────────────────────────────────────────────\n\n/** Whether cell outlines are drawn: the user's choice, else on when the dataset has any. */\nexport function cellsShown(\n  dataset: Pick<SpatialDataset, 'polygonTiles' | 'polygons'> | null,\n  view: Pick<SpatialViewState, 'showCells'>,\n): boolean {\n  const available = !!(dataset?.polygonTiles || dataset?.polygons);\n  return available && (view.showCells ?? true);\n}\n\n/** A column holding a hand-curated cell-type annotation, by naming convention. */\nexport function isCuratedColumn(name: string): boolean {\n  return /curated/i.test(name);\n}\n\n/**\n * The categorical column that names each cell's type: the view's choice when it is a\n * column of this dataset, else the first categorical column that is not a curated\n * annotation (a pipeline's clustering is the default; curation is opted into), else\n * any categorical column.\n */\nexport function cellTypeColumnFor(\n  dataset: SpatialDataset,\n  view: Pick<SpatialViewState, 'cellTypeColumn'>,\n): string | null {\n  const categorical = dataset.columns.filter((c) => c.kind === 'categorical');\n  if (view.cellTypeColumn && categorical.some((c) => c.name === view.cellTypeColumn)) {\n    return view.cellTypeColumn;\n  }\n  return (categorical.find((c) => !isCuratedColumn(c.name)) ?? categorical[0])?.name ?? null;\n}\n\n// ── Tiles in view ─────────────────────────────────────────────────────────────────────\n\n/** A stable string id for a tile key, `level/gx/gy` — usable as a Map key. */\nexport function tileId(k: TileKey): string {\n  return `${k.level}/${k.gx}/${k.gy}`;\n}\n\n/** Canvas pixels per observation unit along x, for a camera zoom and a data→world affine. */\nexport function pixelsPerDataUnit(zoom: number, ref?: SpatialImageRef | null): number {\n  return zoom * Math.abs(ref?.scale?.[0] ?? 1);\n}\n\n/**\n * The part of observation space the camera shows, padded by `margin` (a fraction of the\n * viewport) so tiles just off screen are already there when a pan brings them in: napari-js's\n * `worldViewport`, mapped back through the inverse of the data→world affine.\n */\nexport function visibleDataRect(\n  center: readonly [number, number],\n  zoom: number,\n  canvasW: number,\n  canvasH: number,\n  ref?: SpatialImageRef | null,\n  margin = 0.15,\n): DataRect | null {\n  if (!(zoom > 0) || !(canvasW > 0) || !(canvasH > 0)) return null;\n  const sx = ref?.scale?.[0] ?? 1;\n  const sy = ref?.scale?.[1] ?? 1;\n  const tx = ref?.translate?.[0] ?? 0;\n  const ty = ref?.translate?.[1] ?? 0;\n  // The world rect of a canvas grown by the margin on each side (napari-js's worldViewport).\n  const v = worldViewport(center[0], center[1], zoom, canvasW * (1 + 2 * margin), canvasH * (1 + 2 * margin));\n  const wx0 = v.x;\n  const wx1 = v.x + v.width;\n  const wy0 = v.y;\n  const wy1 = v.y + v.height;\n  const ax = (wx0 - tx) / sx;\n  const bx = (wx1 - tx) / sx;\n  const ay = (wy0 - ty) / sy;\n  const by = (wy1 - ty) / sy;\n  return { x0: Math.min(ax, bx), y0: Math.min(ay, by), x1: Math.max(ax, bx), y1: Math.max(ay, by) };\n}\n\n/**\n * Tiles of one level intersecting `rect`, clipped to the dataset's `bounds` (so zooming\n * out over empty canvas does not ask for tiles that cannot exist). Ordered from the\n * rectangle's centre outward, so the middle of the screen fills in first.\n *\n * Tile `g` covers `[g·s, (g+1)·s)`. The view's far edge is open — a tile starting exactly\n * at `rect.x1` shows nothing — but the bounds' far edge is closed: the bounds are the\n * extreme observations' coordinates, so one sits exactly on `bounds[2]`, in the tile\n * starting there.\n */\nexport function tilesInRect(\n  rect: DataRect,\n  level: number,\n  levels: readonly SpatialTileLevel[],\n  bounds?: SpatialBounds | null,\n  limit = Infinity,\n): TileKey[] {\n  const size = levels[level]?.tileSize;\n  if (!(size > 0)) return [];\n  let { x0, y0 } = rect;\n  // Last tile along an axis: the one before the open view edge, at most the closed bound's.\n  let gx1 = Math.ceil(rect.x1 / size) - 1;\n  let gy1 = Math.ceil(rect.y1 / size) - 1;\n  if (bounds) {\n    x0 = Math.max(x0, bounds[0]);\n    y0 = Math.max(y0, bounds[1]);\n    if (Math.min(rect.x1, bounds[2]) < x0 || Math.min(rect.y1, bounds[3]) < y0) return [];\n    gx1 = Math.min(gx1, Math.floor(bounds[2] / size));\n    gy1 = Math.min(gy1, Math.floor(bounds[3] / size));\n  }\n  const gx0 = Math.floor(x0 / size);\n  const gy0 = Math.floor(y0 / size);\n  const cx = (rect.x0 + rect.x1) / 2 / size;\n  const cy = (rect.y0 + rect.y1) / 2 / size;\n  const out: TileKey[] = [];\n  for (let gy = gy0; gy <= gy1; gy++) {\n    for (let gx = gx0; gx <= gx1; gx++) out.push({ level, gx, gy });\n  }\n  out.sort(\n    (a, b) => (a.gx + 0.5 - cx) ** 2 + (a.gy + 0.5 - cy) ** 2 - ((b.gx + 0.5 - cx) ** 2 + (b.gy + 0.5 - cy) ** 2),\n  );\n  return out.length > limit ? out.slice(0, limit) : out;\n}\n\n/** {@link tilesInRect} for a grid whose tile (0, 0) starts at `origin`. */\nexport function tilesInRectFrom(\n  origin: readonly [number, number],\n  rect: DataRect,\n  level: number,\n  levels: readonly SpatialTileLevel[],\n  bounds?: SpatialBounds | null,\n  limit = Infinity,\n): TileKey[] {\n  const [ox, oy] = origin;\n  const shifted = { x0: rect.x0 - ox, y0: rect.y0 - oy, x1: rect.x1 - ox, y1: rect.y1 - oy };\n  const b: SpatialBounds | null = bounds ? [bounds[0] - ox, bounds[1] - oy, bounds[2] - ox, bounds[3] - oy] : null;\n  return tilesInRect(shifted, level, levels, b, limit);\n}\n\n/** Area of `rect` inside `bounds` (the whole rect when there are none). */\nexport function visibleArea(rect: DataRect, bounds?: SpatialBounds | null): number {\n  const x0 = bounds ? Math.max(rect.x0, bounds[0]) : rect.x0;\n  const y0 = bounds ? Math.max(rect.y0, bounds[1]) : rect.y0;\n  const x1 = bounds ? Math.min(rect.x1, bounds[2]) : rect.x1;\n  const y1 = bounds ? Math.min(rect.y1, bounds[3]) : rect.y1;\n  return Math.max(0, x1 - x0) * Math.max(0, y1 - y0);\n}\n\n// ── Levels ────────────────────────────────────────────────────────────────────────────\n\n/**\n * Typical cell diameter, in observation units, used to judge how large cells appear.\n * Derived from the per-observation radius when there is one; 12 µm otherwise.\n */\nexport function typicalCellDiameter(radius: Float32Array | number | undefined, fallback = 12): number {\n  if (typeof radius === 'number') return radius > 0 ? radius * 2 : fallback;\n  if (!radius?.length) return fallback;\n  // The median of a sample is plenty — this sets a threshold, not a measurement.\n  const median = quantile(radius, 0.5, { filter: 'positive', sampleSize: 2048 });\n  return median === null ? fallback : median * 2;\n}\n\n/**\n * On-screen cell diameter (px) at or above which each polygon level is used. A level\n * halves the vertices of the one below, so each should take over when the cell is about\n * half as large on screen. Below the last finite threshold outlines are not drawn at\n * all — a cell a few pixels wide is a dot, and the observation markers already draw it\n * as one.\n *\n * Xenium's fourth level (3 vertices per cell) is deliberately never used: seen on\n * screen it is a field of triangles, which reads as an artefact rather than as cells.\n * The dots below 8 px say the same thing more honestly.\n */\nexport const POLYGON_LEVEL_MIN_CELL_PX = [36, 18, 8, Infinity];\n\n/**\n * Which polygon level suits this zoom, or -1 for \"too small to outline\".\n * `detail` > 1 prefers finer levels (sharper, slower); < 1 coarser.\n */\nexport function polygonLevelFor(pxPerUnit: number, cellDiameter: number, levelCount: number, detail = 1): number {\n  const cellPx = pxPerUnit * cellDiameter * detail;\n  const table = POLYGON_LEVEL_MIN_CELL_PX;\n  for (let l = 0; l < levelCount; l++) {\n    // Past the table, keep halving: each level still halves the vertices.\n    const min = table[l] ?? table[table.length - 1] / 2 ** (l - table.length + 1);\n    if (cellPx >= min) return l;\n  }\n  return -1;\n}\n\n/**\n * Which transcript level suits this zoom: the one whose tiles come out closest to\n * `targetTilePx` on screen. Coarser levels aggregate more, so this keeps the number of\n * markers per screen roughly constant however far out the camera is — the property that\n * keeps the view fast.\n */\nexport function transcriptLevelFor(\n  pxPerUnit: number,\n  levels: readonly SpatialTileLevel[],\n  targetTilePx = 512,\n): number {\n  if (!levels.length || !(pxPerUnit > 0)) return 0;\n  let best = 0;\n  let bestErr = Infinity;\n  for (let l = 0; l < levels.length; l++) {\n    const err = Math.abs(Math.log2((levels[l].tileSize * pxPerUnit) / targetTilePx));\n    if (err < bestErr) {\n      bestErr = err;\n      best = l;\n    }\n  }\n  return best;\n}\n"]}

package/esm2022/lib/spatial/spatial-controls.facade.mjs

@@ -0,0 +1,200 @@
+import { firstValueFrom } from 'rxjs';
+import { isSpatialOmics3d } from '../contracts/plot-type';
+import { isCategoricalColumn } from '../contracts/spatial-dataset.contract';
+import { resolveCategoryColors } from './spatial-encoding';
+import { sectionsOf } from './spatial-sections';
+import { observationsInSlice, volumeImageRef } from './spatial-volume-image';
+import { emptySelection, selectByCategory, selectByIndices, selectInRegions, selectInRegionsProjected, } from './spatial-selection';
+/**
+ * The spatial-omics controls (`ISpatialControls`) over a host's `SPATIAL_DATA_PORT`.
+ *
+ * Backend-neutral: the view state lives in the shared `VisualizerStore` (like the
+ * colormap) and the selection in the `SpatialSelectionStore`, so the controls keep
+ * working across a plot-type switch and a host can drive them before any backend has
+ * mounted. Owns its mirror of the port's dataset — dropping a stale selection and an
+ * unsatisfiable colour source when the dataset changes — and the subscription behind
+ * it, released by {@link dispose} (review CORE-30).
+ */
+export class SpatialControlsFacade {
+    constructor(port, ctx) {
+        this.port = port;
+        this.ctx = ctx;
+        /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously — it
+         *  runs from a button click and must not await a round-trip. */
+        this.dataset = null;
+        // Mirror the dataset (and drop a stale selection when it changes — the masks are
+        // index-based, so they are meaningless against different observations).
+        this.sub = port.getDataset$().subscribe((dataset) => {
+            const changed = dataset?.id !== this.dataset?.id;
+            this.dataset = dataset;
+            if (!changed)
+                return;
+            ctx.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));
+            // A colour source the new dataset cannot satisfy would leave the map flat while
+            // the panel and the charts kept naming the old column — so drop it, and only it:
+            // point size, opacity and the rest are the user's preferences.
+            const by = ctx.store.currentSpatialView().colorBy;
+            if (by && !canColorBy(dataset, by))
+                ctx.store.setSpatialView({ colorBy: null });
+        });
+        this.controls = this.build();
+    }
+    /** Release the port subscription (the router's injector is being destroyed). */
+    dispose() {
+        this.sub.unsubscribe();
+    }
+    build() {
+        const port = this.port;
+        return {
+            getDataset$: () => port.getDataset$(),
+            getViewState$: () => this.ctx.store.getSpatialView$(),
+            viewState: () => this.ctx.store.currentSpatialView(),
+            setViewState: (partial) => this.ctx.store.setSpatialView(partial),
+            // The hint SEEDS the toggle when the source changes, and nothing consults it
+            // afterwards. It used to be ORed in at render time, which meant an unchecked
+            // box could not turn log scaling off for a hinted column — and the linked
+            // chart, which reads `logScale` alone, disagreed with the map about what it
+            // was showing. One authority, set once per source.
+            colorByColumn: (name) => {
+                const meta = this.dataset?.columns.find((c) => c.name === name);
+                const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;
+                this.ctx.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });
+            },
+            colorByFeature: (name) => this.ctx.store.setSpatialView({
+                colorBy: { kind: 'feature', name },
+                logScale: !!this.dataset?.features?.logScaleHint,
+            }),
+            clearColorBy: () => this.ctx.store.setSpatialView({ colorBy: null }),
+            searchFeatures: async (query, limit = 50) => {
+                // Prefer the port's search (a 31k-gene dataset does not ship its names);
+                // otherwise filter whatever the manifest inlined.
+                if (port.searchFeatures)
+                    return port.searchFeatures(query, limit);
+                const dataset = await firstValueFrom(port.getDataset$());
+                const names = dataset?.features?.names ?? [];
+                const q = query.toLowerCase();
+                return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);
+            },
+            ...(port.importGroups
+                ? {
+                    importGroups: (label, table) => port.importGroups(label, table),
+                }
+                : {}),
+            ...(port.getTranscriptCounts
+                ? {
+                    transcriptCounts: (genes) => port.getTranscriptCounts(genes),
+                }
+                : {}),
+            ...(port.getMarkerGenes
+                ? {
+                    markerGenes: (column, perGroup) => port.getMarkerGenes(column, perGroup),
+                }
+                : {}),
+            getTranscriptEstimate$: () => this.ctx.napari.transcriptEstimate$.asObservable(),
+            getGeneCountsInView$: () => this.ctx.napari.geneCountsInView$.asObservable(),
+            getDensityStats$: () => this.ctx.napari.densityStats$.asObservable(),
+            categoryColors: async (name) => {
+                const column = await port.getColumn(name);
+                if (!isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
+                }
+                // Resolved by the SAME function the renderer uses, so a legend swatch
+                // can never disagree with the colour on screen.
+                return resolveCategoryColors(column.meta);
+            },
+            continuousValues: async (source) => {
+                if (source.kind === 'feature')
+                    return port.getFeatureVector(source.name);
+                const column = await port.getColumn(source.name);
+                if (isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${source.name}" is categorical — it has no values to chart`);
+                }
+                return column.values;
+            },
+            categoricalView: async (name) => {
+                const column = await port.getColumn(name);
+                if (!isCategoricalColumn(column)) {
+                    throw new Error(`[spatial] column "${name}" is continuous — it has no categories`);
+                }
+                return {
+                    name,
+                    categories: column.meta.categories,
+                    colors: resolveCategoryColors(column.meta),
+                    codes: column.codes,
+                };
+            },
+            // Spread rather than always defined: `getEmbedding` is optional on both the port
+            // and this facade, and a panel checks for its presence to decide whether the view
+            // is offered at all. Defining it as a function that rejects would make an
+            // embedding-less source look like a broken one.
+            ...(port.getEmbedding ? { getEmbedding: (name) => port.getEmbedding(name) } : {}),
+            categoricalColumns: () => (this.dataset?.columns ?? []).filter((c) => c.kind === 'categorical').map((c) => c.name),
+            // Memoized on the observations object, so the renderer's own lookup and
+            // this one are the same single scan of up to 3.7M z values.
+            sampledSections: () => {
+                const obs = this.dataset?.observations;
+                return obs ? sectionsOf(obs) : null;
+            },
+            getSelection$: () => this.ctx.selectionStore.getSelection$(),
+            selectFromRegions: () => {
+                const dataset = this.dataset;
+                if (!dataset)
+                    return 0;
+                const regions = this.ctx.regionStore.getRegions();
+                // The union of every drawn region — so every ROI tool the library
+                // already has doubles as a spatial selection tool.
+                //
+                // In the 3D cloud there is no data-space affine to push a drawn shape
+                // through, so the observations are projected to canvas pixels by the
+                // renderer (which owns the camera) and tested in screen space instead.
+                // Falls back to the 2D path whenever the cloud is not mounted.
+                const projected = isSpatialOmics3d(this.ctx.plotType())
+                    ? this.ctx.napari.getSpatialScreenProjection(dataset.observations)
+                    : null;
+                // In the 2D view of a volume-backed dataset the shape was drawn over ONE
+                // section, in the volume's pixel grid: it selects the cells of that
+                // section, not the whole depth of brain standing behind them.
+                const volume = !dataset.imageRef ? dataset.volume : undefined;
+                const selection = projected
+                    ? selectInRegionsProjected(projected, dataset.observations.count, regions)
+                    : selectInRegions(dataset.observations, volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef, regions, volume ? observationsInSlice(dataset.observations, volume, this.ctx.zIndex()) : undefined);
+                this.ctx.selectionStore.set(selection);
+                return selection.count;
+            },
+            selectCategory: async (column, categoryIndex) => {
+                const loaded = await port.getColumn(column);
+                if (!isCategoricalColumn(loaded)) {
+                    throw new Error(`[spatial] column "${column}" is continuous — it has no categories`);
+                }
+                const selection = selectByCategory(loaded.codes, categoryIndex);
+                this.ctx.selectionStore.set(selection);
+                return selection.count;
+            },
+            selectIndices: (indices) => {
+                const count = this.dataset?.observations.count ?? 0;
+                if (count === 0)
+                    return 0;
+                const selection = selectByIndices(indices, count);
+                this.ctx.selectionStore.set(selection);
+                return selection.count;
+            },
+            clearSelection: () => this.ctx.selectionStore.clear(),
+        };
+    }
+}
+/**
+ * Whether `dataset` can answer this colour source. A column is checkable against the
+ * declared list. A gene is checkable only when the dataset inlines its feature names —
+ * a dataset too wide to inline them (typeahead-only) keeps the source, and a name that
+ * turns out not to exist surfaces as the chart's "could not be charted" rather than as
+ * a silent reset.
+ */
+function canColorBy(dataset, by) {
+    if (!dataset)
+        return false;
+    if (by.kind === 'column')
+        return dataset.columns.some((c) => c.name === by.name);
+    const names = dataset.features?.names;
+    return !!dataset.features && (!names || names.includes(by.name));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-controls.facade.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-controls.facade.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subscription, firstValueFrom } from 'rxjs';\n\nimport { PlotType, isSpatialOmics3d } from '../contracts/plot-type';\nimport { SpatialDataPort } from '../contracts/ports/spatial-data.port';\nimport { SpatialColorBy } from '../contracts/display-types';\nimport { SpatialDataset, SpatialObservations, isCategoricalColumn } from '../contracts/spatial-dataset.contract';\nimport { ISpatialControls } from '../contracts/visualizer.contract';\nimport { RegionStore } from '../store/region-store.service';\nimport { SpatialSelectionStore } from '../store/spatial-selection.service';\nimport { VisualizerStore } from '../store/visualizer-store.service';\nimport { resolveCategoryColors } from './spatial-encoding';\nimport { sectionsOf } from './spatial-sections';\nimport { observationsInSlice, volumeImageRef } from './spatial-volume-image';\nimport {\n  emptySelection,\n  selectByCategory,\n  selectByIndices,\n  selectInRegions,\n  selectInRegionsProjected,\n} from './spatial-selection';\n\n/** The renderer-side spatial readouts the controls surface (the napari-js backend). */\nexport interface SpatialRendererFeeds {\n  readonly transcriptEstimate$: { asObservable(): Observable<{ points: number; max: number } | null> };\n  readonly geneCountsInView$: { asObservable(): Observable<Record<string, number> | null> };\n  readonly densityStats$: { asObservable(): Observable<{ lo: number; hi: number; max: number } | null> };\n  /** Observations projected to canvas pixels by the 3D camera, or null when the cloud is not mounted. */\n  getSpatialScreenProjection(obs: SpatialObservations): Float32Array | null;\n}\n\n/** What the facade works over: the shared stores, the renderer feeds and the router's view state. */\nexport interface SpatialControlsContext {\n  readonly store: VisualizerStore;\n  readonly regionStore: RegionStore;\n  readonly selectionStore: SpatialSelectionStore;\n  readonly napari: SpatialRendererFeeds;\n  /** The plot type on screen (the 3D cloud selects in screen space). */\n  plotType(): PlotType;\n  /** The displayed slice (a volume-backed dataset selects within one section). */\n  zIndex(): number;\n}\n\n/**\n * The spatial-omics controls (`ISpatialControls`) over a host's `SPATIAL_DATA_PORT`.\n *\n * Backend-neutral: the view state lives in the shared `VisualizerStore` (like the\n * colormap) and the selection in the `SpatialSelectionStore`, so the controls keep\n * working across a plot-type switch and a host can drive them before any backend has\n * mounted. Owns its mirror of the port's dataset — dropping a stale selection and an\n * unsatisfiable colour source when the dataset changes — and the subscription behind\n * it, released by {@link dispose} (review CORE-30).\n */\nexport class SpatialControlsFacade {\n  /** The controls; one object for the facade's life, so consumers can hold it. */\n  readonly controls: ISpatialControls;\n  /** Latest dataset, mirrored so `selectFromRegions()` can answer synchronously — it\n   *  runs from a button click and must not await a round-trip. */\n  private dataset: SpatialDataset | null = null;\n  private readonly sub: Subscription;\n\n  constructor(\n    private readonly port: SpatialDataPort,\n    private readonly ctx: SpatialControlsContext,\n  ) {\n    // Mirror the dataset (and drop a stale selection when it changes — the masks are\n    // index-based, so they are meaningless against different observations).\n    this.sub = port.getDataset$().subscribe((dataset) => {\n      const changed = dataset?.id !== this.dataset?.id;\n      this.dataset = dataset;\n      if (!changed) return;\n      ctx.selectionStore.set(emptySelection(dataset?.observations.count ?? 0));\n      // A colour source the new dataset cannot satisfy would leave the map flat while\n      // the panel and the charts kept naming the old column — so drop it, and only it:\n      // point size, opacity and the rest are the user's preferences.\n      const by = ctx.store.currentSpatialView().colorBy;\n      if (by && !canColorBy(dataset, by)) ctx.store.setSpatialView({ colorBy: null });\n    });\n    this.controls = this.build();\n  }\n\n  /** Release the port subscription (the router's injector is being destroyed). */\n  dispose(): void {\n    this.sub.unsubscribe();\n  }\n\n  private build(): ISpatialControls {\n    const port = this.port;\n    return {\n      getDataset$: () => port.getDataset$(),\n      getViewState$: () => this.ctx.store.getSpatialView$(),\n      viewState: () => this.ctx.store.currentSpatialView(),\n      setViewState: (partial) => this.ctx.store.setSpatialView(partial),\n      // The hint SEEDS the toggle when the source changes, and nothing consults it\n      // afterwards. It used to be ORed in at render time, which meant an unchecked\n      // box could not turn log scaling off for a hinted column — and the linked\n      // chart, which reads `logScale` alone, disagreed with the map about what it\n      // was showing. One authority, set once per source.\n      colorByColumn: (name: string) => {\n        const meta = this.dataset?.columns.find((c) => c.name === name);\n        const hint = meta?.kind === 'continuous' ? !!meta.logScaleHint : false;\n        this.ctx.store.setSpatialView({ colorBy: { kind: 'column', name }, logScale: hint });\n      },\n      colorByFeature: (name: string) =>\n        this.ctx.store.setSpatialView({\n          colorBy: { kind: 'feature', name },\n          logScale: !!this.dataset?.features?.logScaleHint,\n        }),\n      clearColorBy: () => this.ctx.store.setSpatialView({ colorBy: null }),\n      searchFeatures: async (query: string, limit = 50) => {\n        // Prefer the port's search (a 31k-gene dataset does not ship its names);\n        // otherwise filter whatever the manifest inlined.\n        if (port.searchFeatures) return port.searchFeatures(query, limit);\n        const dataset = await firstValueFrom(port.getDataset$());\n        const names = dataset?.features?.names ?? [];\n        const q = query.toLowerCase();\n        return names.filter((n) => n.toLowerCase().includes(q)).slice(0, limit);\n      },\n      ...(port.importGroups\n        ? {\n            importGroups: (label: string, table: string) => port.importGroups!(label, table),\n          }\n        : {}),\n      ...(port.getTranscriptCounts\n        ? {\n            transcriptCounts: (genes: string[]) => port.getTranscriptCounts!(genes),\n          }\n        : {}),\n      ...(port.getMarkerGenes\n        ? {\n            markerGenes: (column: string, perGroup?: number) => port.getMarkerGenes!(column, perGroup),\n          }\n        : {}),\n      getTranscriptEstimate$: () => this.ctx.napari.transcriptEstimate$.asObservable(),\n      getGeneCountsInView$: () => this.ctx.napari.geneCountsInView$.asObservable(),\n      getDensityStats$: () => this.ctx.napari.densityStats$.asObservable(),\n      categoryColors: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        // Resolved by the SAME function the renderer uses, so a legend swatch\n        // can never disagree with the colour on screen.\n        return resolveCategoryColors(column.meta);\n      },\n\n      continuousValues: async (source) => {\n        if (source.kind === 'feature') return port.getFeatureVector(source.name);\n        const column = await port.getColumn(source.name);\n        if (isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${source.name}\" is categorical — it has no values to chart`);\n        }\n        return column.values;\n      },\n\n      categoricalView: async (name: string) => {\n        const column = await port.getColumn(name);\n        if (!isCategoricalColumn(column)) {\n          throw new Error(`[spatial] column \"${name}\" is continuous — it has no categories`);\n        }\n        return {\n          name,\n          categories: column.meta.categories,\n          colors: resolveCategoryColors(column.meta),\n          codes: column.codes,\n        };\n      },\n\n      // Spread rather than always defined: `getEmbedding` is optional on both the port\n      // and this facade, and a panel checks for its presence to decide whether the view\n      // is offered at all. Defining it as a function that rejects would make an\n      // embedding-less source look like a broken one.\n      ...(port.getEmbedding ? { getEmbedding: (name: string) => port.getEmbedding!(name) } : {}),\n\n      categoricalColumns: () =>\n        (this.dataset?.columns ?? []).filter((c) => c.kind === 'categorical').map((c) => c.name),\n\n      // Memoized on the observations object, so the renderer's own lookup and\n      // this one are the same single scan of up to 3.7M z values.\n      sampledSections: () => {\n        const obs = this.dataset?.observations;\n        return obs ? sectionsOf(obs) : null;\n      },\n\n      getSelection$: () => this.ctx.selectionStore.getSelection$(),\n\n      selectFromRegions: () => {\n        const dataset = this.dataset;\n        if (!dataset) return 0;\n        const regions = this.ctx.regionStore.getRegions();\n        // The union of every drawn region — so every ROI tool the library\n        // already has doubles as a spatial selection tool.\n        //\n        // In the 3D cloud there is no data-space affine to push a drawn shape\n        // through, so the observations are projected to canvas pixels by the\n        // renderer (which owns the camera) and tested in screen space instead.\n        // Falls back to the 2D path whenever the cloud is not mounted.\n        const projected = isSpatialOmics3d(this.ctx.plotType())\n          ? this.ctx.napari.getSpatialScreenProjection(dataset.observations)\n          : null;\n        // In the 2D view of a volume-backed dataset the shape was drawn over ONE\n        // section, in the volume's pixel grid: it selects the cells of that\n        // section, not the whole depth of brain standing behind them.\n        const volume = !dataset.imageRef ? dataset.volume : undefined;\n        const selection = projected\n          ? selectInRegionsProjected(projected, dataset.observations.count, regions)\n          : selectInRegions(\n              dataset.observations,\n              volume ? volumeImageRef(volume, dataset.micronsPerUnit) : dataset.imageRef,\n              regions,\n              volume ? observationsInSlice(dataset.observations, volume, this.ctx.zIndex()) : undefined,\n            );\n        this.ctx.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectCategory: async (column: string, categoryIndex: number) => {\n        const loaded = await port.getColumn(column);\n        if (!isCategoricalColumn(loaded)) {\n          throw new Error(`[spatial] column \"${column}\" is continuous — it has no categories`);\n        }\n        const selection = selectByCategory(loaded.codes, categoryIndex);\n        this.ctx.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      selectIndices: (indices: Iterable<number>) => {\n        const count = this.dataset?.observations.count ?? 0;\n        if (count === 0) return 0;\n        const selection = selectByIndices(indices, count);\n        this.ctx.selectionStore.set(selection);\n        return selection.count;\n      },\n\n      clearSelection: () => this.ctx.selectionStore.clear(),\n    };\n  }\n}\n\n/**\n * Whether `dataset` can answer this colour source. A column is checkable against the\n * declared list. A gene is checkable only when the dataset inlines its feature names —\n * a dataset too wide to inline them (typeahead-only) keeps the source, and a name that\n * turns out not to exist surfaces as the chart's \"could not be charted\" rather than as\n * a silent reset.\n */\nfunction canColorBy(dataset: SpatialDataset | null, by: SpatialColorBy): boolean {\n  if (!dataset) return false;\n  if (by.kind === 'column') return dataset.columns.some((c) => c.name === by.name);\n  const names = dataset.features?.names;\n  return !!dataset.features && (!names || names.includes(by.name));\n}\n"]}