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

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

@@ -0,0 +1,60 @@
+/**
+ * Framing a 2D scatter on its own coordinates.
+ *
+ * The 2D spatial camera is normally fitted to the IMAGE, because the observations are recorded in
+ * that image's pixel space — frame the image and they come with it. A dataset with no reference
+ * image has coordinates in whatever units its source used: seqFISH's span about 5 x 7. Left with
+ * the previous image's framing, such a dataset lands as a handful of pixels far off-centre, which
+ * looks exactly like nothing having loaded rather than like a framing problem.
+ *
+ * Pure, like `spatial-density.ts` and the rest of this directory — the renderer applies the result.
+ */
+/** Fraction of the viewport the coordinates are fitted into, so the outermost markers are not
+ *  flush against the edge. Matches napari-js's own fit margin. */
+export const SPATIAL_FIT_MARGIN = 0.95;
+/**
+ * Camera centre and zoom that fit `positions` into a `viewportW` x `viewportH` box.
+ *
+ * `positions` is interleaved `[x0, y0, x1, y1, …]`, the layout the points layer takes.
+ *
+ * Null when there is nothing to fit — no points, a viewport with no area, or coordinates that are
+ * entirely non-finite. Null means LEAVE THE CAMERA ALONE: a caller that substituted a default
+ * would move the view for a dataset it cannot frame, which is worse than not moving it.
+ *
+ * A degenerate extent — one point, or every point on a line — yields a centre but no zoom, since
+ * there is no span to divide by. The caller keeps its current zoom and just recentres, rather than
+ * dividing by zero into an infinite one.
+ */
+export function framePositions(positions, viewportW, viewportH, margin = SPATIAL_FIT_MARGIN) {
+    if (positions.length < 2 || viewportW <= 0 || viewportH <= 0)
+        return null;
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    for (let i = 0; i + 1 < positions.length; i += 2) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        // A NaN coordinate is a hole in the data, not a position — including it would
+        // poison the extent and frame on nothing.
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            continue;
+        if (x < xMin)
+            xMin = x;
+        if (x > xMax)
+            xMax = x;
+        if (y < yMin)
+            yMin = y;
+        if (y > yMax)
+            yMax = y;
+    }
+    if (!Number.isFinite(xMin) || !Number.isFinite(yMin))
+        return null;
+    const center = [(xMin + xMax) / 2, (yMin + yMax) / 2];
+    const spanX = xMax - xMin;
+    const spanY = yMax - yMin;
+    if (spanX <= 0 || spanY <= 0)
+        return { center, zoom: null };
+    return { center, zoom: margin * Math.min(viewportW / spanX, viewportH / spanY) };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,185 @@
+import { NO_CATEGORY } from '../contracts/spatial-dataset.contract';
+/** Default floor for a group to earn a column. */
+export const HEATMAP_MIN_CELLS = 3;
+/**
+ * Mean expression of each gene in each group.
+ *
+ * Null when nothing survives — no genes, no groups, or every group filtered
+ * out — so the caller draws no chart rather than an empty grid.
+ */
+export function heatmapMatrix(genes, groups, opts = {}) {
+    const nGroups = groups.categories.length;
+    if (genes.length === 0 || nGroups === 0)
+        return null;
+    const minCells = opts.minCells ?? HEATMAP_MIN_CELLS;
+    const indices = opts.indices;
+    const n = indices ? indices.length : groups.codes.length;
+    // Cells per group, counted once from the codes rather than per gene: the
+    // membership does not depend on which gene is being averaged.
+    const groupCount = new Uint32Array(nGroups);
+    for (let k = 0; k < n; k++) {
+        const i = indices ? indices[k] : k;
+        const code = groups.codes[i];
+        if (code === NO_CATEGORY || code >= nGroups)
+            continue;
+        groupCount[code]++;
+    }
+    const keep = [];
+    for (let g = 0; g < nGroups; g++)
+        if (groupCount[g] >= minCells)
+            keep.push(g);
+    if (keep.length === 0)
+        return null;
+    const rows = genes.map((g) => g.name);
+    const cols = keep.map((g) => groups.categories[g]);
+    const counts = Uint32Array.from(keep, (g) => groupCount[g]);
+    const values = new Float32Array(rows.length * cols.length).fill(NaN);
+    for (let r = 0; r < genes.length; r++) {
+        const gene = genes[r];
+        const sum = new Float64Array(nGroups);
+        const measured = new Uint32Array(nGroups);
+        for (let k = 0; k < n; k++) {
+            const i = indices ? indices[k] : k;
+            const code = groups.codes[i];
+            if (code === NO_CATEGORY || code >= nGroups)
+                continue;
+            const v = gene.values[i];
+            // Not measured for this cell — skipping keeps the mean about the cells
+            // that were actually assayed.
+            if (!Number.isFinite(v))
+                continue;
+            sum[code] += v;
+            measured[code]++;
+        }
+        for (let c = 0; c < keep.length; c++) {
+            const g = keep[c];
+            if (measured[g] === 0)
+                continue; // stays NaN: a gap, not a zero
+            values[r * cols.length + c] = sum[g] / measured[g];
+        }
+    }
+    if (opts.zScore !== false)
+        zScoreRows(values, rows.length, cols.length);
+    // Ranked AFTER scaling, so "strongest signal" means strongest relative to each
+    // gene's own spread rather than to whichever gene has the largest units.
+    let hiddenCols = 0;
+    let outCols = cols;
+    let outValues = values;
+    let outCounts = counts;
+    if (opts.maxCols !== undefined && cols.length > opts.maxCols) {
+        const strength = cols.map((_, c) => {
+            let peak = 0;
+            for (let r = 0; r < rows.length; r++) {
+                const v = Math.abs(values[r * cols.length + c]);
+                if (Number.isFinite(v) && v > peak)
+                    peak = v;
+            }
+            return { c, peak };
+        });
+        // Strongest first, then original order for ties, so the choice is stable.
+        strength.sort((a, b) => (b.peak - a.peak) || (a.c - b.c));
+        const picked = strength.slice(0, opts.maxCols).map((s) => s.c).sort((a, b) => a - b);
+        hiddenCols = cols.length - picked.length;
+        outCols = picked.map((c) => cols[c]);
+        outCounts = Uint32Array.from(picked, (c) => counts[c]);
+        outValues = new Float32Array(rows.length * picked.length);
+        for (let r = 0; r < rows.length; r++) {
+            for (let k = 0; k < picked.length; k++) {
+                outValues[r * picked.length + k] = values[r * cols.length + picked[k]];
+            }
+        }
+    }
+    let lo = Infinity;
+    let hi = -Infinity;
+    for (let i = 0; i < outValues.length; i++) {
+        const v = outValues[i];
+        if (!Number.isFinite(v))
+            continue;
+        if (v < lo)
+            lo = v;
+        if (v > hi)
+            hi = v;
+    }
+    if (!Number.isFinite(lo))
+        return null;
+    return {
+        rows,
+        hiddenCols,
+        cols: outCols,
+        values: outValues,
+        counts: outCounts,
+        range: hi > lo ? [lo, hi] : [lo, lo + 1],
+    };
+}
+/**
+ * Z-score each row in place, over its finite entries only.
+ *
+ * A row with no spread across groups — a gene expressed evenly everywhere, or
+ * measured in only one group — becomes all zeros rather than dividing by zero:
+ * "this gene distinguishes nothing here" is the correct reading, and it is the
+ * one a NaN row would hide.
+ */
+function zScoreRows(values, nRows, nCols) {
+    for (let r = 0; r < nRows; r++) {
+        const base = r * nCols;
+        let sum = 0;
+        let count = 0;
+        for (let c = 0; c < nCols; c++) {
+            const v = values[base + c];
+            if (!Number.isFinite(v))
+                continue;
+            sum += v;
+            count++;
+        }
+        if (count === 0)
+            continue;
+        const mean = sum / count;
+        let variance = 0;
+        for (let c = 0; c < nCols; c++) {
+            const v = values[base + c];
+            if (!Number.isFinite(v))
+                continue;
+            variance += (v - mean) * (v - mean);
+        }
+        // Population SD: these are all the groups there are, not a sample of them.
+        const sd = Math.sqrt(variance / count);
+        for (let c = 0; c < nCols; c++) {
+            const v = values[base + c];
+            if (!Number.isFinite(v))
+                continue;
+            values[base + c] = sd > 0 ? (v - mean) / sd : 0;
+        }
+    }
+}
+/**
+ * Groups standing in for individual cells, for the in-selection view.
+ *
+ * Inside an ROI, "which classes express what" is often the wrong question and
+ * "what is in front of me" is the right one — so each cell becomes its own
+ * column. Capped: past a few hundred columns a heatmap is a texture, not a
+ * readable panel, and the cap is applied by even thinning so the selection is
+ * still represented across its whole extent rather than truncated to its first
+ * cells.
+ *
+ * NOTE: every column here holds exactly ONE cell, so the caller must pass
+ * `minCells: 1` to {@link heatmapMatrix}. The default floor of
+ * {@link HEATMAP_MIN_CELLS} exists to suppress noisy group means and would
+ * filter out every column of this view, returning null.
+ */
+export function cellsAsGroups(indices, observationCount, max = 200) {
+    const step = indices.length > max ? indices.length / max : 1;
+    const take = indices.length > max ? max : indices.length;
+    const picked = new Uint32Array(take);
+    for (let k = 0; k < take; k++)
+        picked[k] = indices[Math.floor(k * step)];
+    // One category per picked cell: codes are dense over the picked order, so the
+    // matrix columns line up with `picked` without a lookup table.
+    const codes = new Uint16Array(observationCount).fill(NO_CATEGORY);
+    const categories = [];
+    for (let k = 0; k < take; k++) {
+        codes[picked[k]] = k;
+        categories.push(`#${picked[k]}`);
+    }
+    return { groups: { codes, categories }, indices: picked };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-heatmap.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-heatmap.ts"],"names":[],"mappings":"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","sourcesContent":["import { NO_CATEGORY } from '../contracts/spatial-dataset.contract';\n\n/**\n * Mean expression per group, for the gene × class heatmap.\n *\n * A scatter coloured by one gene answers \"where is this gene\". It cannot answer\n * \"which classes express which genes\", which is the question a marker panel is\n * actually read for — and the standard object for that is the mean-expression\n * matrix per cluster (scanpy's `matrixplot`/`dotplot`), genes against classes.\n *\n * Deliberately NOT cells × genes at the full dataset: 374k columns is not a\n * heatmap. Cells become columns only inside a selection, where a few thousand\n * of them render and the question changes to \"what is in this region\".\n *\n * Two things this has to get right to be readable:\n *\n *  - A cell with no measurement for a gene (`NaN`) is SKIPPED, not counted as\n *    zero. Counting it would drag a group's mean towards absence for a reason\n *    that has nothing to do with the biology.\n *  - Z-scoring is per GENE, across groups. Without it a gene expressed an order\n *    of magnitude above the others saturates the colour scale and the rest of\n *    the panel reads as uniformly blank — the matrix would show which gene is\n *    loudest rather than which class expresses what.\n *\n * Pure — no Angular, no Plotly, no renderer — like `spatial-density.ts`, and\n * tested the same way.\n */\n\n/** One gene's values, with the name to label its row. */\nexport interface HeatmapGene {\n  name: string;\n  /** One value per observation; `NaN` where the gene was not measured. */\n  values: Float32Array;\n}\n\n/** The columns to aggregate into: a categorical column's categories. */\nexport interface HeatmapGroups {\n  /** Per-observation category index, or {@link NO_CATEGORY}. */\n  codes: Uint16Array;\n  categories: readonly string[];\n}\n\nexport interface HeatmapMatrixOptions {\n  /** Observations to include; every one when absent (an ROI selection). */\n  indices?: Uint32Array;\n  /**\n   * Z-score each gene across the groups, so one loud gene cannot flatten the\n   * panel. On by default — the raw means are only readable when every gene is\n   * on a comparable scale.\n   */\n  zScore?: boolean;\n  /** Drop groups with fewer than this many measured cells. A mean over one or\n   *  two cells is noise presented with the same weight as a real one. */\n  minCells?: number;\n  /**\n   * Keep at most this many columns, chosen by the STRONGEST signal any picked\n   * gene shows in them.\n   *\n   * `subclass` has 338 categories. Drawn in full that is a texture rather than a\n   * panel — every column a couple of pixels wide, every label unreadable — and\n   * the question being asked (\"which groups express my genes\") is answered by\n   * the handful of groups where a gene actually stands out. Ranking by\n   * max |value| across the rows surfaces exactly those; ranking by cell count\n   * would instead surface the biggest groups, which is a different question.\n   *\n   * Unset keeps every column that cleared `minCells`.\n   */\n  maxCols?: number;\n}\n\nexport interface HeatmapMatrix {\n  /** Gene names, one per row, in the order given. */\n  rows: string[];\n  /** Columns dropped by `maxCols`, so the caller can say how many are hidden\n   *  rather than silently showing a subset as if it were everything. */\n  hiddenCols: number;\n  /** Group labels, one per column — only the groups that survived `minCells`. */\n  cols: string[];\n  /**\n   * `rows.length × cols.length`, row-major: `values[r * cols.length + c]`.\n   * `NaN` where a group had nothing measured for that gene, which the caller\n   * draws as a gap rather than as a zero.\n   */\n  values: Float32Array;\n  /** Measured cells behind each column, index-aligned with {@link cols}. */\n  counts: Uint32Array;\n  /** Finite range of `values`, for a symmetric or absolute colour scale. */\n  range: [number, number];\n}\n\n/** Default floor for a group to earn a column. */\nexport const HEATMAP_MIN_CELLS = 3;\n\n/**\n * Mean expression of each gene in each group.\n *\n * Null when nothing survives — no genes, no groups, or every group filtered\n * out — so the caller draws no chart rather than an empty grid.\n */\nexport function heatmapMatrix(\n  genes: readonly HeatmapGene[],\n  groups: HeatmapGroups,\n  opts: HeatmapMatrixOptions = {},\n): HeatmapMatrix | null {\n  const nGroups = groups.categories.length;\n  if (genes.length === 0 || nGroups === 0) return null;\n  const minCells = opts.minCells ?? HEATMAP_MIN_CELLS;\n  const indices = opts.indices;\n  const n = indices ? indices.length : groups.codes.length;\n\n  // Cells per group, counted once from the codes rather than per gene: the\n  // membership does not depend on which gene is being averaged.\n  const groupCount = new Uint32Array(nGroups);\n  for (let k = 0; k < n; k++) {\n    const i = indices ? indices[k] : k;\n    const code = groups.codes[i];\n    if (code === NO_CATEGORY || code >= nGroups) continue;\n    groupCount[code]++;\n  }\n  const keep: number[] = [];\n  for (let g = 0; g < nGroups; g++) if (groupCount[g] >= minCells) keep.push(g);\n  if (keep.length === 0) return null;\n\n  const rows = genes.map((g) => g.name);\n  const cols = keep.map((g) => groups.categories[g]);\n  const counts = Uint32Array.from(keep, (g) => groupCount[g]);\n  const values = new Float32Array(rows.length * cols.length).fill(NaN);\n\n  for (let r = 0; r < genes.length; r++) {\n    const gene = genes[r];\n    const sum = new Float64Array(nGroups);\n    const measured = new Uint32Array(nGroups);\n    for (let k = 0; k < n; k++) {\n      const i = indices ? indices[k] : k;\n      const code = groups.codes[i];\n      if (code === NO_CATEGORY || code >= nGroups) continue;\n      const v = gene.values[i];\n      // Not measured for this cell — skipping keeps the mean about the cells\n      // that were actually assayed.\n      if (!Number.isFinite(v)) continue;\n      sum[code] += v;\n      measured[code]++;\n    }\n    for (let c = 0; c < keep.length; c++) {\n      const g = keep[c];\n      if (measured[g] === 0) continue; // stays NaN: a gap, not a zero\n      values[r * cols.length + c] = sum[g] / measured[g];\n    }\n  }\n\n  if (opts.zScore !== false) zScoreRows(values, rows.length, cols.length);\n\n  // Ranked AFTER scaling, so \"strongest signal\" means strongest relative to each\n  // gene's own spread rather than to whichever gene has the largest units.\n  let hiddenCols = 0;\n  let outCols = cols;\n  let outValues = values;\n  let outCounts = counts;\n  if (opts.maxCols !== undefined && cols.length > opts.maxCols) {\n    const strength = cols.map((_, c) => {\n      let peak = 0;\n      for (let r = 0; r < rows.length; r++) {\n        const v = Math.abs(values[r * cols.length + c]);\n        if (Number.isFinite(v) && v > peak) peak = v;\n      }\n      return { c, peak };\n    });\n    // Strongest first, then original order for ties, so the choice is stable.\n    strength.sort((a, b) => (b.peak - a.peak) || (a.c - b.c));\n    const picked = strength.slice(0, opts.maxCols).map((s) => s.c).sort((a, b) => a - b);\n    hiddenCols = cols.length - picked.length;\n    outCols = picked.map((c) => cols[c]);\n    outCounts = Uint32Array.from(picked, (c) => counts[c]);\n    outValues = new Float32Array(rows.length * picked.length);\n    for (let r = 0; r < rows.length; r++) {\n      for (let k = 0; k < picked.length; k++) {\n        outValues[r * picked.length + k] = values[r * cols.length + picked[k]];\n      }\n    }\n  }\n\n  let lo = Infinity;\n  let hi = -Infinity;\n  for (let i = 0; i < outValues.length; i++) {\n    const v = outValues[i];\n    if (!Number.isFinite(v)) continue;\n    if (v < lo) lo = v;\n    if (v > hi) hi = v;\n  }\n  if (!Number.isFinite(lo)) return null;\n\n  return {\n    rows,\n    hiddenCols,\n    cols: outCols,\n    values: outValues,\n    counts: outCounts,\n    range: hi > lo ? [lo, hi] : [lo, lo + 1],\n  };\n}\n\n/**\n * Z-score each row in place, over its finite entries only.\n *\n * A row with no spread across groups — a gene expressed evenly everywhere, or\n * measured in only one group — becomes all zeros rather than dividing by zero:\n * \"this gene distinguishes nothing here\" is the correct reading, and it is the\n * one a NaN row would hide.\n */\nfunction zScoreRows(values: Float32Array, nRows: number, nCols: number): void {\n  for (let r = 0; r < nRows; r++) {\n    const base = r * nCols;\n    let sum = 0;\n    let count = 0;\n    for (let c = 0; c < nCols; c++) {\n      const v = values[base + c];\n      if (!Number.isFinite(v)) continue;\n      sum += v;\n      count++;\n    }\n    if (count === 0) continue;\n    const mean = sum / count;\n    let variance = 0;\n    for (let c = 0; c < nCols; c++) {\n      const v = values[base + c];\n      if (!Number.isFinite(v)) continue;\n      variance += (v - mean) * (v - mean);\n    }\n    // Population SD: these are all the groups there are, not a sample of them.\n    const sd = Math.sqrt(variance / count);\n    for (let c = 0; c < nCols; c++) {\n      const v = values[base + c];\n      if (!Number.isFinite(v)) continue;\n      values[base + c] = sd > 0 ? (v - mean) / sd : 0;\n    }\n  }\n}\n\n/**\n * Groups standing in for individual cells, for the in-selection view.\n *\n * Inside an ROI, \"which classes express what\" is often the wrong question and\n * \"what is in front of me\" is the right one — so each cell becomes its own\n * column. Capped: past a few hundred columns a heatmap is a texture, not a\n * readable panel, and the cap is applied by even thinning so the selection is\n * still represented across its whole extent rather than truncated to its first\n * cells.\n *\n * NOTE: every column here holds exactly ONE cell, so the caller must pass\n * `minCells: 1` to {@link heatmapMatrix}. The default floor of\n * {@link HEATMAP_MIN_CELLS} exists to suppress noisy group means and would\n * filter out every column of this view, returning null.\n */\nexport function cellsAsGroups(\n  indices: Uint32Array,\n  observationCount: number,\n  max = 200,\n): { groups: HeatmapGroups; indices: Uint32Array } {\n  const step = indices.length > max ? indices.length / max : 1;\n  const take = indices.length > max ? max : indices.length;\n  const picked = new Uint32Array(take);\n  for (let k = 0; k < take; k++) picked[k] = indices[Math.floor(k * step)];\n\n  // One category per picked cell: codes are dense over the picked order, so the\n  // matrix columns line up with `picked` without a lookup table.\n  const codes = new Uint16Array(observationCount).fill(NO_CATEGORY);\n  const categories: string[] = [];\n  for (let k = 0; k < take; k++) {\n    codes[picked[k]] = k;\n    categories.push(`#${picked[k]}`);\n  }\n  return { groups: { codes, categories }, indices: picked };\n}\n"]}

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

@@ -0,0 +1,79 @@
+/**
+ * What is under the cursor, and what to say about it.
+ *
+ * A coloured cloud answers "how is this annotation distributed"; it cannot answer
+ * "which class is THAT" — the legend has 34 entries, several of them similar
+ * colours, and matching a dot to a swatch by eye is exactly the task a tooltip
+ * exists to remove.
+ *
+ * Pure — no DOM, no camera, no data access. The renderer supplies screen
+ * positions (it owns the projection) and the active colour source; everything
+ * here is arithmetic and string formatting, so it is tested directly.
+ */
+/**
+ * Index of the drawn observation nearest `(x, y)` within `maxDist` screen pixels,
+ * or -1.
+ *
+ * `screen` is `[x0, y0, x1, y1, …]` indexed BY OBSERVATION, with NaN for anything
+ * not currently drawn — off screen, behind the eye, or on a hidden section. NaN
+ * fails every comparison, so those are skipped without a special case.
+ *
+ * Ties go to the LATER observation, which is the one drawn on top and therefore
+ * the one the user believes they are pointing at.
+ */
+export function nearestObservation(screen, x, y, maxDist) {
+    const limit = maxDist * maxDist;
+    let best = -1;
+    let bestDist = Infinity;
+    const n = screen.length >> 1;
+    for (let i = 0; i < n; i++) {
+        const dx = screen[i * 2] - x;
+        const dy = screen[i * 2 + 1] - y;
+        const d = dx * dx + dy * dy;
+        // `<=` so a later point at the same distance wins: it is drawn on top.
+        if (d <= bestDist && d <= limit) {
+            bestDist = d;
+            best = i;
+        }
+    }
+    return best;
+}
+/** A number for a tooltip: enough digits to distinguish, few enough to read. */
+function formatValue(v) {
+    if (!Number.isFinite(v))
+        return '—';
+    if (v === 0)
+        return '0';
+    const magnitude = Math.abs(v);
+    if (magnitude >= 1000 || magnitude < 0.01)
+        return v.toExponential(2);
+    return String(Math.round(v * 100) / 100);
+}
+/**
+ * The tooltip's lines for one observation: what it is, then which column said so.
+ *
+ * Null when the source cannot describe this observation — a code outside the
+ * category list, or a value that was never measured. Saying nothing is better
+ * than a tooltip that reads "undefined", and better than inventing a label for a
+ * cell whose annotation is genuinely missing.
+ */
+export function hoverText(source, index) {
+    if (!source || index < 0)
+        return null;
+    if (source.kind === 'categorical') {
+        const code = source.codes?.[index];
+        const label = code === undefined ? undefined : source.categories?.[code];
+        if (label === undefined)
+            return null;
+        return [label, source.name];
+    }
+    // Guarded rather than indexed straight: this runs from a pointermove handler,
+    // so a malformed source would throw on every mouse movement — far worse than a
+    // tooltip that stays quiet.
+    const value = source.values?.[index];
+    if (value === undefined || !Number.isFinite(value))
+        return null;
+    const unit = source.unit ? ` ${source.unit}` : '';
+    return [`${formatValue(value)}${unit}`, source.name];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,96 @@
+/**
+ * The planes a **serially sectioned** dataset was actually imaged at.
+ *
+ * A 3D spatial-omics dataset of this kind is not a cloud that happens to have a z:
+ * it is a stack of thin sections, hundreds of microns apart, each one a separate
+ * slide. Every observation on a given slide shares that slide's registered z
+ * exactly, so the distinct z values ARE the sections — no binning, no tolerance,
+ * and no need for a dataset-specific section-label column.
+ *
+ * That matters for the 3D view, where the cloud reads as a stack of discs and the
+ * discs hide the density volumes drawn between them. Being able to show one
+ * section's cells against the estimated field is how you check the estimate against
+ * the measurement; being able to hide them is how you see the field at all.
+ *
+ * Deliberately NOT a binning of a continuous z (that is
+ * `observationsInSlice`'s job, against a volume's voxel planes). If the z is
+ * continuous rather than sectioned there are no sections to offer, and
+ * {@link sampledSections} says so by returning null rather than inventing some.
+ *
+ * Pure — no Angular, no GPU — like `spatial-density.ts`, and tested the same way.
+ */
+/**
+ * Distinct z values beyond which the data is treated as continuous rather than
+ * sectioned. Serial sectioning runs to tens or low hundreds of slides (53 for the
+ * ABC whole-brain MERFISH atlas); a z that keeps producing new values is a
+ * measurement axis, and a "pick one section" control over it would be a lie.
+ */
+export const MAX_SAMPLED_SECTIONS = 512;
+/**
+ * The dataset's sampled section positions, ascending — or null when it has no z,
+ * no observations, or a z too finely divided to be sections at all.
+ *
+ * Bails out as soon as the distinct count passes `max`, so a continuous z costs one
+ * partial pass rather than a set with one entry per observation.
+ */
+export function sampledSections(obs, max = MAX_SAMPLED_SECTIONS) {
+    const z = obs.z;
+    if (!z || obs.count === 0)
+        return null;
+    const seen = new Set();
+    for (let i = 0; i < obs.count; i++) {
+        const v = z[i];
+        // A non-finite z places an observation on no section; it must not become one.
+        if (!Number.isFinite(v))
+            continue;
+        seen.add(v);
+        if (seen.size > max)
+            return null;
+    }
+    if (seen.size === 0)
+        return null;
+    return Float32Array.from(seen).sort();
+}
+/**
+ * Indices of the observations lying on one sampled section.
+ *
+ * Exact equality on purpose: `z` comes from {@link sampledSections}, which read the
+ * values out of this same array, so the comparison cannot drift. Passing a z that
+ * is not one of the sampled positions yields nothing, which is the honest answer.
+ */
+export function observationsInSection(obs, z) {
+    const zs = obs.z;
+    if (!zs)
+        return new Uint32Array(0);
+    const out = new Uint32Array(obs.count);
+    let n = 0;
+    for (let i = 0; i < obs.count; i++) {
+        if (zs[i] === z)
+            out[n++] = i;
+    }
+    return out.subarray(0, n);
+}
+/** Memoized per observations object; see {@link sectionsOf}. */
+const memo = new WeakMap();
+/**
+ * {@link sampledSections} for a dataset's observations, computed once.
+ *
+ * Both the renderer (which filters the cloud's geometry to one section) and the
+ * control panel (which offers the sections to pick from) need this list, and the
+ * scan reads the z of up to 3.7M observations — so it is memoized on the
+ * observations object itself rather than each caller keeping its own copy keyed by
+ * a dataset id it has to remember to invalidate. Still referentially transparent:
+ * the same observations always give the same sections.
+ *
+ * Default `max` only; a caller wanting a different cap should call
+ * {@link sampledSections} directly and cache it itself.
+ */
+export function sectionsOf(obs) {
+    const hit = memo.get(obs);
+    if (hit !== undefined)
+        return hit;
+    const sections = sampledSections(obs);
+    memo.set(obs, sections);
+    return sections;
+}
+//# sourceMappingURL=data:application/json;base64,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