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

package/esm2022/lib/implementations/napari-js/napari-spatial-encoding.mjs

@@ -0,0 +1,199 @@
+import { colormapFromLut } from 'napari-js';
+import { NO_CATEGORY } from '../../contracts/spatial-dataset.contract';
+import { contrastWindow, encodeCategorical, encodeContinuous, resolveCategoryColors, } from '../../spatial/spatial-encoding';
+import { maskToIndices } from '../../spatial/spatial-selection';
+/**
+ * The spatial scenes' pure colour and grouping math: what the 2D markers, the 3D cloud and the
+ * density volumes are coloured with, as functions of the data, the view and a LUT. No viewer, no
+ * port, no store (review Appendix B, step 1).
+ */
+/** Marker radius (image px) for a dataset that declares none — segmented cells often don't. */
+export const SPATIAL_FALLBACK_RADIUS = 4;
+/** Smallest marker DIAMETER, in slice pixels, over a volume-backed dataset. A cell's real
+ *  size is honoured wherever it survives the grid: the ABC atlas serves 5 µm radii on a
+ *  40 µm/px template, so drawing them to scale would put every cell a fifth of a pixel wide
+ *  and the section would come up empty. The point-size control scales up from this floor. */
+export const SPATIAL_SLICE_MIN_DIAMETER_PX = 1.5;
+/** Longest side of the gene-map raster, in field pixels. A gene map is a smooth
+ *  field read as territory, so it gains nothing from matching a 2 Gpx slide's
+ *  resolution — and the estimate costs one pass over this many pixels. */
+export const GENE_MAP_MAX_SIDE = 512;
+/** Kernel σ in field pixels at smoothing 1: wide enough to read between cells,
+ *  tight enough to keep a nucleus-scale structure distinct. */
+export const GENE_MAP_SIGMA = 2.5;
+/**
+ * In-plane coarsening of the 3D gene map's lattice, relative to the reference
+ * volume. The field is smooth, so its detail is set by the kernel rather than the
+ * raster — and the estimate is a pair of separable blurs, which at the template's
+ * full resolution means seconds of work per toggle.
+ */
+export const GENE_MAP_VOLUME_STRIDE = 2;
+/** Clusters drawn as density volumes at once. Past a handful, additive translucent
+ *  clouds stop being separable by eye — and each one is a full rasterisation. */
+export const DENSITY_MAX_CLUSTERS = 6;
+/** How much larger a selected marker is drawn, so a small selection is findable inside a
+ *  3.7M-point cloud rather than merely brighter. */
+export const SPATIAL_SELECTED_SIZE_SCALE = 1.6;
+/** Base marker diameter for the 3D cloud, in SCREEN pixels (the layer's unit). */
+export const SPATIAL_3D_BASE_SIZE = 3;
+/** Colour for observations when nothing is selected to colour by: visible, neutral, and
+ *  obviously not encoding anything. */
+export const SPATIAL_NEUTRAL_COLOR = [0.35, 0.72, 0.95, 0.9];
+/** {@link SPATIAL_NEUTRAL_COLOR} as a hex colour (alpha dropped), for the encoders and the
+ *  density-volume tint. */
+export const SPATIAL_NEUTRAL_HEX = `#${SPATIAL_NEUTRAL_COLOR.slice(0, 3)
+    .map((c) => Math.round(c * 255)
+    .toString(16)
+    .padStart(2, '0'))
+    .join('')}`;
+/**
+ * Contrast windows memoised per (values array, lo, hi, log). `contrastWindow` sorts every value,
+ * and the spatial colouring re-runs it on each opacity, selection or colormap change while the
+ * coloured vector itself is unchanged (review SPATIAL-12). Keyed by the vector's identity, so a
+ * new column or gene vector is a miss and an old one is collected with its windows.
+ */
+export class ContrastWindowCache {
+    constructor() {
+        this.byVector = new WeakMap();
+    }
+    get(values, lo, hi, log, compute) {
+        let windows = this.byVector.get(values);
+        if (!windows) {
+            windows = new Map();
+            this.byVector.set(values, windows);
+        }
+        const key = `${lo}|${hi}|${log ? 1 : 0}`;
+        let w = windows.get(key);
+        if (!w) {
+            w = compute();
+            windows.set(key, w);
+        }
+        return w;
+    }
+}
+/** A one-colour colormap, for the "nothing to colour by" state. */
+export function spatialFlatColormap() {
+    const [r, g, b] = SPATIAL_NEUTRAL_COLOR;
+    const rgb = [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+    // Two identical stops: colormapFromLut needs at least two, and equal ends
+    // make every value resolve to the same colour.
+    return colormapFromLut('spatial-flat', [rgb, rgb]);
+}
+/**
+ * Category codes → one RGBA per point, for any number of categories.
+ *
+ * The 2D markers' encoding, with one difference: a point with no category stays opaque (grey),
+ * as it always has in the cloud, where the selection dims through the layer's per-point alphas
+ * instead. It used to be smuggled through the scalar channel as a stepped 256-entry LUT, which
+ * kept at most 95 categories apart (review SPATIAL-11, NAPARI-SVC-18).
+ */
+export function encodeSpatial3dCategorical(codes, colors) {
+    return { kind: 'colors', colors: encodeCategorical(codes, { colors, mutedOpacity: 1 }) };
+}
+/** Continuous values → `lut` over a percentile-clipped window (log1p first when the view's log
+ *  scale is on), for the 3D cloud's scalar channel. */
+export function encodeSpatial3dContinuous(source, view, lut, windows) {
+    const [lo, hi] = view.percentileClip ?? [0.01, 0.99];
+    const log = !!view.logScale;
+    let values = source;
+    if (log) {
+        values = new Float32Array(source.length);
+        for (let i = 0; i < source.length; i++)
+            values[i] = Math.log1p(Math.max(0, source[i]));
+    }
+    // Keyed by the SOURCE vector: the log copy above is new on every call.
+    const [min, max] = windows.get(source, lo, hi, log, () => contrastWindow(values, lo, hi));
+    return {
+        kind: 'scalars',
+        values,
+        colormap: colormapFromLut('spatial-continuous', lut),
+        // A degenerate window would divide by zero in the shader's normalisation.
+        contrastLimits: max > min ? [min, max] : [min, min + 1],
+    };
+}
+/** Continuous values → per-point RGBA through `lut` and a clipped window (log scale per the
+ *  view), for the 2D markers. */
+export function encodeSpatialContinuous(values, view, lut, windows, muted = null) {
+    const [lo, hi] = view.percentileClip ?? [0.01, 0.99];
+    // The window is taken on the raw values (encodeContinuous applies the log itself).
+    const [min, max] = windows.get(values, lo, hi, false, () => contrastWindow(values, lo, hi));
+    return encodeContinuous(values, {
+        lut,
+        min,
+        max,
+        log: view.logScale,
+        opacity: view.opacity,
+        muted,
+    });
+}
+/** Whether a colour input is one RGBA per point rather than one broadcast RGBA. */
+export function isPerPoint(colors) {
+    return colors instanceof Float32Array;
+}
+/** Per-point colours for the drawn subset. A broadcast tuple stays broadcast —
+ *  it is one colour for every point either way. */
+export function gatherColors(colors, indices) {
+    if (!indices || !isPerPoint(colors))
+        return colors;
+    const out = new Float32Array(indices.length * 4);
+    for (let i = 0; i < indices.length; i++) {
+        const s = indices[i] * 4;
+        const o = i * 4;
+        out[o] = colors[s];
+        out[o + 1] = colors[s + 1];
+        out[o + 2] = colors[s + 2];
+        out[o + 3] = colors[s + 3];
+    }
+    return out;
+}
+/** The single group drawn when the colouring is not categorical: total cell density, within the
+ *  selection when there is one. */
+export function totalDensityGroup(selection) {
+    const inSelection = selection.count > 0 ? selection.mask : null;
+    return {
+        name: inSelection ? 'selected cells' : 'all cells',
+        color: SPATIAL_NEUTRAL_HEX,
+        indices: inSelection ? maskToIndices(inSelection) : undefined,
+    };
+}
+/**
+ * The clusters of a categorical column to rasterise, biggest first and capped at
+ * {@link DENSITY_MAX_CLUSTERS}, each with its legend colour — restricted to the selection when
+ * there is one, so "select a region, check the box" answers which clusters live there.
+ */
+export function rankDensityGroups(columnName, column, count, selection) {
+    const inSelection = selection.count > 0 ? selection.mask : null;
+    const colors = resolveCategoryColors(column.meta);
+    const counts = new Uint32Array(column.meta.categories.length);
+    for (let i = 0; i < count; i++) {
+        if (inSelection && !inSelection[i])
+            continue;
+        const code = column.codes[i];
+        if (code !== NO_CATEGORY && code < counts.length)
+            counts[code]++;
+    }
+    const ranked = Array.from(counts, (n, code) => ({ code, n }))
+        .filter((c) => c.n > 0)
+        .sort((a, b) => b.n - a.n)
+        .slice(0, DENSITY_MAX_CLUSTERS);
+    if (counts.filter((c) => c > 0).length > ranked.length) {
+        console.warn(`[napari-js] ${columnName}: drawing the ${ranked.length} largest clusters as density ` +
+            'volumes; more than that stop being separable by eye');
+    }
+    return ranked.map(({ code }) => {
+        const indices = new Uint32Array(counts[code]);
+        let k = 0;
+        for (let i = 0; i < count; i++) {
+            if (inSelection && !inSelection[i])
+                continue;
+            if (column.codes[i] === code)
+                indices[k++] = i;
+        }
+        return {
+            name: column.meta.categories[code],
+            color: colors[code] ?? '#888888',
+            indices: indices.subarray(0, k),
+        };
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-encoding.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-encoding.ts"],"names":[],"mappings":"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","sourcesContent":["import { colormapFromLut } from 'napari-js';\nimport type { Colormap } from 'napari-js';\n\nimport { Rgb } from '../../contracts/colormap-lut';\nimport { CategoricalColumn, NO_CATEGORY } from '../../contracts/spatial-dataset.contract';\nimport { SpatialViewState } from '../../contracts/display-types';\nimport {\n  contrastWindow,\n  encodeCategorical,\n  encodeContinuous,\n  resolveCategoryColors,\n  type RGBA,\n} from '../../spatial/spatial-encoding';\nimport { SpatialSelectionMask, maskToIndices } from '../../spatial/spatial-selection';\n\n/**\n * The spatial scenes' pure colour and grouping math: what the 2D markers, the 3D cloud and the\n * density volumes are coloured with, as functions of the data, the view and a LUT. No viewer, no\n * port, no store (review Appendix B, step 1).\n */\n\n/** Marker radius (image px) for a dataset that declares none — segmented cells often don't. */\nexport const SPATIAL_FALLBACK_RADIUS = 4;\n/** Smallest marker DIAMETER, in slice pixels, over a volume-backed dataset. A cell's real\n *  size is honoured wherever it survives the grid: the ABC atlas serves 5 µm radii on a\n *  40 µm/px template, so drawing them to scale would put every cell a fifth of a pixel wide\n *  and the section would come up empty. The point-size control scales up from this floor. */\nexport const SPATIAL_SLICE_MIN_DIAMETER_PX = 1.5;\n/** Longest side of the gene-map raster, in field pixels. A gene map is a smooth\n *  field read as territory, so it gains nothing from matching a 2 Gpx slide's\n *  resolution — and the estimate costs one pass over this many pixels. */\nexport const GENE_MAP_MAX_SIDE = 512;\n/** Kernel σ in field pixels at smoothing 1: wide enough to read between cells,\n *  tight enough to keep a nucleus-scale structure distinct. */\nexport const GENE_MAP_SIGMA = 2.5;\n/**\n * In-plane coarsening of the 3D gene map's lattice, relative to the reference\n * volume. The field is smooth, so its detail is set by the kernel rather than the\n * raster — and the estimate is a pair of separable blurs, which at the template's\n * full resolution means seconds of work per toggle.\n */\nexport const GENE_MAP_VOLUME_STRIDE = 2;\n/** Clusters drawn as density volumes at once. Past a handful, additive translucent\n *  clouds stop being separable by eye — and each one is a full rasterisation. */\nexport const DENSITY_MAX_CLUSTERS = 6;\n/** How much larger a selected marker is drawn, so a small selection is findable inside a\n *  3.7M-point cloud rather than merely brighter. */\nexport const SPATIAL_SELECTED_SIZE_SCALE = 1.6;\n/** Base marker diameter for the 3D cloud, in SCREEN pixels (the layer's unit). */\nexport const SPATIAL_3D_BASE_SIZE = 3;\n\n/** Colour for observations when nothing is selected to colour by: visible, neutral, and\n *  obviously not encoding anything. */\nexport const SPATIAL_NEUTRAL_COLOR: [number, number, number, number] = [0.35, 0.72, 0.95, 0.9];\n/** {@link SPATIAL_NEUTRAL_COLOR} as a hex colour (alpha dropped), for the encoders and the\n *  density-volume tint. */\nexport const SPATIAL_NEUTRAL_HEX = `#${SPATIAL_NEUTRAL_COLOR.slice(0, 3)\n  .map((c) =>\n    Math.round(c * 255)\n      .toString(16)\n      .padStart(2, '0'),\n  )\n  .join('')}`;\n\n/**\n * Contrast windows memoised per (values array, lo, hi, log). `contrastWindow` sorts every value,\n * and the spatial colouring re-runs it on each opacity, selection or colormap change while the\n * coloured vector itself is unchanged (review SPATIAL-12). Keyed by the vector's identity, so a\n * new column or gene vector is a miss and an old one is collected with its windows.\n */\nexport class ContrastWindowCache {\n  private readonly byVector = new WeakMap<Float32Array, Map<string, [number, number]>>();\n\n  get(\n    values: Float32Array,\n    lo: number,\n    hi: number,\n    log: boolean,\n    compute: () => [number, number],\n  ): [number, number] {\n    let windows = this.byVector.get(values);\n    if (!windows) {\n      windows = new Map();\n      this.byVector.set(values, windows);\n    }\n    const key = `${lo}|${hi}|${log ? 1 : 0}`;\n    let w = windows.get(key);\n    if (!w) {\n      w = compute();\n      windows.set(key, w);\n    }\n    return w;\n  }\n}\n\n/**\n * What the 3D points layer needs to colour a cloud: for continuous data, one scalar per point, a\n * colormap and the window that maps scalars onto it; for categorical data, one packed RGBA per\n * point (`Points3DLayer.colors`, which wins over the scalars).\n */\nexport type Spatial3dEncoding = Spatial3dScalars | Spatial3dColors;\n\n/** A cloud coloured through the colormap: scalars, colormap and window. */\nexport interface Spatial3dScalars {\n  kind: 'scalars';\n  values: Float32Array;\n  colormap: Colormap;\n  contrastLimits: [number, number];\n}\n\n/** A cloud coloured point by point: packed RGBA, 4 floats per point. */\nexport interface Spatial3dColors {\n  kind: 'colors';\n  colors: Float32Array;\n}\n\n/** A one-colour colormap, for the \"nothing to colour by\" state. */\nexport function spatialFlatColormap(): Colormap {\n  const [r, g, b] = SPATIAL_NEUTRAL_COLOR;\n  const rgb: Rgb = [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];\n  // Two identical stops: colormapFromLut needs at least two, and equal ends\n  // make every value resolve to the same colour.\n  return colormapFromLut('spatial-flat', [rgb, rgb]);\n}\n\n/**\n * Category codes → one RGBA per point, for any number of categories.\n *\n * The 2D markers' encoding, with one difference: a point with no category stays opaque (grey),\n * as it always has in the cloud, where the selection dims through the layer's per-point alphas\n * instead. It used to be smuggled through the scalar channel as a stepped 256-entry LUT, which\n * kept at most 95 categories apart (review SPATIAL-11, NAPARI-SVC-18).\n */\nexport function encodeSpatial3dCategorical(codes: Uint16Array, colors: string[]): Spatial3dColors {\n  return { kind: 'colors', colors: encodeCategorical(codes, { colors, mutedOpacity: 1 }) };\n}\n\n/** Continuous values → `lut` over a percentile-clipped window (log1p first when the view's log\n *  scale is on), for the 3D cloud's scalar channel. */\nexport function encodeSpatial3dContinuous(\n  source: Float32Array,\n  view: SpatialViewState,\n  lut: Rgb[],\n  windows: ContrastWindowCache,\n): Spatial3dScalars {\n  const [lo, hi] = view.percentileClip ?? [0.01, 0.99];\n  const log = !!view.logScale;\n  let values = source;\n  if (log) {\n    values = new Float32Array(source.length);\n    for (let i = 0; i < source.length; i++) values[i] = Math.log1p(Math.max(0, source[i]));\n  }\n  // Keyed by the SOURCE vector: the log copy above is new on every call.\n  const [min, max] = windows.get(source, lo, hi, log, () => contrastWindow(values, lo, hi));\n  return {\n    kind: 'scalars',\n    values,\n    colormap: colormapFromLut('spatial-continuous', lut),\n    // A degenerate window would divide by zero in the shader's normalisation.\n    contrastLimits: max > min ? [min, max] : [min, min + 1],\n  };\n}\n\n/** Continuous values → per-point RGBA through `lut` and a clipped window (log scale per the\n *  view), for the 2D markers. */\nexport function encodeSpatialContinuous(\n  values: Float32Array,\n  view: SpatialViewState,\n  lut: Rgb[],\n  windows: ContrastWindowCache,\n  muted: Uint8Array | null = null,\n): Float32Array {\n  const [lo, hi] = view.percentileClip ?? [0.01, 0.99];\n  // The window is taken on the raw values (encodeContinuous applies the log itself).\n  const [min, max] = windows.get(values, lo, hi, false, () => contrastWindow(values, lo, hi));\n  return encodeContinuous(values, {\n    lut,\n    min,\n    max,\n    log: view.logScale,\n    opacity: view.opacity,\n    muted,\n  });\n}\n\n/** Marker colours: packed per-point RGBA (4 floats per point, the shape napari-js copies straight\n *  into its instance buffer), or one RGBA broadcast to every point. */\nexport type PointColors = Float32Array | RGBA;\n\n/** Whether a colour input is one RGBA per point rather than one broadcast RGBA. */\nexport function isPerPoint(colors: PointColors): colors is Float32Array {\n  return colors instanceof Float32Array;\n}\n\n/** Per-point colours for the drawn subset. A broadcast tuple stays broadcast —\n *  it is one colour for every point either way. */\nexport function gatherColors(colors: PointColors, indices?: Uint32Array): PointColors {\n  if (!indices || !isPerPoint(colors)) return colors;\n  const out = new Float32Array(indices.length * 4);\n  for (let i = 0; i < indices.length; i++) {\n    const s = indices[i] * 4;\n    const o = i * 4;\n    out[o] = colors[s];\n    out[o + 1] = colors[s + 1];\n    out[o + 2] = colors[s + 2];\n    out[o + 3] = colors[s + 3];\n  }\n  return out;\n}\n\n/** One density volume's observations: a cluster (or all cells), with its legend colour. */\nexport interface DensityGroup {\n  name: string;\n  color: string;\n  indices?: Uint32Array;\n}\n\n/** The single group drawn when the colouring is not categorical: total cell density, within the\n *  selection when there is one. */\nexport function totalDensityGroup(selection: SpatialSelectionMask): DensityGroup {\n  const inSelection = selection.count > 0 ? selection.mask : null;\n  return {\n    name: inSelection ? 'selected cells' : 'all cells',\n    color: SPATIAL_NEUTRAL_HEX,\n    indices: inSelection ? maskToIndices(inSelection) : undefined,\n  };\n}\n\n/**\n * The clusters of a categorical column to rasterise, biggest first and capped at\n * {@link DENSITY_MAX_CLUSTERS}, each with its legend colour — restricted to the selection when\n * there is one, so \"select a region, check the box\" answers which clusters live there.\n */\nexport function rankDensityGroups(\n  columnName: string,\n  column: CategoricalColumn,\n  count: number,\n  selection: SpatialSelectionMask,\n): DensityGroup[] {\n  const inSelection = selection.count > 0 ? selection.mask : null;\n  const colors = resolveCategoryColors(column.meta);\n  const counts = new Uint32Array(column.meta.categories.length);\n  for (let i = 0; i < count; i++) {\n    if (inSelection && !inSelection[i]) continue;\n    const code = column.codes[i];\n    if (code !== NO_CATEGORY && code < counts.length) counts[code]++;\n  }\n  const ranked = Array.from(counts, (n, code) => ({ code, n }))\n    .filter((c) => c.n > 0)\n    .sort((a, b) => b.n - a.n)\n    .slice(0, DENSITY_MAX_CLUSTERS);\n  if (counts.filter((c) => c > 0).length > ranked.length) {\n    console.warn(\n      `[napari-js] ${columnName}: drawing the ${ranked.length} largest clusters as density ` +\n        'volumes; more than that stop being separable by eye',\n    );\n  }\n  return ranked.map(({ code }) => {\n    const indices = new Uint32Array(counts[code]);\n    let k = 0;\n    for (let i = 0; i < count; i++) {\n      if (inSelection && !inSelection[i]) continue;\n      if (column.codes[i] === code) indices[k++] = i;\n    }\n    return {\n      name: column.meta.categories[code],\n      color: colors[code] ?? '#888888',\n      indices: indices.subarray(0, k),\n    };\n  });\n}\n"]}

package/esm2022/lib/implementations/napari-js/napari-spatial-hover.mjs

@@ -0,0 +1,270 @@
+import { NO_CATEGORY, isCategoricalColumn } from '../../contracts/spatial-dataset.contract';
+import { sameSelection, selectByCategory } from '../../spatial/spatial-selection';
+import { hoverText } from '../../spatial/spatial-hover';
+import { Supersede } from '../../util/supersede';
+import { NapariSpatialTooltip } from './napari-spatial-tooltip';
+/** Movement, in screen pixels, under which a press-release is a CLICK and not a
+ *  drag. An orbit or a pan starts the same way, so the two have to be told
+ *  apart by how far the pointer travelled. */
+const CLICK_SLOP_PX = 4;
+/** Longest press-release still treated as a click. A long press with the mouse
+ *  held still is more likely an interrupted drag than a selection. */
+const CLICK_MAX_MS = 600;
+/** Pointer distance, in screen pixels, that still counts as "on" a marker.
+ *  Generous relative to a 1.5px disc: the cursor is a blunt instrument, and a
+ *  tooltip you have to hunt for is worse than none. */
+export const HOVER_RADIUS_PX = 10;
+/**
+ * Cursor tooltip and click-to-select for the spatial views (review Appendix B, cluster L): hover a
+ * marker, read its class; click it, select the class — the canvas equivalent of the panel's
+ * legend. The tooltip and the click share ONE hit-test, so a click selects the class the tooltip
+ * names (NAPARI-SVC-5).
+ *
+ * A 34-entry legend cannot be read back from a dot — several classes get similar colours, and
+ * matching one to a swatch by eye is exactly the task this removes. It reports whatever the cloud
+ * is CURRENTLY coloured by ({@link resolveSource}), so it and the legend can never say different
+ * things.
+ */
+export class SpatialHover {
+    constructor(host) {
+        this.host = host;
+        this.tooltip = null;
+        /** What the markers are coloured by, resolved once per colour source rather than per hover. */
+        this.hoverSource = null;
+        this.hoverSourceKey = null;
+        /** Latest wins within the scene: the KEY is only committed once a resolution lands, so a
+         *  superseded fetch cannot leave the cache claiming to hold a source it never stored. */
+        this.resolutions = new Supersede();
+        this.pointer = null;
+        this.frame = 0;
+        this.off = [];
+    }
+    /**
+     * Listen on `el` (the plot host) rather than the canvas, so it keeps working over the region
+     * overlay (an SVG covering the canvas, which would otherwise swallow every move), and throttle
+     * to one hit-test per animation frame: a pointermove can fire far more often than that, and
+     * the first test after an orbit re-projects the cloud. None while a button is held: that is an
+     * orbit or a pan moving the camera every frame, and a test per frame re-projected all of a 3.7M
+     * cloud each time (≈150 ms a frame); the first move after the drag pays for one.
+     */
+    install(el) {
+        this.dispose();
+        this.tooltip = new NapariSpatialTooltip(el);
+        const onMove = (e) => {
+            if (e.buttons) {
+                this.pointer = null;
+                this.tooltip?.hide();
+                return;
+            }
+            this.pointer = { clientX: e.clientX, clientY: e.clientY };
+            if (this.frame)
+                return;
+            this.frame = requestAnimationFrame(() => {
+                this.frame = 0;
+                this.update(el);
+            });
+        };
+        const onLeave = () => {
+            this.pointer = null;
+            this.tooltip?.hide();
+        };
+        // A click on a marker selects its class, exactly as clicking that class in the
+        // panel's legend does — including clicking again to clear, so a click is
+        // always reversible. Tracked as down/up rather than bound to `click` so a DRAG
+        // (an orbit in 3D, a pan in 2D) can be told apart from a click: the gesture
+        // has to move less than a few pixels and be over quickly.
+        let down = null;
+        const onDown = (e) => {
+            down = { x: e.clientX, y: e.clientY, t: Date.now() };
+        };
+        const onUp = (e) => {
+            const start = down;
+            down = null;
+            if (!start)
+                return;
+            const moved = Math.hypot(e.clientX - start.x, e.clientY - start.y);
+            if (moved > CLICK_SLOP_PX)
+                return;
+            if (Date.now() - start.t > CLICK_MAX_MS)
+                return;
+            // A region tool owns the pointer while it is active, and placing a polygon
+            // vertex is also a click that does not move.
+            if (this.host.toolActive())
+                return;
+            this.host.inZone(() => this.selectClassAt(e.clientX, e.clientY));
+        };
+        // Outside the zone: a pointermove fires far more often than anything here changes what
+        // Angular renders (the tooltip is plain DOM); a selecting click re-enters it.
+        this.host.outsideZone(() => {
+            el.addEventListener('pointermove', onMove);
+            el.addEventListener('pointerleave', onLeave);
+            el.addEventListener('pointerdown', onDown);
+            el.addEventListener('pointerup', onUp);
+        });
+        this.off.push(() => el.removeEventListener('pointermove', onMove));
+        this.off.push(() => el.removeEventListener('pointerleave', onLeave));
+        this.off.push(() => el.removeEventListener('pointerdown', onDown));
+        this.off.push(() => el.removeEventListener('pointerup', onUp));
+    }
+    /** Hide the tooltip (the navigator is being dragged, say). */
+    hide() {
+        this.tooltip?.hide();
+    }
+    /** Remove the listeners and the tooltip, and drop the colour source. */
+    dispose() {
+        for (const off of this.off)
+            off();
+        this.off = [];
+        if (this.frame)
+            cancelAnimationFrame(this.frame);
+        this.frame = 0;
+        this.pointer = null;
+        this.tooltip?.dispose();
+        this.tooltip = null;
+        this.resolutions.cancel();
+        this.hoverSource = null;
+        this.hoverSourceKey = null;
+    }
+    /**
+     * What the tooltip says, resolved once per colour source rather than per hover.
+     *
+     * Fetched separately from the colouring on purpose: the reference port caches
+     * columns, but a host's need not, and re-fetching a 3.7M-element vector because
+     * the pointer moved would be indefensible either way.
+     */
+    async resolveSource(dataset, view) {
+        const port = this.host.port;
+        const colorBy = view.colorBy;
+        const key = dataset && colorBy ? `${dataset.id}|${colorBy.kind}:${colorBy.name}` : null;
+        if (key === this.hoverSourceKey)
+            return;
+        // The key is committed only where a value is actually stored. Setting it up
+        // front would mean a resolution that loses the race leaves the key claiming a
+        // source that was never stored — and since every later emission carries the
+        // same key, it would short-circuit here forever and the tooltip would stay
+        // silent for the rest of the session.
+        const task = this.resolutions.next();
+        // No colour source means nothing is being said about the cells, so there is no
+        // cluster to name and the tooltip stays silent.
+        if (!key || !dataset || !colorBy || !port) {
+            this.hoverSource = null;
+            this.hoverSourceKey = key;
+            return;
+        }
+        try {
+            if (colorBy.kind === 'column') {
+                const column = await port.getColumn(colorBy.name);
+                if (!task())
+                    return;
+                this.hoverSource = isCategoricalColumn(column)
+                    ? {
+                        kind: 'categorical',
+                        name: colorBy.name,
+                        categories: column.meta.categories,
+                        codes: column.codes,
+                    }
+                    : {
+                        kind: 'continuous',
+                        name: colorBy.name,
+                        values: column.values,
+                        ...(column.meta.unit ? { unit: column.meta.unit } : {}),
+                    };
+                this.hoverSourceKey = key;
+                return;
+            }
+            const values = await port.getFeatureVector(colorBy.name);
+            if (!task())
+                return;
+            this.hoverSource = {
+                kind: 'continuous',
+                name: colorBy.name,
+                values,
+                ...(dataset.features?.unit ? { unit: dataset.features.unit } : {}),
+            };
+            this.hoverSourceKey = key;
+        }
+        catch {
+            if (!task())
+                return;
+            // The tooltip is an extra; a failed fetch must not disturb the render. The
+            // key is left unset so a later emission retries rather than inheriting a
+            // permanent silence.
+            this.hoverSource = null;
+            this.hoverSourceKey = null;
+        }
+    }
+    /** Hit-test the last pointer position and show or hide the tooltip. */
+    update(el) {
+        const tip = this.tooltip;
+        const pointer = this.pointer;
+        const dataset = this.host.dataset();
+        if (!tip || !pointer || !dataset)
+            return;
+        // Transcript markers sit on top of everything, so they are asked first.
+        const tiles = this.host.tiles();
+        if (!this.host.is3d && tiles) {
+            const viewer = this.host.viewer;
+            const world = viewer.canvasToWorld(pointer.clientX, pointer.clientY);
+            const zoom = viewer.camera.zoom;
+            const radius = HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);
+            const lines = world
+                ? tiles.hoverAt(world[0], world[1], radius, (details) => {
+                    const p = this.pointer;
+                    if (!p || !this.tooltip)
+                        return;
+                    const r = el.getBoundingClientRect();
+                    this.tooltip.show(details, p.clientX - r.left, p.clientY - r.top);
+                })
+                : null;
+            if (lines) {
+                const rect = el.getBoundingClientRect();
+                tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);
+                return;
+            }
+        }
+        const hit = this.host.pick(pointer.clientX, pointer.clientY, HOVER_RADIUS_PX);
+        const lines = hoverText(this.hoverSource, hit);
+        if (!lines) {
+            tip.hide();
+            return;
+        }
+        const rect = el.getBoundingClientRect();
+        tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);
+    }
+    /**
+     * Select the class of the marker at a client position — the canvas equivalent of
+     * clicking that class in the panel's legend, and the same selection object, so
+     * the two controls cannot produce different results.
+     *
+     * Clicking a class that is already the whole selection CLEARS it, which is what
+     * the legend does. Compared against the selection itself rather than against a
+     * remembered click, so selecting from the legend and then clicking the same
+     * class on the canvas still toggles.
+     */
+    selectClassAt(clientX, clientY) {
+        const source = this.hoverSource;
+        const store = this.host.selection;
+        const dataset = this.host.dataset();
+        // Only a categorical source has classes to select. A gene is continuous:
+        // there is no set of cells that "is" a value.
+        if (!store || !dataset || source?.kind !== 'categorical')
+            return;
+        // The same pick the tooltip makes — depth-aware in 3D — so a click selects the class the
+        // tooltip names, not an occluded marker's.
+        const hit = this.host.pick(clientX, clientY, HOVER_RADIUS_PX);
+        if (hit < 0)
+            return;
+        const code = source.codes[hit];
+        // A cell the annotation does not cover has no class to select.
+        if (code === undefined || code === NO_CATEGORY)
+            return;
+        const next = selectByCategory(source.codes, code);
+        const current = store.current();
+        if (sameSelection(current, next)) {
+            store.clear();
+            return;
+        }
+        store.set(next);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"napari-spatial-hover.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/napari-js/napari-spatial-hover.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Viewer } from 'napari-js';\n\nimport { SpatialDataPort } from '../../contracts/ports/spatial-data.port';\nimport { NO_CATEGORY, SpatialDataset, isCategoricalColumn } from '../../contracts/spatial-dataset.contract';\nimport { SpatialViewState } from '../../contracts/display-types';\nimport { sameSelection, selectByCategory } from '../../spatial/spatial-selection';\nimport { type HoverSource, hoverText } from '../../spatial/spatial-hover';\nimport { SpatialSelectionStore } from '../../store/spatial-selection.service';\nimport { Supersede } from '../../util/supersede';\nimport { NapariSpatialTooltip } from './napari-spatial-tooltip';\nimport { NapariSpatialTileLayers } from './napari-spatial-tiles';\n\n/** Movement, in screen pixels, under which a press-release is a CLICK and not a\n *  drag. An orbit or a pan starts the same way, so the two have to be told\n *  apart by how far the pointer travelled. */\nconst CLICK_SLOP_PX = 4;\n/** Longest press-release still treated as a click. A long press with the mouse\n *  held still is more likely an interrupted drag than a selection. */\nconst CLICK_MAX_MS = 600;\n/** Pointer distance, in screen pixels, that still counts as \"on\" a marker.\n *  Generous relative to a 1.5px disc: the cursor is a blunt instrument, and a\n *  tooltip you have to hunt for is worse than none. */\nexport const HOVER_RADIUS_PX = 10;\n\n/** What the hover reads from the spatial scene it serves. */\nexport interface SpatialHoverHost {\n  /** The orbit view rather than the 2D view (no transcript markers to ask first). */\n  readonly is3d: boolean;\n  readonly viewer: Viewer;\n  readonly port: SpatialDataPort | null;\n  readonly selection: SpatialSelectionStore | null;\n  /** The dataset on screen, as the spatial subscription last saw it. */\n  dataset(): SpatialDataset | null;\n  /**\n   * The OBSERVATION drawn under a client position, or -1 — `slackPx` screen pixels of slack\n   * around the pointer. The scene owns the pick (napari-js's, on the layer it drew) and maps the\n   * drawn index back to the observation.\n   */\n  pick(clientX: number, clientY: number, slackPx: number): number;\n  /** The 2D transcript markers, which sit on top of everything and are asked first. */\n  tiles(): NapariSpatialTileLayers | null;\n  /** A region tool owns the pointer (placing a polygon vertex is also a still click). */\n  toolActive(): boolean;\n  outsideZone<T>(fn: () => T): T;\n  inZone<T>(fn: () => T): T;\n}\n\n/**\n * Cursor tooltip and click-to-select for the spatial views (review Appendix B, cluster L): hover a\n * marker, read its class; click it, select the class — the canvas equivalent of the panel's\n * legend. The tooltip and the click share ONE hit-test, so a click selects the class the tooltip\n * names (NAPARI-SVC-5).\n *\n * A 34-entry legend cannot be read back from a dot — several classes get similar colours, and\n * matching one to a swatch by eye is exactly the task this removes. It reports whatever the cloud\n * is CURRENTLY coloured by ({@link resolveSource}), so it and the legend can never say different\n * things.\n */\nexport class SpatialHover {\n  private tooltip: NapariSpatialTooltip | null = null;\n  /** What the markers are coloured by, resolved once per colour source rather than per hover. */\n  private hoverSource: HoverSource | null = null;\n  private hoverSourceKey: string | null = null;\n  /** Latest wins within the scene: the KEY is only committed once a resolution lands, so a\n   *  superseded fetch cannot leave the cache claiming to hold a source it never stored. */\n  private readonly resolutions = new Supersede();\n  private pointer: { clientX: number; clientY: number } | null = null;\n  private frame = 0;\n  private off: (() => void)[] = [];\n\n  constructor(private readonly host: SpatialHoverHost) {}\n\n  /**\n   * Listen on `el` (the plot host) rather than the canvas, so it keeps working over the region\n   * overlay (an SVG covering the canvas, which would otherwise swallow every move), and throttle\n   * to one hit-test per animation frame: a pointermove can fire far more often than that, and\n   * the first test after an orbit re-projects the cloud. None while a button is held: that is an\n   * orbit or a pan moving the camera every frame, and a test per frame re-projected all of a 3.7M\n   * cloud each time (≈150 ms a frame); the first move after the drag pays for one.\n   */\n  install(el: HTMLElement): void {\n    this.dispose();\n    this.tooltip = new NapariSpatialTooltip(el);\n\n    const onMove = (e: PointerEvent) => {\n      if (e.buttons) {\n        this.pointer = null;\n        this.tooltip?.hide();\n        return;\n      }\n      this.pointer = { clientX: e.clientX, clientY: e.clientY };\n      if (this.frame) return;\n      this.frame = requestAnimationFrame(() => {\n        this.frame = 0;\n        this.update(el);\n      });\n    };\n    const onLeave = () => {\n      this.pointer = null;\n      this.tooltip?.hide();\n    };\n\n    // A click on a marker selects its class, exactly as clicking that class in the\n    // panel's legend does — including clicking again to clear, so a click is\n    // always reversible. Tracked as down/up rather than bound to `click` so a DRAG\n    // (an orbit in 3D, a pan in 2D) can be told apart from a click: the gesture\n    // has to move less than a few pixels and be over quickly.\n    let down: { x: number; y: number; t: number } | null = null;\n    const onDown = (e: MouseEvent) => {\n      down = { x: e.clientX, y: e.clientY, t: Date.now() };\n    };\n    const onUp = (e: MouseEvent) => {\n      const start = down;\n      down = null;\n      if (!start) return;\n      const moved = Math.hypot(e.clientX - start.x, e.clientY - start.y);\n      if (moved > CLICK_SLOP_PX) return;\n      if (Date.now() - start.t > CLICK_MAX_MS) return;\n      // A region tool owns the pointer while it is active, and placing a polygon\n      // vertex is also a click that does not move.\n      if (this.host.toolActive()) return;\n      this.host.inZone(() => this.selectClassAt(e.clientX, e.clientY));\n    };\n\n    // Outside the zone: a pointermove fires far more often than anything here changes what\n    // Angular renders (the tooltip is plain DOM); a selecting click re-enters it.\n    this.host.outsideZone(() => {\n      el.addEventListener('pointermove', onMove);\n      el.addEventListener('pointerleave', onLeave);\n      el.addEventListener('pointerdown', onDown);\n      el.addEventListener('pointerup', onUp);\n    });\n    this.off.push(() => el.removeEventListener('pointermove', onMove));\n    this.off.push(() => el.removeEventListener('pointerleave', onLeave));\n    this.off.push(() => el.removeEventListener('pointerdown', onDown));\n    this.off.push(() => el.removeEventListener('pointerup', onUp));\n  }\n\n  /** Hide the tooltip (the navigator is being dragged, say). */\n  hide(): void {\n    this.tooltip?.hide();\n  }\n\n  /** Remove the listeners and the tooltip, and drop the colour source. */\n  dispose(): void {\n    for (const off of this.off) off();\n    this.off = [];\n    if (this.frame) cancelAnimationFrame(this.frame);\n    this.frame = 0;\n    this.pointer = null;\n    this.tooltip?.dispose();\n    this.tooltip = null;\n    this.resolutions.cancel();\n    this.hoverSource = null;\n    this.hoverSourceKey = null;\n  }\n\n  /**\n   * What the tooltip says, resolved once per colour source rather than per hover.\n   *\n   * Fetched separately from the colouring on purpose: the reference port caches\n   * columns, but a host's need not, and re-fetching a 3.7M-element vector because\n   * the pointer moved would be indefensible either way.\n   */\n  async resolveSource(dataset: SpatialDataset | null, view: SpatialViewState): Promise<void> {\n    const port = this.host.port;\n    const colorBy = view.colorBy;\n    const key = dataset && colorBy ? `${dataset.id}|${colorBy.kind}:${colorBy.name}` : null;\n    if (key === this.hoverSourceKey) return;\n    // The key is committed only where a value is actually stored. Setting it up\n    // front would mean a resolution that loses the race leaves the key claiming a\n    // source that was never stored — and since every later emission carries the\n    // same key, it would short-circuit here forever and the tooltip would stay\n    // silent for the rest of the session.\n    const task = this.resolutions.next();\n    // No colour source means nothing is being said about the cells, so there is no\n    // cluster to name and the tooltip stays silent.\n    if (!key || !dataset || !colorBy || !port) {\n      this.hoverSource = null;\n      this.hoverSourceKey = key;\n      return;\n    }\n    try {\n      if (colorBy.kind === 'column') {\n        const column = await port.getColumn(colorBy.name);\n        if (!task()) return;\n        this.hoverSource = isCategoricalColumn(column)\n          ? {\n              kind: 'categorical',\n              name: colorBy.name,\n              categories: column.meta.categories,\n              codes: column.codes,\n            }\n          : {\n              kind: 'continuous',\n              name: colorBy.name,\n              values: column.values,\n              ...(column.meta.unit ? { unit: column.meta.unit } : {}),\n            };\n        this.hoverSourceKey = key;\n        return;\n      }\n      const values = await port.getFeatureVector(colorBy.name);\n      if (!task()) return;\n      this.hoverSource = {\n        kind: 'continuous',\n        name: colorBy.name,\n        values,\n        ...(dataset.features?.unit ? { unit: dataset.features.unit } : {}),\n      };\n      this.hoverSourceKey = key;\n    } catch {\n      if (!task()) return;\n      // The tooltip is an extra; a failed fetch must not disturb the render. The\n      // key is left unset so a later emission retries rather than inheriting a\n      // permanent silence.\n      this.hoverSource = null;\n      this.hoverSourceKey = null;\n    }\n  }\n\n  /** Hit-test the last pointer position and show or hide the tooltip. */\n  private update(el: HTMLElement): void {\n    const tip = this.tooltip;\n    const pointer = this.pointer;\n    const dataset = this.host.dataset();\n    if (!tip || !pointer || !dataset) return;\n\n    // Transcript markers sit on top of everything, so they are asked first.\n    const tiles = this.host.tiles();\n    if (!this.host.is3d && tiles) {\n      const viewer = this.host.viewer;\n      const world = viewer.canvasToWorld(pointer.clientX, pointer.clientY);\n      const zoom = viewer.camera.zoom;\n      const radius = HOVER_RADIUS_PX / (zoom > 0 ? zoom : 1);\n      const lines = world\n        ? tiles.hoverAt(world[0], world[1], radius, (details) => {\n            const p = this.pointer;\n            if (!p || !this.tooltip) return;\n            const r = el.getBoundingClientRect();\n            this.tooltip.show(details, p.clientX - r.left, p.clientY - r.top);\n          })\n        : null;\n      if (lines) {\n        const rect = el.getBoundingClientRect();\n        tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);\n        return;\n      }\n    }\n\n    const hit = this.host.pick(pointer.clientX, pointer.clientY, HOVER_RADIUS_PX);\n    const lines = hoverText(this.hoverSource, hit);\n    if (!lines) {\n      tip.hide();\n      return;\n    }\n    const rect = el.getBoundingClientRect();\n    tip.show(lines, pointer.clientX - rect.left, pointer.clientY - rect.top);\n  }\n\n  /**\n   * Select the class of the marker at a client position — the canvas equivalent of\n   * clicking that class in the panel's legend, and the same selection object, so\n   * the two controls cannot produce different results.\n   *\n   * Clicking a class that is already the whole selection CLEARS it, which is what\n   * the legend does. Compared against the selection itself rather than against a\n   * remembered click, so selecting from the legend and then clicking the same\n   * class on the canvas still toggles.\n   */\n  private selectClassAt(clientX: number, clientY: number): void {\n    const source = this.hoverSource;\n    const store = this.host.selection;\n    const dataset = this.host.dataset();\n    // Only a categorical source has classes to select. A gene is continuous:\n    // there is no set of cells that \"is\" a value.\n    if (!store || !dataset || source?.kind !== 'categorical') return;\n\n    // The same pick the tooltip makes — depth-aware in 3D — so a click selects the class the\n    // tooltip names, not an occluded marker's.\n    const hit = this.host.pick(clientX, clientY, HOVER_RADIUS_PX);\n    if (hit < 0) return;\n    const code = source.codes[hit];\n    // A cell the annotation does not cover has no class to select.\n    if (code === undefined || code === NO_CATEGORY) return;\n\n    const next = selectByCategory(source.codes, code);\n    const current = store.current();\n    if (sameSelection(current, next)) {\n      store.clear();\n      return;\n    }\n    store.set(next);\n  }\n}\n"]}