@jax-data-science/sci-image-visualizer 0.3.3 → 0.5.0

package/esm2022/lib/spatial/spatial-encoding.mjs

@@ -0,0 +1,232 @@
+import { buildColormapLut } from '../contracts/colormap-lut';
+import { fallbackColorFor } from '../store/class-color.util';
+import { NO_CATEGORY, } from '../contracts/spatial-dataset.contract';
+/** Neutral grey for observations with no value (NaN, or {@link NO_CATEGORY}). */
+export const MISSING_COLOR = [150, 150, 150];
+/** Default alpha for muted (background / unselected) points — CosMx-style context. */
+export const DEFAULT_MUTED_OPACITY = 0.15;
+/**
+ * Largest number of CATEGORIES whose colours survive the 3D points layer's LUT
+ * intact.
+ *
+ * That layer has no per-point RGBA — it maps a per-point SCALAR through a
+ * 256-entry colormap LUT — so a categorical palette is encoded as one contiguous
+ * block of LUT entries per value. Measured against napari-js, every K in 2..96
+ * blocks round-trips exactly and K=97 is the first that does not: 256 texels
+ * cannot keep more values apart than that.
+ *
+ * One of those 96 blocks is spent on {@link NO_CATEGORY}, which every column can
+ * contain, so what fits is **95 categories** — the number published here. It was
+ * 96 while the encoder rejected at 96, which meant a 96-category column drew flat
+ * with the panel showing no warning: the one failure this ceiling exists to
+ * prevent, arrived at from the other direction.
+ *
+ * Above it the cloud draws FLAT rather than draw a lie, because subtly wrong
+ * category colours under a confident legend is the failure nobody catches.
+ *
+ * A limit of that one layer, and of nothing else: the 2D markers carry per-point
+ * RGBA, and a density volume is a scalar field per cluster. Shared here so the
+ * renderer that enforces it and the panel that explains it cannot drift apart.
+ */
+export const SPATIAL_3D_MAX_CATEGORIES = 95;
+/** LUT blocks the 3D layer can keep apart — {@link SPATIAL_3D_MAX_CATEGORIES}
+ *  plus the one reserved for a missing value. */
+export const SPATIAL_3D_LUT_BLOCKS = SPATIAL_3D_MAX_CATEGORIES + 1;
+/**
+ * Fallback categorical palette. Colour-blind-safe and stable, so a category
+ * without an authored colour still lands somewhere sensible and lands there
+ * every run (`fallbackColorFor` hashes the name — same name, same colour).
+ * Okabe–Ito, plus two greys for long tails.
+ */
+export const DEFAULT_CATEGORICAL_PALETTE = [
+    '#0072B2', '#E69F00', '#009E73', '#CC79A7', '#56B4E9',
+    '#D55E00', '#F0E442', '#000000', '#7F7F7F', '#BFBFBF',
+];
+/** Parse `#rgb` / `#rrggbb` to 0–255 RGB; unparseable input falls back to grey.
+ *  Exported so the 3D LUT path parses palettes exactly as the 2D path does. */
+export function parseHex(hex) {
+    const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec((hex ?? '').trim());
+    if (!m)
+        return MISSING_COLOR;
+    let h = m[1];
+    if (h.length === 3)
+        h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+    return [
+        parseInt(h.slice(0, 2), 16),
+        parseInt(h.slice(2, 4), 16),
+        parseInt(h.slice(4, 6), 16),
+    ];
+}
+function alphaAt(i, opts) {
+    const on = opts.opacity ?? 1;
+    const off = opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY;
+    return opts.muted && opts.muted[i] ? off : on;
+}
+/**
+ * Per-category colours: the column's authored `colors` where present (so the
+ * viewer matches the figures the same analysis produced elsewhere), otherwise
+ * the palette by position, wrapping through a name-hash past its end so a
+ * 40-cluster column still gets stable, distinct-ish colours.
+ */
+export function resolveCategoryColors(meta, palette = DEFAULT_CATEGORICAL_PALETTE) {
+    const authored = meta.colors;
+    return meta.categories.map((name, i) => {
+        const given = authored?.[i];
+        if (given)
+            return given;
+        if (i < palette.length)
+            return palette[i];
+        return fallbackColorFor(name, palette);
+    });
+}
+/** Categorical column → flat per-point RGBA (length `4 * codes.length`). */
+export function encodeCategorical(codes, opts) {
+    const n = codes.length;
+    const out = new Float32Array(n * 4);
+    // Resolve each category once — parsing a hex string per point would dominate.
+    const rgb = opts.colors.map(parseHex);
+    const missing = opts.missingColor ?? MISSING_COLOR;
+    for (let i = 0; i < n; i++) {
+        const code = codes[i];
+        const c = code === NO_CATEGORY || code >= rgb.length ? missing : rgb[code];
+        const o = i * 4;
+        out[o] = c[0] / 255;
+        out[o + 1] = c[1] / 255;
+        out[o + 2] = c[2] / 255;
+        // A point with no category is background by definition — never emphasised.
+        out[o + 3] = code === NO_CATEGORY
+            ? Math.min(alphaAt(i, opts), opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY)
+            : alphaAt(i, opts);
+    }
+    return out;
+}
+/** Continuous column / gene vector → flat per-point RGBA. */
+export function encodeContinuous(values, opts) {
+    const n = values.length;
+    const out = new Float32Array(n * 4);
+    const missing = opts.missingColor ?? MISSING_COLOR;
+    const lut = opts.lut;
+    const lo = opts.log ? Math.log1p(Math.max(0, opts.min)) : opts.min;
+    const hi = opts.log ? Math.log1p(Math.max(0, opts.max)) : opts.max;
+    // A degenerate window (all values equal) maps everything to the LUT midpoint
+    // rather than dividing by zero.
+    const span = hi - lo;
+    for (let i = 0; i < n; i++) {
+        const raw = values[i];
+        const o = i * 4;
+        if (!Number.isFinite(raw)) {
+            out[o] = missing[0] / 255;
+            out[o + 1] = missing[1] / 255;
+            out[o + 2] = missing[2] / 255;
+            out[o + 3] = opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY;
+            continue;
+        }
+        const v = opts.log ? Math.log1p(Math.max(0, raw)) : raw;
+        const t = span > 0 ? (v - lo) / span : 0.5;
+        const idx = Math.max(0, Math.min(255, Math.round(t * 255)));
+        const c = lut[idx] ?? missing;
+        out[o] = c[0] / 255;
+        out[o + 1] = c[1] / 255;
+        out[o + 2] = c[2] / 255;
+        out[o + 3] = alphaAt(i, opts);
+    }
+    return out;
+}
+/**
+ * Contrast window from percentiles of the finite values — the CosMx
+ * "cap outliers at percentiles to improve contrast" rule. `lo`/`hi` are
+ * fractions (0.01 / 0.99 clips the extreme 1% at each end).
+ *
+ * Returns `[0, 1]` for an empty or all-missing vector so callers always get a
+ * usable window.
+ */
+export function contrastWindow(values, lo = 0.01, hi = 0.99) {
+    const finite = [];
+    for (let i = 0; i < values.length; i++) {
+        if (Number.isFinite(values[i]))
+            finite.push(values[i]);
+    }
+    if (finite.length === 0)
+        return [0, 1];
+    finite.sort((a, b) => a - b);
+    const at = (f) => {
+        const k = Math.max(0, Math.min(finite.length - 1, Math.round(f * (finite.length - 1))));
+        return finite[k];
+    };
+    const min = at(Math.max(0, Math.min(1, lo)));
+    const max = at(Math.max(0, Math.min(1, hi)));
+    // A flat or inverted window would divide by zero downstream; widen it.
+    return max > min ? [min, max] : [min, min + 1];
+}
+/**
+ * Marker sizes for the points layer. napari-js `PointsLayer.size` is a
+ * **diameter** in data units while `SpatialObservations.radius` is a radius —
+ * the doubling lives here so no call site has to remember it.
+ *
+ * `fallbackRadius` covers a dataset that declares no radius (segmented cells
+ * often don't); it is in image pixels, like everything else in this space.
+ */
+export function markerDiameters(observations, fallbackRadius = 4) {
+    const r = observations.radius;
+    if (typeof r === 'number')
+        return r * 2;
+    if (r instanceof Float32Array) {
+        const out = new Float32Array(r.length);
+        for (let i = 0; i < r.length; i++)
+            out[i] = r[i] * 2;
+        return out;
+    }
+    return fallbackRadius * 2;
+}
+/**
+ * Adapt a flat RGBA buffer to the `RGBA[]` shape napari-js 0.12.0's
+ * `PointsLayer.faceColor` accepts. One 4-element array per point — the reason
+ * this is a named boundary rather than inlined: it is the one place the model
+ * stops being typed-array shaped, and it is what a future napari-js taking a
+ * `Float32Array` would delete.
+ */
+export function toRgbaTuples(flat) {
+    const n = flat.length / 4;
+    const out = new Array(n);
+    for (let i = 0; i < n; i++) {
+        const o = i * 4;
+        out[i] = [flat[o], flat[o + 1], flat[o + 2], flat[o + 3]];
+    }
+    return out;
+}
+/** Convenience: a 256-entry LUT for a colormap value, falling back to Viridis. */
+export function lutFor(colormapValue, reverse = false) {
+    return buildColormapLut(colormapValue, reverse)
+        ?? buildColormapLut('Viridis', reverse);
+}
+/** True when every entry of a LUT is a neutral grey. Tested on the VALUES rather
+ *  than the colormap's name, so a reversed or renamed grey ramp still counts. */
+export function isGrayscaleLut(lut) {
+    return lut.every(([r, g, b]) => r === g && g === b);
+}
+/**
+ * LUT for a spatial CONTINUOUS encoding — a gene, a numeric column.
+ *
+ * `override` is the caller's explicit choice and wins outright, grey included: a
+ * grey ramp picked FOR the data is a decision, not the image's colormap leaking
+ * in.
+ *
+ * Without one, the display colormap — unless that colormap is grayscale. The
+ * tissue underneath is grayscale, so a grey overlay of a measurement is
+ * indistinguishable from the anatomy it is drawn over, and the reader cannot tell
+ * which channel a bright pixel belongs to. Viridis is then the fallback, which is
+ * what the CosMx guidance prescribes for continuous values anyway.
+ *
+ * Shared by the markers, both gene maps and the panel's colour bar, so none of
+ * them can disagree about what a colour means, whichever way the choice falls.
+ */
+export function spatialContinuousLut(colormapValue, reverse = false, override) {
+    // An inline scale is an array, so emptiness has to be checked as well as
+    // presence: `[]` is truthy and would resolve to the fallback LUT silently.
+    const chosen = Array.isArray(override) ? (override.length ? override : null) : override;
+    if (chosen)
+        return lutFor(chosen, reverse);
+    const lut = lutFor(colormapValue, reverse);
+    return isGrayscaleLut(lut) ? buildColormapLut('Viridis', reverse) : lut;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-encoding.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-encoding.ts"],"names":[],"mappings":"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","sourcesContent":["import { Rgb, buildColormapLut } from '../contracts/colormap-lut';\nimport { fallbackColorFor } from '../store/class-color.util';\nimport {\n  CategoricalColumnMeta, NO_CATEGORY, SpatialObservations,\n} from '../contracts/spatial-dataset.contract';\nimport { ColormapValue } from '../contracts/display-types';\n\n/**\n * Turning spatial-omics columns into per-point visual attributes.\n *\n * Pure — no Angular, no RxJS, no renderer — like `plotly-trace-builders.ts`, so\n * the encodings are testable on their own and shared by any backend that grows\n * a spatial mode.\n *\n * The rules here are the ones the CosMx analysis guidance prescribes, made\n * explicit rather than left to each call site:\n *  - count-like columns read on a **log** scale (linear collapses them against a\n *    few bright outliers);\n *  - contrast windows come from **percentiles**, not min/max, so a single\n *    saturated spot doesn't flatten everything else;\n *  - context is kept by **muting** rather than hiding — background points stay\n *    visible at low alpha so the tissue shape survives.\n *\n * COLOUR REPRESENTATION\n * ---------------------\n * Internally everything is a flat `Float32Array` of `[r,g,b,a, …]` in 0..1 —\n * one allocation for N points, GPU-upload shaped. napari-js 0.12.0's\n * `PointsLayer.faceColor` takes `RGBA[]` (an array of 4-tuples) instead, so\n * {@link toRgbaTuples} adapts at the boundary; when the layer accepts a typed\n * array the adapter goes away and the flat buffer is passed straight through.\n */\n\n/** napari-js per-point colour tuple: r, g, b, a in 0..1. */\nexport type RGBA = [number, number, number, number];\n\n/** Neutral grey for observations with no value (NaN, or {@link NO_CATEGORY}). */\nexport const MISSING_COLOR: Rgb = [150, 150, 150];\n\n/** Default alpha for muted (background / unselected) points — CosMx-style context. */\nexport const DEFAULT_MUTED_OPACITY = 0.15;\n\n/**\n * Largest number of CATEGORIES whose colours survive the 3D points layer's LUT\n * intact.\n *\n * That layer has no per-point RGBA — it maps a per-point SCALAR through a\n * 256-entry colormap LUT — so a categorical palette is encoded as one contiguous\n * block of LUT entries per value. Measured against napari-js, every K in 2..96\n * blocks round-trips exactly and K=97 is the first that does not: 256 texels\n * cannot keep more values apart than that.\n *\n * One of those 96 blocks is spent on {@link NO_CATEGORY}, which every column can\n * contain, so what fits is **95 categories** — the number published here. It was\n * 96 while the encoder rejected at 96, which meant a 96-category column drew flat\n * with the panel showing no warning: the one failure this ceiling exists to\n * prevent, arrived at from the other direction.\n *\n * Above it the cloud draws FLAT rather than draw a lie, because subtly wrong\n * category colours under a confident legend is the failure nobody catches.\n *\n * A limit of that one layer, and of nothing else: the 2D markers carry per-point\n * RGBA, and a density volume is a scalar field per cluster. Shared here so the\n * renderer that enforces it and the panel that explains it cannot drift apart.\n */\nexport const SPATIAL_3D_MAX_CATEGORIES = 95;\n\n/** LUT blocks the 3D layer can keep apart — {@link SPATIAL_3D_MAX_CATEGORIES}\n *  plus the one reserved for a missing value. */\nexport const SPATIAL_3D_LUT_BLOCKS = SPATIAL_3D_MAX_CATEGORIES + 1;\n\n/**\n * Fallback categorical palette. Colour-blind-safe and stable, so a category\n * without an authored colour still lands somewhere sensible and lands there\n * every run (`fallbackColorFor` hashes the name — same name, same colour).\n * Okabe–Ito, plus two greys for long tails.\n */\nexport const DEFAULT_CATEGORICAL_PALETTE: string[] = [\n  '#0072B2', '#E69F00', '#009E73', '#CC79A7', '#56B4E9',\n  '#D55E00', '#F0E442', '#000000', '#7F7F7F', '#BFBFBF',\n];\n\ninterface MuteOptions {\n  /** Alpha for points that are not muted. Default 1. */\n  opacity?: number;\n  /** Alpha for muted points. Default {@link DEFAULT_MUTED_OPACITY}. */\n  mutedOpacity?: number;\n  /** `1` at index i mutes observation i. Absent ⇒ nothing is muted. */\n  muted?: Uint8Array | null;\n}\n\nexport interface CategoricalEncodingOptions extends MuteOptions {\n  /** Per-category `#rrggbb`, index-aligned with the column's categories. */\n  colors: string[];\n  /** Colour for {@link NO_CATEGORY}. Default {@link MISSING_COLOR}. */\n  missingColor?: Rgb;\n}\n\nexport interface ContinuousEncodingOptions extends MuteOptions {\n  /** 256-entry RGB table from {@link buildColormapLut}. */\n  lut: Rgb[];\n  /** Contrast window in VALUE units (pre-log). */\n  min: number;\n  max: number;\n  /** Apply `log1p` to the value and the window before normalising. */\n  log?: boolean;\n  /** Colour for `NaN`. Default {@link MISSING_COLOR}. */\n  missingColor?: Rgb;\n}\n\n/** Parse `#rgb` / `#rrggbb` to 0–255 RGB; unparseable input falls back to grey.\n *  Exported so the 3D LUT path parses palettes exactly as the 2D path does. */\nexport function parseHex(hex: string): Rgb {\n  const m = /^#?([0-9a-f]{3}|[0-9a-f]{6})$/i.exec((hex ?? '').trim());\n  if (!m) return MISSING_COLOR;\n  let h = m[1];\n  if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];\n  return [\n    parseInt(h.slice(0, 2), 16),\n    parseInt(h.slice(2, 4), 16),\n    parseInt(h.slice(4, 6), 16),\n  ];\n}\n\nfunction alphaAt(i: number, opts: MuteOptions): number {\n  const on = opts.opacity ?? 1;\n  const off = opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY;\n  return opts.muted && opts.muted[i] ? off : on;\n}\n\n/**\n * Per-category colours: the column's authored `colors` where present (so the\n * viewer matches the figures the same analysis produced elsewhere), otherwise\n * the palette by position, wrapping through a name-hash past its end so a\n * 40-cluster column still gets stable, distinct-ish colours.\n */\nexport function resolveCategoryColors(\n  meta: CategoricalColumnMeta, palette: string[] = DEFAULT_CATEGORICAL_PALETTE,\n): string[] {\n  const authored = meta.colors;\n  return meta.categories.map((name, i) => {\n    const given = authored?.[i];\n    if (given) return given;\n    if (i < palette.length) return palette[i];\n    return fallbackColorFor(name, palette);\n  });\n}\n\n/** Categorical column → flat per-point RGBA (length `4 * codes.length`). */\nexport function encodeCategorical(\n  codes: Uint16Array, opts: CategoricalEncodingOptions,\n): Float32Array {\n  const n = codes.length;\n  const out = new Float32Array(n * 4);\n  // Resolve each category once — parsing a hex string per point would dominate.\n  const rgb = opts.colors.map(parseHex);\n  const missing = opts.missingColor ?? MISSING_COLOR;\n  for (let i = 0; i < n; i++) {\n    const code = codes[i];\n    const c = code === NO_CATEGORY || code >= rgb.length ? missing : rgb[code];\n    const o = i * 4;\n    out[o] = c[0] / 255;\n    out[o + 1] = c[1] / 255;\n    out[o + 2] = c[2] / 255;\n    // A point with no category is background by definition — never emphasised.\n    out[o + 3] = code === NO_CATEGORY\n      ? Math.min(alphaAt(i, opts), opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY)\n      : alphaAt(i, opts);\n  }\n  return out;\n}\n\n/** Continuous column / gene vector → flat per-point RGBA. */\nexport function encodeContinuous(\n  values: Float32Array, opts: ContinuousEncodingOptions,\n): Float32Array {\n  const n = values.length;\n  const out = new Float32Array(n * 4);\n  const missing = opts.missingColor ?? MISSING_COLOR;\n  const lut = opts.lut;\n  const lo = opts.log ? Math.log1p(Math.max(0, opts.min)) : opts.min;\n  const hi = opts.log ? Math.log1p(Math.max(0, opts.max)) : opts.max;\n  // A degenerate window (all values equal) maps everything to the LUT midpoint\n  // rather than dividing by zero.\n  const span = hi - lo;\n  for (let i = 0; i < n; i++) {\n    const raw = values[i];\n    const o = i * 4;\n    if (!Number.isFinite(raw)) {\n      out[o] = missing[0] / 255;\n      out[o + 1] = missing[1] / 255;\n      out[o + 2] = missing[2] / 255;\n      out[o + 3] = opts.mutedOpacity ?? DEFAULT_MUTED_OPACITY;\n      continue;\n    }\n    const v = opts.log ? Math.log1p(Math.max(0, raw)) : raw;\n    const t = span > 0 ? (v - lo) / span : 0.5;\n    const idx = Math.max(0, Math.min(255, Math.round(t * 255)));\n    const c = lut[idx] ?? missing;\n    out[o] = c[0] / 255;\n    out[o + 1] = c[1] / 255;\n    out[o + 2] = c[2] / 255;\n    out[o + 3] = alphaAt(i, opts);\n  }\n  return out;\n}\n\n/**\n * Contrast window from percentiles of the finite values — the CosMx\n * \"cap outliers at percentiles to improve contrast\" rule. `lo`/`hi` are\n * fractions (0.01 / 0.99 clips the extreme 1% at each end).\n *\n * Returns `[0, 1]` for an empty or all-missing vector so callers always get a\n * usable window.\n */\nexport function contrastWindow(\n  values: Float32Array, lo = 0.01, hi = 0.99,\n): [number, number] {\n  const finite: number[] = [];\n  for (let i = 0; i < values.length; i++) {\n    if (Number.isFinite(values[i])) finite.push(values[i]);\n  }\n  if (finite.length === 0) return [0, 1];\n  finite.sort((a, b) => a - b);\n  const at = (f: number) => {\n    const k = Math.max(0, Math.min(finite.length - 1, Math.round(f * (finite.length - 1))));\n    return finite[k];\n  };\n  const min = at(Math.max(0, Math.min(1, lo)));\n  const max = at(Math.max(0, Math.min(1, hi)));\n  // A flat or inverted window would divide by zero downstream; widen it.\n  return max > min ? [min, max] : [min, min + 1];\n}\n\n/**\n * Marker sizes for the points layer. napari-js `PointsLayer.size` is a\n * **diameter** in data units while `SpatialObservations.radius` is a radius —\n * the doubling lives here so no call site has to remember it.\n *\n * `fallbackRadius` covers a dataset that declares no radius (segmented cells\n * often don't); it is in image pixels, like everything else in this space.\n */\nexport function markerDiameters(\n  observations: SpatialObservations, fallbackRadius = 4,\n): number | Float32Array {\n  const r = observations.radius;\n  if (typeof r === 'number') return r * 2;\n  if (r instanceof Float32Array) {\n    const out = new Float32Array(r.length);\n    for (let i = 0; i < r.length; i++) out[i] = r[i] * 2;\n    return out;\n  }\n  return fallbackRadius * 2;\n}\n\n/**\n * Adapt a flat RGBA buffer to the `RGBA[]` shape napari-js 0.12.0's\n * `PointsLayer.faceColor` accepts. One 4-element array per point — the reason\n * this is a named boundary rather than inlined: it is the one place the model\n * stops being typed-array shaped, and it is what a future napari-js taking a\n * `Float32Array` would delete.\n */\nexport function toRgbaTuples(flat: Float32Array): RGBA[] {\n  const n = flat.length / 4;\n  const out: RGBA[] = new Array(n);\n  for (let i = 0; i < n; i++) {\n    const o = i * 4;\n    out[i] = [flat[o], flat[o + 1], flat[o + 2], flat[o + 3]];\n  }\n  return out;\n}\n\n/** Convenience: a 256-entry LUT for a colormap value, falling back to Viridis. */\nexport function lutFor(colormapValue: unknown, reverse = false): Rgb[] {\n  return buildColormapLut(colormapValue, reverse)\n    ?? buildColormapLut('Viridis', reverse)!;\n}\n\n/** True when every entry of a LUT is a neutral grey. Tested on the VALUES rather\n *  than the colormap's name, so a reversed or renamed grey ramp still counts. */\nexport function isGrayscaleLut(lut: readonly Rgb[]): boolean {\n  return lut.every(([r, g, b]) => r === g && g === b);\n}\n\n/**\n * LUT for a spatial CONTINUOUS encoding — a gene, a numeric column.\n *\n * `override` is the caller's explicit choice and wins outright, grey included: a\n * grey ramp picked FOR the data is a decision, not the image's colormap leaking\n * in.\n *\n * Without one, the display colormap — unless that colormap is grayscale. The\n * tissue underneath is grayscale, so a grey overlay of a measurement is\n * indistinguishable from the anatomy it is drawn over, and the reader cannot tell\n * which channel a bright pixel belongs to. Viridis is then the fallback, which is\n * what the CosMx guidance prescribes for continuous values anyway.\n *\n * Shared by the markers, both gene maps and the panel's colour bar, so none of\n * them can disagree about what a colour means, whichever way the choice falls.\n */\nexport function spatialContinuousLut(\n  colormapValue: unknown, reverse = false, override?: ColormapValue | null,\n): Rgb[] {\n  // An inline scale is an array, so emptiness has to be checked as well as\n  // presence: `[]` is truthy and would resolve to the fallback LUT silently.\n  const chosen = Array.isArray(override) ? (override.length ? override : null) : override;\n  if (chosen) return lutFor(chosen, reverse);\n  const lut = lutFor(colormapValue, reverse);\n  return isGrayscaleLut(lut) ? buildColormapLut('Viridis', reverse)! : lut;\n}\n"]}

package/esm2022/lib/spatial/spatial-expression.mjs

@@ -0,0 +1,257 @@
+import { blurVolumeAxis } from './spatial-density';
+/** In-place separable Gaussian along one axis of a `w × h` field. */
+function blurAxis(field, w, h, axis, sigma) {
+    if (!(sigma > 0.01))
+        return;
+    const radius = Math.max(1, Math.ceil(sigma * 3));
+    const kernel = new Float32Array(radius * 2 + 1);
+    let sum = 0;
+    for (let i = -radius; i <= radius; i++) {
+        const v = Math.exp(-(i * i) / (2 * sigma * sigma));
+        kernel[i + radius] = v;
+        sum += v;
+    }
+    for (let i = 0; i < kernel.length; i++)
+        kernel[i] /= sum;
+    const len = axis === 0 ? w : h;
+    const stride = axis === 0 ? 1 : w;
+    const lines = axis === 0 ? h : w;
+    const line = new Float32Array(len);
+    for (let l = 0; l < lines; l++) {
+        const base = axis === 0 ? l * w : l;
+        for (let i = 0; i < len; i++)
+            line[i] = field[base + i * stride];
+        for (let i = 0; i < len; i++) {
+            let acc = 0;
+            for (let k = -radius; k <= radius; k++) {
+                // Clamped edges: zero-padding would darken the specimen's own boundary,
+                // and the support channel already says where there is no data at all.
+                const j = Math.min(len - 1, Math.max(0, i + k));
+                acc += line[j] * kernel[k + radius];
+            }
+            field[base + i * stride] = acc;
+        }
+    }
+}
+/**
+ * Estimate a gene's expression field over the image the observations sit in.
+ *
+ * Null when nothing lands on the raster — the caller then draws no layer, rather
+ * than an empty one the reader has to interpret.
+ */
+export function expressionField(obs, opts) {
+    const { width: w, height: h, step, sigma, values, indices } = opts;
+    if (w <= 0 || h <= 0)
+        return null;
+    const [sx, sy] = opts.ref?.scale ?? [1, 1];
+    const [tx, ty] = opts.ref?.translate ?? [0, 0];
+    const num = new Float32Array(w * h);
+    const den = new Float32Array(w * h);
+    const n = indices ? indices.length : obs.count;
+    let placed = 0;
+    for (let k = 0; k < n; k++) {
+        const i = indices ? indices[k] : k;
+        const e = values[i];
+        // A NaN is "not measured for this cell", which must not become a zero: it
+        // would pull the local mean down as if the gene were absent there.
+        if (!Number.isFinite(e))
+            continue;
+        const px = Math.floor((obs.x[i] * sx + tx) / step);
+        const py = Math.floor((obs.y[i] * sy + ty) / step);
+        if (px < 0 || px >= w || py < 0 || py >= h)
+            continue;
+        const at = py * w + px;
+        num[at] += e;
+        den[at] += 1;
+        placed++;
+    }
+    if (!placed)
+        return null;
+    for (const axis of [0, 1]) {
+        blurAxis(num, w, h, axis, sigma);
+        blurAxis(den, w, h, axis, sigma);
+    }
+    const mean = new Float32Array(w * h);
+    let lo = Infinity;
+    let hi = -Infinity;
+    const positives = [];
+    for (let i = 0; i < mean.length; i++) {
+        const d = den[i];
+        if (d <= 0)
+            continue;
+        const m = num[i] / d;
+        mean[i] = m;
+        positives.push(d);
+        if (m < lo)
+            lo = m;
+        if (m > hi)
+            hi = m;
+    }
+    if (!Number.isFinite(lo))
+        return null;
+    positives.sort((a, b) => a - b);
+    const supportScale = positives[positives.length >> 1] || 0;
+    return {
+        width: w,
+        height: h,
+        mean,
+        support: den,
+        supportScale,
+        range: hi > lo ? [lo, hi] : [lo, lo + 1],
+    };
+}
+/**
+ * Colour a field into RGBA8 for a `channels: 4` image source.
+ *
+ * Alpha comes from the SUPPORT, ramped to the field's own median support rather
+ * than a constant: a pixel backed by one distant cell is faint, a properly sampled
+ * one is solid, and unmeasured tissue is fully transparent — so the map never
+ * asserts a measurement where there was none. `opacity` scales the whole layer on
+ * top of that.
+ */
+export function colorExpressionField(field, lut, window, opts = {}) {
+    const { mean, support, supportScale } = field;
+    const rgba = new Uint8Array(mean.length * 4);
+    const log = !!opts.log;
+    const opacity = opts.opacity ?? 1;
+    const norm = (v) => (log ? Math.log1p(Math.max(0, v)) : v);
+    const lo = norm(window[0]);
+    const hi = norm(window[1]);
+    const span = hi > lo ? hi - lo : 1;
+    const last = lut.length - 1;
+    const sat = supportScale > 0 ? supportScale : 1;
+    for (let i = 0; i < mean.length; i++) {
+        const d = support[i];
+        if (d <= 0)
+            continue; // unmeasured — leave it transparent
+        const t = Math.min(1, Math.max(0, (norm(mean[i]) - lo) / span));
+        const c = lut[Math.round(t * last)] ?? lut[last];
+        const a = Math.min(1, d / sat) * opacity;
+        const o = i * 4;
+        // Premultiplied, matching the canvas alpha mode the renderer configures.
+        rgba[o] = Math.round(c[0] * a);
+        rgba[o + 1] = Math.round(c[1] * a);
+        rgba[o + 2] = Math.round(c[2] * a);
+        rgba[o + 3] = Math.round(a * 255);
+    }
+    return rgba;
+}
+export function expressionVolume(obs, grid, opts) {
+    const { width: w, height: h, depth: d, voxelSize } = grid;
+    if (w <= 0 || h <= 0 || d <= 0)
+        return null;
+    const num = new Float32Array(w * h * d);
+    const den = new Float32Array(w * h * d);
+    const idx = opts.indices;
+    const n = idx ? idx.length : obs.count;
+    const z = obs.z;
+    let placed = 0;
+    // The imaged range, taken from the observations that were actually included:
+    // the estimate may not reach past the outermost section it was built from.
+    let first = d;
+    let last = -1;
+    for (let k = 0; k < n; k++) {
+        const i = idx ? idx[k] : k;
+        const e = opts.values[i];
+        // Not measured for this cell — must not be read as "the gene is absent here".
+        if (!Number.isFinite(e))
+            continue;
+        const vx = Math.floor(obs.x[i] / voxelSize[0]);
+        const vy = Math.floor(obs.y[i] / voxelSize[1]);
+        const vz = z ? Math.floor(z[i] / voxelSize[2]) : 0;
+        if (vx < 0 || vx >= w || vy < 0 || vy >= h || vz < 0 || vz >= d)
+            continue;
+        const at = (vz * h + vy) * w + vx;
+        num[at] += e;
+        den[at] += 1;
+        placed++;
+        if (vz < first)
+            first = vz;
+        if (vz > last)
+            last = vz;
+    }
+    if (!placed)
+        return null;
+    const sigmaVox = [
+        opts.sigma[0] / voxelSize[0], opts.sigma[1] / voxelSize[1], opts.sigma[2] / voxelSize[2],
+    ];
+    // In-plane always: a section's own gene map is a 2D field, whichever mode this is.
+    for (const axis of [0, 1]) {
+        blurVolumeAxis(num, w, h, d, axis, sigmaVox[axis]);
+        blurVolumeAxis(den, w, h, d, axis, sigmaVox[axis]);
+    }
+    if (opts.interpolate) {
+        blurVolumeAxis(num, w, h, d, 2, sigmaVox[2]);
+        blurVolumeAxis(den, w, h, d, 2, sigmaVox[2]);
+        const plane = w * h;
+        for (let k = 0; k < d; k++) {
+            if (k >= first && k <= last)
+                continue;
+            // The blur leaves a tail past the outermost sections; keeping it would draw
+            // expression where the specimen was never sectioned.
+            num.fill(0, k * plane, (k + 1) * plane);
+            den.fill(0, k * plane, (k + 1) * plane);
+        }
+    }
+    const mean = new Float32Array(num.length);
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (let i = 0; i < mean.length; i++) {
+        const support = den[i];
+        if (support <= 0)
+            continue;
+        const m = num[i] / support;
+        mean[i] = m;
+        if (m < lo)
+            lo = m;
+        if (m > hi)
+            hi = m;
+    }
+    if (!Number.isFinite(lo))
+        return null;
+    return {
+        width: w,
+        height: h,
+        depth: d,
+        mean,
+        support: den,
+        range: hi > lo ? [lo, hi] : [lo, lo + 1],
+    };
+}
+/**
+ * Encode a field into the uint8 scalar a `VolumeLayer` renders, windowed the same
+ * way the 2D map and the markers are so the three cannot disagree.
+ *
+ * `floor` lifts every MEASURED voxel to at least this fraction of full scale, so
+ * that "the gene is not here" can be told from "nobody sectioned here" — the
+ * distinction the 2D map keeps with its separate support channel, which a scalar
+ * volume cannot express because its raymarch takes alpha from the same number it
+ * takes colour from.
+ *
+ * It defaults to OFF, because in a volume that trade does not pay. A ray crosses
+ * tens of measured planes and the DVR composites every one of them, so a floor
+ * large enough to see on a single plane saturates to an opaque shell over the
+ * whole specimen and buries the signal it was meant to contextualise, while one
+ * small enough to stay faint is already invisible per plane. The measured envelope
+ * is better read from the anatomy layer and the observations, which are drawn in
+ * the same scene — and the surrounding density volumes take the same no-floor
+ * approach, so the scene stays internally consistent.
+ */
+export function encodeExpressionVolume(field, window, opts = {}) {
+    const { mean, support } = field;
+    const out = new Uint8Array(mean.length);
+    const log = !!opts.log;
+    const floor = Math.min(1, Math.max(0, opts.floor ?? 0));
+    const norm = (v) => (log ? Math.log1p(Math.max(0, v)) : v);
+    const lo = norm(window[0]);
+    const hi = norm(window[1]);
+    const span = hi > lo ? hi - lo : 1;
+    for (let i = 0; i < mean.length; i++) {
+        if (support[i] <= 0)
+            continue; // unmeasured — zero, so the raymarch skips it
+        const t = Math.min(1, Math.max(0, (norm(mean[i]) - lo) / span));
+        out[i] = Math.round((floor + (1 - floor) * t) * 255);
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-expression.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-expression.ts"],"names":[],"mappings":"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","sourcesContent":["import { SpatialImageRef, SpatialObservations } from '../contracts/spatial-dataset.contract';\nimport { blurVolumeAxis, DensityGrid } from './spatial-density';\n\n/**\n * Turning per-cell expression into a **gene map** — a continuous field over the\n * tissue, drawn under the cells rather than instead of them.\n *\n * A scatter coloured by a gene answers \"which cells express it\"; it does not answer\n * \"where is it expressed\", because the eye cannot integrate thousands of small dots\n * into a territory. A field can be estimated between the cells and read as a\n * region, which is what the CosMx guidance and Spatial-Live's heat layer both do.\n *\n * The quantity is the kernel-weighted **MEAN per cell**, not a sum:\n *\n * ```\n *   mean(p) = Σᵢ w(p, xᵢ)·eᵢ  /  Σᵢ w(p, xᵢ)\n * ```\n *\n * A sum would conflate \"many cells here\" with \"high expression here\" — a dense\n * region would glow whatever its cells were doing, which is the single easiest way\n * to read a gene map wrongly. The denominator is also what makes emptiness\n * expressible: where no cell was measured the mean is *undefined*, not zero, so the\n * caller gets a `support` channel and can draw nothing there instead of drawing the\n * colormap's low end over unmeasured tissue.\n *\n * Pure — no Angular, no GPU, no colour — like `spatial-density.ts`, and tested the\n * same way.\n */\n\nexport interface ExpressionFieldOptions {\n  /** Data→image affine, so the field lands in the displayed image's pixels. */\n  ref?: SpatialImageRef;\n  /** Raster size in field pixels. */\n  width: number;\n  height: number;\n  /** Image pixels per field pixel — the field is coarser than the slide it covers. */\n  step: number;\n  /** Kernel σ in FIELD pixels. */\n  sigma: number;\n  /** One expression value per observation. */\n  values: Float32Array;\n  /** Observations to include; every one when absent (a plane, a selection). */\n  indices?: Uint32Array;\n}\n\nexport interface ExpressionField {\n  width: number;\n  height: number;\n  /** Kernel-weighted mean expression, valid only where `support > 0`. */\n  mean: Float32Array;\n  /** Kernel-weighted cell count per field pixel — 0 where nothing was measured. */\n  support: Float32Array;\n  /** Median positive support: the scale at which a pixel is \"properly sampled\",\n   *  and a data-driven saturation point for an opacity ramp. */\n  supportScale: number;\n  /** Finite range of `mean` over the supported pixels, for a contrast window. */\n  range: [number, number];\n}\n\n/** In-place separable Gaussian along one axis of a `w × h` field. */\nfunction blurAxis(field: Float32Array, w: number, h: number, axis: 0 | 1, sigma: number): void {\n  if (!(sigma > 0.01)) return;\n  const radius = Math.max(1, Math.ceil(sigma * 3));\n  const kernel = new Float32Array(radius * 2 + 1);\n  let sum = 0;\n  for (let i = -radius; i <= radius; i++) {\n    const v = Math.exp(-(i * i) / (2 * sigma * sigma));\n    kernel[i + radius] = v;\n    sum += v;\n  }\n  for (let i = 0; i < kernel.length; i++) kernel[i] /= sum;\n\n  const len = axis === 0 ? w : h;\n  const stride = axis === 0 ? 1 : w;\n  const lines = axis === 0 ? h : w;\n  const line = new Float32Array(len);\n  for (let l = 0; l < lines; l++) {\n    const base = axis === 0 ? l * w : l;\n    for (let i = 0; i < len; i++) line[i] = field[base + i * stride];\n    for (let i = 0; i < len; i++) {\n      let acc = 0;\n      for (let k = -radius; k <= radius; k++) {\n        // Clamped edges: zero-padding would darken the specimen's own boundary,\n        // and the support channel already says where there is no data at all.\n        const j = Math.min(len - 1, Math.max(0, i + k));\n        acc += line[j] * kernel[k + radius];\n      }\n      field[base + i * stride] = acc;\n    }\n  }\n}\n\n/**\n * Estimate a gene's expression field over the image the observations sit in.\n *\n * Null when nothing lands on the raster — the caller then draws no layer, rather\n * than an empty one the reader has to interpret.\n */\nexport function expressionField(\n  obs: SpatialObservations,\n  opts: ExpressionFieldOptions,\n): ExpressionField | null {\n  const { width: w, height: h, step, sigma, values, indices } = opts;\n  if (w <= 0 || h <= 0) return null;\n  const [sx, sy] = opts.ref?.scale ?? [1, 1];\n  const [tx, ty] = opts.ref?.translate ?? [0, 0];\n\n  const num = new Float32Array(w * h);\n  const den = new Float32Array(w * h);\n  const n = indices ? indices.length : obs.count;\n  let placed = 0;\n  for (let k = 0; k < n; k++) {\n    const i = indices ? indices[k] : k;\n    const e = values[i];\n    // A NaN is \"not measured for this cell\", which must not become a zero: it\n    // would pull the local mean down as if the gene were absent there.\n    if (!Number.isFinite(e)) continue;\n    const px = Math.floor((obs.x[i] * sx + tx) / step);\n    const py = Math.floor((obs.y[i] * sy + ty) / step);\n    if (px < 0 || px >= w || py < 0 || py >= h) continue;\n    const at = py * w + px;\n    num[at] += e;\n    den[at] += 1;\n    placed++;\n  }\n  if (!placed) return null;\n\n  for (const axis of [0, 1] as const) {\n    blurAxis(num, w, h, axis, sigma);\n    blurAxis(den, w, h, axis, sigma);\n  }\n\n  const mean = new Float32Array(w * h);\n  let lo = Infinity;\n  let hi = -Infinity;\n  const positives: number[] = [];\n  for (let i = 0; i < mean.length; i++) {\n    const d = den[i];\n    if (d <= 0) continue;\n    const m = num[i] / d;\n    mean[i] = m;\n    positives.push(d);\n    if (m < lo) lo = m;\n    if (m > hi) hi = m;\n  }\n  if (!Number.isFinite(lo)) return null;\n\n  positives.sort((a, b) => a - b);\n  const supportScale = positives[positives.length >> 1] || 0;\n  return {\n    width: w,\n    height: h,\n    mean,\n    support: den,\n    supportScale,\n    range: hi > lo ? [lo, hi] : [lo, lo + 1],\n  };\n}\n\n/**\n * Colour a field into RGBA8 for a `channels: 4` image source.\n *\n * Alpha comes from the SUPPORT, ramped to the field's own median support rather\n * than a constant: a pixel backed by one distant cell is faint, a properly sampled\n * one is solid, and unmeasured tissue is fully transparent — so the map never\n * asserts a measurement where there was none. `opacity` scales the whole layer on\n * top of that.\n */\nexport function colorExpressionField(\n  field: ExpressionField,\n  lut: readonly (readonly [number, number, number])[],\n  window: [number, number],\n  opts: { log?: boolean; opacity?: number } = {},\n): Uint8Array {\n  const { mean, support, supportScale } = field;\n  const rgba = new Uint8Array(mean.length * 4);\n  const log = !!opts.log;\n  const opacity = opts.opacity ?? 1;\n  const norm = (v: number): number => (log ? Math.log1p(Math.max(0, v)) : v);\n  const lo = norm(window[0]);\n  const hi = norm(window[1]);\n  const span = hi > lo ? hi - lo : 1;\n  const last = lut.length - 1;\n  const sat = supportScale > 0 ? supportScale : 1;\n  for (let i = 0; i < mean.length; i++) {\n    const d = support[i];\n    if (d <= 0) continue; // unmeasured — leave it transparent\n    const t = Math.min(1, Math.max(0, (norm(mean[i]) - lo) / span));\n    const c = lut[Math.round(t * last)] ?? lut[last];\n    const a = Math.min(1, d / sat) * opacity;\n    const o = i * 4;\n    // Premultiplied, matching the canvas alpha mode the renderer configures.\n    rgba[o] = Math.round(c[0] * a);\n    rgba[o + 1] = Math.round(c[1] * a);\n    rgba[o + 2] = Math.round(c[2] * a);\n    rgba[o + 3] = Math.round(a * 255);\n  }\n  return rgba;\n}\n\n/**\n * The same estimator in 3D: a gene's expression over a serially sectioned\n * specimen, on a {@link DensityGrid} lattice.\n *\n * Two modes, and the difference between them is the difference between a\n * measurement and an estimate:\n *\n *  - **sheets** (`interpolate` unset) blurs in-plane only, so exactly the z planes\n *    that hold cells are filled and the gaps between sections stay empty. This is\n *    the measured sections, stacked — the 2D gene map of each slide, at its own z.\n *  - **volume** (`interpolate` set) also smooths along z, so the planes between\n *    the sections carry an interpolated value. Smoothing the numerator and the\n *    denominator together is what makes that honest: it is Nadaraya-Watson, so an\n *    unimaged plane inherits its neighbours' MEAN rather than their sum thinned\n *    over a gap nobody sampled. Outside the sampled range the field is zeroed —\n *    \"smoothed between the imaged sections\" must not put expression in front of\n *    the first section or behind the last.\n *\n * Individual cells are still never interpolated: consecutive sections sample\n * different cells, so there is nothing to interpolate along. What is interpolated\n * is a field, which is legitimately defined between the planes.\n */\nexport interface ExpressionVolumeOptions {\n  /** Kernel σ per axis, in the observations' own units. The z term is used only\n   *  when {@link interpolate} is set. */\n  sigma: [number, number, number];\n  /** One expression value per observation. */\n  values: Float32Array;\n  /** Observations to include; every one when absent — one section, or a selection. */\n  indices?: Uint32Array;\n  /** Smooth along z into a continuous estimate rather than leaving the measured\n   *  sheets isolated at their own planes. */\n  interpolate?: boolean;\n}\n\nexport interface ExpressionVolumeField {\n  width: number;\n  height: number;\n  depth: number;\n  /** Kernel-weighted mean expression, valid only where `support > 0`. */\n  mean: Float32Array;\n  /** Kernel-weighted cell count per voxel — 0 where nothing was measured. */\n  support: Float32Array;\n  /** Finite range of `mean` over the supported voxels, for a contrast window. */\n  range: [number, number];\n}\n\nexport function expressionVolume(\n  obs: SpatialObservations,\n  grid: DensityGrid,\n  opts: ExpressionVolumeOptions,\n): ExpressionVolumeField | null {\n  const { width: w, height: h, depth: d, voxelSize } = grid;\n  if (w <= 0 || h <= 0 || d <= 0) return null;\n  const num = new Float32Array(w * h * d);\n  const den = new Float32Array(w * h * d);\n  const idx = opts.indices;\n  const n = idx ? idx.length : obs.count;\n  const z = obs.z;\n  let placed = 0;\n  // The imaged range, taken from the observations that were actually included:\n  // the estimate may not reach past the outermost section it was built from.\n  let first = d;\n  let last = -1;\n\n  for (let k = 0; k < n; k++) {\n    const i = idx ? idx[k] : k;\n    const e = opts.values[i];\n    // Not measured for this cell — must not be read as \"the gene is absent here\".\n    if (!Number.isFinite(e)) continue;\n    const vx = Math.floor(obs.x[i] / voxelSize[0]);\n    const vy = Math.floor(obs.y[i] / voxelSize[1]);\n    const vz = z ? Math.floor(z[i] / voxelSize[2]) : 0;\n    if (vx < 0 || vx >= w || vy < 0 || vy >= h || vz < 0 || vz >= d) continue;\n    const at = (vz * h + vy) * w + vx;\n    num[at] += e;\n    den[at] += 1;\n    placed++;\n    if (vz < first) first = vz;\n    if (vz > last) last = vz;\n  }\n  if (!placed) return null;\n\n  const sigmaVox: [number, number, number] = [\n    opts.sigma[0] / voxelSize[0], opts.sigma[1] / voxelSize[1], opts.sigma[2] / voxelSize[2],\n  ];\n  // In-plane always: a section's own gene map is a 2D field, whichever mode this is.\n  for (const axis of [0, 1] as const) {\n    blurVolumeAxis(num, w, h, d, axis, sigmaVox[axis]);\n    blurVolumeAxis(den, w, h, d, axis, sigmaVox[axis]);\n  }\n  if (opts.interpolate) {\n    blurVolumeAxis(num, w, h, d, 2, sigmaVox[2]);\n    blurVolumeAxis(den, w, h, d, 2, sigmaVox[2]);\n    const plane = w * h;\n    for (let k = 0; k < d; k++) {\n      if (k >= first && k <= last) continue;\n      // The blur leaves a tail past the outermost sections; keeping it would draw\n      // expression where the specimen was never sectioned.\n      num.fill(0, k * plane, (k + 1) * plane);\n      den.fill(0, k * plane, (k + 1) * plane);\n    }\n  }\n\n  const mean = new Float32Array(num.length);\n  let lo = Infinity;\n  let hi = -Infinity;\n  for (let i = 0; i < mean.length; i++) {\n    const support = den[i];\n    if (support <= 0) continue;\n    const m = num[i] / support;\n    mean[i] = m;\n    if (m < lo) lo = m;\n    if (m > hi) hi = m;\n  }\n  if (!Number.isFinite(lo)) return null;\n\n  return {\n    width: w,\n    height: h,\n    depth: d,\n    mean,\n    support: den,\n    range: hi > lo ? [lo, hi] : [lo, lo + 1],\n  };\n}\n\n/**\n * Encode a field into the uint8 scalar a `VolumeLayer` renders, windowed the same\n * way the 2D map and the markers are so the three cannot disagree.\n *\n * `floor` lifts every MEASURED voxel to at least this fraction of full scale, so\n * that \"the gene is not here\" can be told from \"nobody sectioned here\" — the\n * distinction the 2D map keeps with its separate support channel, which a scalar\n * volume cannot express because its raymarch takes alpha from the same number it\n * takes colour from.\n *\n * It defaults to OFF, because in a volume that trade does not pay. A ray crosses\n * tens of measured planes and the DVR composites every one of them, so a floor\n * large enough to see on a single plane saturates to an opaque shell over the\n * whole specimen and buries the signal it was meant to contextualise, while one\n * small enough to stay faint is already invisible per plane. The measured envelope\n * is better read from the anatomy layer and the observations, which are drawn in\n * the same scene — and the surrounding density volumes take the same no-floor\n * approach, so the scene stays internally consistent.\n */\nexport function encodeExpressionVolume(\n  field: ExpressionVolumeField,\n  window: [number, number],\n  opts: { log?: boolean; floor?: number } = {},\n): Uint8Array {\n  const { mean, support } = field;\n  const out = new Uint8Array(mean.length);\n  const log = !!opts.log;\n  const floor = Math.min(1, Math.max(0, opts.floor ?? 0));\n  const norm = (v: number): number => (log ? Math.log1p(Math.max(0, v)) : v);\n  const lo = norm(window[0]);\n  const hi = norm(window[1]);\n  const span = hi > lo ? hi - lo : 1;\n  for (let i = 0; i < mean.length; i++) {\n    if (support[i] <= 0) continue; // unmeasured — zero, so the raymarch skips it\n    const t = Math.min(1, Math.max(0, (norm(mean[i]) - lo) / span));\n    out[i] = Math.round((floor + (1 - floor) * t) * 255);\n  }\n  return out;\n}\n"]}