@jax-data-science/sci-image-visualizer 0.3.2 → 0.4.0

package/esm2022/lib/spatial/embedding-compute.mjs

@@ -0,0 +1,142 @@
+export class EmbeddingComputeRun {
+    /**
+     * `factory` is optional: without one the real worker module is imported on demand.
+     *
+     * Dynamically, and that is not laziness for its own sake — the module holds an
+     * `import.meta.url`, which ts-jest's CommonJS compile rejects outright, so a static
+     * import here would break every spec that touches this file.
+     */
+    constructor(factory) {
+        this.factory = factory;
+        this.worker = null;
+        this.settled = false;
+        /**
+         * Settles a run that is still waiting, set for as long as one is.
+         *
+         * `terminate()` is called from outside — a dataset switch, a component being destroyed —
+         * and killing the worker on its own leaves the promise `run()` returned pending FOR
+         * EVER, because the settlement it was waiting for arrives as a worker message. The
+         * awaiting closure, and everything it captured, is retained with it. So termination
+         * settles the run itself.
+         */
+        this.abandon = null;
+    }
+    /**
+     * Start a run. Resolves with the coordinates, or null if cancelled.
+     *
+     * Rejects only on a real failure. Cancellation is a NULL rather than a rejection: a user
+     * pressing Cancel is not an error, and making callers tell the two apart in a catch
+     * block is how a cancelled run ends up reported as a crash.
+     */
+    async run(request, meta, onProgress) {
+        if (this.worker)
+            throw new Error('a computation is already running');
+        const create = this.factory
+            ?? (await import('./tsne-worker')).createTsneWorker;
+        const worker = create();
+        this.worker = worker;
+        this.settled = false;
+        const { scores, nObs, nDims, dims, perplexity = 30, iterations = 1000, seed = 0, } = request;
+        let backend = null;
+        return new Promise((resolve, reject) => {
+            const finish = (fn) => {
+                if (this.settled)
+                    return;
+                this.settled = true;
+                // Cleared BEFORE terminating: `terminate()` calls it, and this is what keeps the
+                // two from calling each other round in a circle.
+                this.abandon = null;
+                this.terminate();
+                fn();
+            };
+            // An abandoned run resolves NULL, exactly as a cancelled one does. It is the same
+            // event from the caller's side — the answer was no longer wanted — and rejecting
+            // would make a routine dataset switch look like a failed computation.
+            this.abandon = () => finish(() => resolve(null));
+            worker.onmessage = (event) => {
+                const data = event.data ?? {};
+                switch (data.type) {
+                    case 'backend':
+                        backend = data.backend;
+                        onProgress({ fraction: null, backend, message: null });
+                        break;
+                    case 'warning':
+                        onProgress({ fraction: null, backend, message: data.message });
+                        break;
+                    case 'progress':
+                        onProgress({ fraction: data.done / data.total, backend, message: null });
+                        break;
+                    case 'cancelled':
+                        finish(() => resolve(null));
+                        break;
+                    case 'done': {
+                        const flat = new Float32Array(data.embedding);
+                        // Struct of arrays, matching what the port serves, so the chart cannot tell a
+                        // locally-computed embedding from a fetched one.
+                        const planes = [];
+                        for (let d = 0; d < data.dims; d++) {
+                            const plane = new Float32Array(nObs);
+                            for (let i = 0; i < nObs; i++)
+                                plane[i] = flat[i * data.dims + d];
+                            planes.push(plane);
+                        }
+                        finish(() => resolve({
+                            meta: {
+                                ...meta,
+                                derived: true,
+                                params: `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, `
+                                    + `${iterations} iterations, seed ${seed}`,
+                            },
+                            x: planes[0],
+                            y: planes[1],
+                            ...(planes[2] ? { z: planes[2] } : {}),
+                        }));
+                        break;
+                    }
+                    case 'error':
+                        finish(() => reject(new Error(data.message)));
+                        break;
+                    default:
+                        break;
+                }
+            };
+            // A worker that dies takes the promise with it; without this the caller waits for
+            // ever on a progress bar that has stopped moving.
+            worker.onerror = (event) => finish(() => reject(new Error(`embedding worker failed: ${event.message ?? 'unknown'}`)));
+            // Copied, then transferred: the caller keeps its scores, and the worker gets the
+            // buffer without a structured clone.
+            const payload = scores.slice();
+            worker.postMessage({
+                type: 'start',
+                scores: payload.buffer,
+                nObs,
+                nDims,
+                dims,
+                perplexity,
+                iterations,
+                seed,
+            }, [payload.buffer]);
+        });
+    }
+    /** Ask the run to stop. It resolves with null shortly after. */
+    cancel() {
+        this.worker?.postMessage({ type: 'cancel' });
+    }
+    /**
+     * Stop immediately, abandoning any result. Safe to call twice.
+     *
+     * Unlike {@link cancel}, this does not wait for the worker to acknowledge — the run is
+     * settled here, with null, because nothing is left to deliver the answer.
+     */
+    terminate() {
+        const abandon = this.abandon;
+        this.abandon = null;
+        this.worker?.terminate();
+        this.worker = null;
+        abandon?.();
+    }
+    get running() {
+        return this.worker !== null && !this.settled;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"embedding-compute.js","sourceRoot":"","sources":["../../../../src/lib/spatial/embedding-compute.ts"],"names":[],"mappings":"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","sourcesContent":["import { SpatialEmbedding, SpatialEmbeddingMeta } from '../contracts/spatial-dataset.contract';\n\n/**\n * Run a t-SNE in a Web Worker and report progress.\n *\n * The panel offers this for a dataset that publishes no t-SNE — a dropped-in `.h5ad`\n * typically carries one UMAP and nothing else. The server reduces to PCA (it needs the\n * whole expression matrix, which the browser should not download); this takes those\n * scores and embeds them here, where the GPU is.\n *\n * A thin wrapper on purpose: no Angular, no store. It owns one worker and one run, so a\n * component can hold it, show a progress bar, and cancel — and so the whole thing can be\n * tested by substituting a worker.\n */\n\nexport interface ComputeProgress {\n  /** 0..1, or null before the first report — a run starts with kNN and P, not iterations. */\n  fraction: number | null;\n  /** 'webgpu', 'wasm' or 'cpu' once known: it changes what a long wait means. */\n  backend: string | null;\n  message: string | null;\n}\n\nexport interface ComputeRequest {\n  /** PCA scores, row-major `nObs x nDims`. */\n  scores: Float32Array;\n  nObs: number;\n  nDims: number;\n  dims: 2 | 3;\n  perplexity?: number;\n  iterations?: number;\n  seed?: number;\n}\n\n/** Factory, so a test can supply a worker without a bundler. */\nexport type WorkerFactory = () => Worker;\n\nexport class EmbeddingComputeRun {\n  private worker: Worker | null = null;\n\n  private settled = false;\n\n  /**\n   * Settles a run that is still waiting, set for as long as one is.\n   *\n   * `terminate()` is called from outside — a dataset switch, a component being destroyed —\n   * and killing the worker on its own leaves the promise `run()` returned pending FOR\n   * EVER, because the settlement it was waiting for arrives as a worker message. The\n   * awaiting closure, and everything it captured, is retained with it. So termination\n   * settles the run itself.\n   */\n  private abandon: (() => void) | null = null;\n\n  /**\n   * `factory` is optional: without one the real worker module is imported on demand.\n   *\n   * Dynamically, and that is not laziness for its own sake — the module holds an\n   * `import.meta.url`, which ts-jest's CommonJS compile rejects outright, so a static\n   * import here would break every spec that touches this file.\n   */\n  constructor(private readonly factory?: WorkerFactory) {}\n\n  /**\n   * Start a run. Resolves with the coordinates, or null if cancelled.\n   *\n   * Rejects only on a real failure. Cancellation is a NULL rather than a rejection: a user\n   * pressing Cancel is not an error, and making callers tell the two apart in a catch\n   * block is how a cancelled run ends up reported as a crash.\n   */\n  async run(\n    request: ComputeRequest,\n    meta: SpatialEmbeddingMeta,\n    onProgress: (progress: ComputeProgress) => void,\n  ): Promise<SpatialEmbedding | null> {\n    if (this.worker) throw new Error('a computation is already running');\n    const create = this.factory\n      ?? (await import('./tsne-worker')).createTsneWorker;\n    const worker = create();\n    this.worker = worker;\n    this.settled = false;\n\n    const {\n      scores, nObs, nDims, dims,\n      perplexity = 30, iterations = 1000, seed = 0,\n    } = request;\n    let backend: string | null = null;\n\n    return new Promise<SpatialEmbedding | null>((resolve, reject) => {\n      const finish = (fn: () => void) => {\n        if (this.settled) return;\n        this.settled = true;\n        // Cleared BEFORE terminating: `terminate()` calls it, and this is what keeps the\n        // two from calling each other round in a circle.\n        this.abandon = null;\n        this.terminate();\n        fn();\n      };\n      // An abandoned run resolves NULL, exactly as a cancelled one does. It is the same\n      // event from the caller's side — the answer was no longer wanted — and rejecting\n      // would make a routine dataset switch look like a failed computation.\n      this.abandon = () => finish(() => resolve(null));\n\n      worker.onmessage = (event: MessageEvent) => {\n        const data = event.data ?? {};\n        switch (data.type) {\n          case 'backend':\n            backend = data.backend;\n            onProgress({ fraction: null, backend, message: null });\n            break;\n          case 'warning':\n            onProgress({ fraction: null, backend, message: data.message });\n            break;\n          case 'progress':\n            onProgress({ fraction: data.done / data.total, backend, message: null });\n            break;\n          case 'cancelled':\n            finish(() => resolve(null));\n            break;\n          case 'done': {\n            const flat = new Float32Array(data.embedding);\n            // Struct of arrays, matching what the port serves, so the chart cannot tell a\n            // locally-computed embedding from a fetched one.\n            const planes: Float32Array[] = [];\n            for (let d = 0; d < data.dims; d++) {\n              const plane = new Float32Array(nObs);\n              for (let i = 0; i < nObs; i++) plane[i] = flat[i * data.dims + d];\n              planes.push(plane);\n            }\n            finish(() => resolve({\n              meta: {\n                ...meta,\n                derived: true,\n                params: `PCA(${nDims}) then t-SNE, perplexity ${data.perplexity}, `\n                  + `${iterations} iterations, seed ${seed}`,\n              },\n              x: planes[0],\n              y: planes[1],\n              ...(planes[2] ? { z: planes[2] } : {}),\n            }));\n            break;\n          }\n          case 'error':\n            finish(() => reject(new Error(data.message)));\n            break;\n          default:\n            break;\n        }\n      };\n      // A worker that dies takes the promise with it; without this the caller waits for\n      // ever on a progress bar that has stopped moving.\n      worker.onerror = (event) => finish(\n        () => reject(new Error(`embedding worker failed: ${event.message ?? 'unknown'}`)),\n      );\n\n      // Copied, then transferred: the caller keeps its scores, and the worker gets the\n      // buffer without a structured clone.\n      const payload = scores.slice();\n      worker.postMessage(\n        {\n          type: 'start',\n          scores: payload.buffer,\n          nObs,\n          nDims,\n          dims,\n          perplexity,\n          iterations,\n          seed,\n        },\n        [payload.buffer],\n      );\n    });\n  }\n\n  /** Ask the run to stop. It resolves with null shortly after. */\n  cancel(): void {\n    this.worker?.postMessage({ type: 'cancel' });\n  }\n\n  /**\n   * Stop immediately, abandoning any result. Safe to call twice.\n   *\n   * Unlike {@link cancel}, this does not wait for the worker to acknowledge — the run is\n   * settled here, with null, because nothing is left to deliver the answer.\n   */\n  terminate(): void {\n    const abandon = this.abandon;\n    this.abandon = null;\n    this.worker?.terminate();\n    this.worker = null;\n    abandon?.();\n  }\n\n  get running(): boolean {\n    return this.worker !== null && !this.settled;\n  }\n}\n"]}

package/esm2022/lib/spatial/gene-search.mjs

@@ -0,0 +1,77 @@
+/**
+ * Narrowing a gene list to the handful a picker should actually render.
+ *
+ * A targeted panel has a few hundred genes and can simply be listed. A
+ * whole-transcriptome assay has ~18k-31k, and handing that many options to a dropdown
+ * costs a visible freeze on every keystroke — the control rebuilds and re-filters the
+ * whole array, and the browser lays out what the virtual scroller has not yet clipped.
+ * Measured on the Visium H&E bundle: 18,078 names.
+ *
+ * The names themselves are cheap to hold — strings already parsed from the manifest — so
+ * this does not fetch anything. What it caps is how many OPTION OBJECTS are ever
+ * materialised for the view. The rest of the corpus stays a plain array, searched per
+ * keystroke, which is the work a dropdown was doing anyway; the saving is in not asking
+ * a component to render, diff and re-filter thousands of rows it will never show.
+ *
+ * Ranking is PREFIX FIRST, then substring. Typing "Mb" should surface `Mbp` above
+ * `Adam1b`, which a plain `includes` would not do. It deliberately mirrors the example
+ * server's `/spatial/:id/features?q=` (see `lib/spatial.mjs`) so a dataset that inlines
+ * its names and one that does not order their suggestions the same way — the picker must
+ * not appear to rank differently depending on how the data happens to be served.
+ *
+ * Pure — no Angular, no port, no DOM — like `spatial-heatmap.ts`, and tested the same way.
+ */
+/**
+ * How many options a picker will materialise at once.
+ *
+ * Above the virtual-scroll threshold, so a capped list is still scrolled rather than laid
+ * out in full, and far below the point where rebuilding the array is perceptible.
+ */
+export const GENE_OPTIONS_MAX = 500;
+/**
+ * The best `limit` matches for `query`, prefix matches first.
+ *
+ * An empty query returns the head of the list rather than nothing: the dropdown opens
+ * before anything is typed, and an empty menu reads as "no genes" rather than "start
+ * typing". Matching is case-insensitive, because gene symbols are capitalised by
+ * convention and nobody types `Slc17a7` exactly.
+ */
+export function searchGeneNames(names, query, limit = GENE_OPTIONS_MAX) {
+    if (limit <= 0)
+        return [];
+    const q = query.trim().toLowerCase();
+    if (!q)
+        return names.slice(0, limit);
+    const prefix = [];
+    const contains = [];
+    for (const name of names) {
+        const lower = name.toLowerCase();
+        if (lower.startsWith(q)) {
+            prefix.push(name);
+            // Enough prefix matches to fill the list: nothing a substring match could add
+            // would outrank them, so the rest of the corpus cannot change the answer.
+            if (prefix.length >= limit)
+                return prefix;
+        }
+        else if (lower.includes(q) && contains.length < limit) {
+            contains.push(name);
+        }
+    }
+    return [...prefix, ...contains].slice(0, limit);
+}
+/**
+ * The options a picker should show: the best matches, plus anything already chosen.
+ *
+ * A multi-select whose option list is capped must still carry its SELECTED values, or the
+ * control cannot resolve them — the chips lose their labels and, worse, a value absent
+ * from the options can be dropped from the model on the next change. Selections come
+ * first so they stay visible while a search narrows everything else.
+ */
+export function geneOptionsFor(names, query, selected = [], limit = GENE_OPTIONS_MAX) {
+    const matches = searchGeneNames(names, query, limit);
+    if (selected.length === 0)
+        return matches;
+    const seen = new Set(selected);
+    return [...selected, ...matches.filter((n) => !seen.has(n))];
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,224 @@
+/**
+ * The lattice to estimate on.
+ *
+ * A dataset with a registered volume estimates on that volume's own box, so the
+ * field lands exactly on the anatomy it will be drawn inside — `stride` coarsens
+ * it (density is smooth by construction, and an eighth of the voxels is an eighth
+ * of the work) while keeping the physical extent identical, so the two still
+ * align. Without a volume the box comes from the observations' own bounds.
+ */
+export function densityGrid(dataset, stride = 2, targetLongAxis = 128, zStride = stride) {
+    const volume = dataset.volume;
+    if (volume) {
+        const cells = (n, by) => Math.max(1, Math.ceil(n / by));
+        // z can be coarsened less than x/y — a gene map's sheets need one plane per
+        // imaged section, while its in-plane detail is smooth by construction. The
+        // physical extent is unchanged either way, so the box still aligns.
+        const [w, h, d] = [
+            cells(volume.width, stride), cells(volume.height, stride), cells(volume.depth, zStride),
+        ];
+        // Voxel size from the SPAN, not stride x original: `ceil` can add a fraction
+        // of a voxel, and scaling the original size would push the far edge past the
+        // reference volume's.
+        return {
+            width: w,
+            height: h,
+            depth: d,
+            voxelSize: [
+                (volume.width * volume.voxelSize[0]) / w,
+                (volume.height * volume.voxelSize[1]) / h,
+                (volume.depth * volume.voxelSize[2]) / d,
+            ],
+        };
+    }
+    const obs = dataset.observations;
+    if (!obs.z || obs.count === 0)
+        return null;
+    // Measured from the coordinate ORIGIN, not from the cloud's own minimum: the box
+    // then has its near corner at the origin exactly as a volume's does, which is
+    // what lets a renderer centre either one with the same half-box offset. A cloud
+    // sitting far from the origin just gets a coarser grid, not a wrong one.
+    const extent = (v) => {
+        let hi = 0;
+        for (let i = 0; i < obs.count; i++)
+            if (v[i] > hi)
+                hi = v[i];
+        return Math.max(hi, 1);
+    };
+    const [sx, sy, sz] = [extent(obs.x), extent(obs.y), extent(obs.z)];
+    const voxel = Math.max(sx, sy, sz) / targetLongAxis;
+    return {
+        width: Math.max(1, Math.ceil(sx / voxel)),
+        height: Math.max(1, Math.ceil(sy / voxel)),
+        depth: Math.max(1, Math.ceil(sz / voxel)),
+        voxelSize: [voxel, voxel, voxel],
+    };
+}
+/**
+ * In-place separable Gaussian along one axis of a w x h x d field.
+ *
+ * Exported because the gene-map volume estimates a different quantity on the same
+ * lattice with the same kernel (see `spatial-expression.ts`): two copies of a
+ * separable blur would be two chances to smooth the estimate and its normaliser
+ * differently, which is the one thing a Nadaraya-Watson field cannot survive.
+ */
+export function blurVolumeAxis(field, w, h, d, axis, sigmaVox) {
+    if (!(sigmaVox > 0.01))
+        return;
+    const radius = Math.max(1, Math.ceil(sigmaVox * 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 * sigmaVox * sigmaVox));
+        kernel[i + radius] = v;
+        sum += v;
+    }
+    for (let i = 0; i < kernel.length; i++)
+        kernel[i] /= sum;
+    const len = axis === 0 ? w : axis === 1 ? h : d;
+    const stride = axis === 0 ? 1 : axis === 1 ? w : w * h;
+    const lines = axis === 0 ? h * d : axis === 1 ? w * d : w * h;
+    const line = new Float32Array(len);
+    for (let l = 0; l < lines; l++) {
+        // Offset of this line's first element: the two axes that are not being
+        // blurred, laid back out in x-fastest order.
+        let base;
+        if (axis === 0)
+            base = (l % h) * w + Math.floor(l / h) * w * h;
+        else if (axis === 1)
+            base = (l % w) + Math.floor(l / w) * w * h;
+        else
+            base = 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++) {
+                // Clamp at the edges: zero-padding would darken the specimen's own
+                // boundary, which is exactly where a cluster often sits.
+                const j = Math.min(len - 1, Math.max(0, i + k));
+                acc += line[j] * kernel[k + radius];
+            }
+            field[base + i * stride] = acc;
+        }
+    }
+}
+/**
+ * Which z planes of the grid contain any observation at all — the sampled
+ * support, taken from the WHOLE dataset rather than from the subset being
+ * rasterised. A rare cluster is sparse because it is rare; the gaps between
+ * sections are empty because nobody imaged there, and only the second is a
+ * sampling artefact to correct for.
+ */
+function sampledPlanes(obs, grid) {
+    const cover = new Float32Array(grid.depth);
+    const z = obs.z;
+    if (!z)
+        return { cover: cover.fill(1), first: 0, last: grid.depth - 1 };
+    let first = grid.depth;
+    let last = -1;
+    for (let i = 0; i < obs.count; i++) {
+        const k = Math.floor(z[i] / grid.voxelSize[2]);
+        if (k < 0 || k >= grid.depth)
+            continue;
+        cover[k] = 1;
+        if (k < first)
+            first = k;
+        if (k > last)
+            last = k;
+    }
+    return { cover, first, last };
+}
+/** Blur a 1D profile with the same kernel `blurVolumeAxis` uses, so the correction and
+ *  the field are smoothed identically. */
+function blur1d(profile, sigmaVox) {
+    const out = profile.slice();
+    blurVolumeAxis(out, 1, 1, out.length, 2, sigmaVox);
+    return out;
+}
+/**
+ * Rasterise observations into a uint8 density field on `grid`.
+ *
+ * Returned as uint8 scaled to its own maximum: a `VolumeLayer` renders 0..255, and
+ * the absolute cell count per voxel is not the readable quantity anyway — where
+ * the cluster is dense RELATIVE to itself is. Null when nothing lands on the grid,
+ * so the caller draws no layer rather than an empty box.
+ */
+export function rasterizeDensity(obs, grid, opts) {
+    const { width: w, height: h, depth: d, voxelSize } = grid;
+    const field = new Float32Array(w * h * d);
+    const idx = opts.indices;
+    const n = idx ? idx.length : obs.count;
+    const z = obs.z;
+    let placed = 0;
+    for (let k = 0; k < n; k++) {
+        const i = idx ? idx[k] : k;
+        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;
+        field[(vz * h + vy) * w + vx] += 1;
+        placed++;
+    }
+    if (!placed)
+        return null;
+    const sigmaVox = [
+        opts.sigma[0] / voxelSize[0], opts.sigma[1] / voxelSize[1], opts.sigma[2] / voxelSize[2],
+    ];
+    blurVolumeAxis(field, w, h, d, 0, sigmaVox[0]);
+    blurVolumeAxis(field, w, h, d, 1, sigmaVox[1]);
+    blurVolumeAxis(field, w, h, d, 2, sigmaVox[2]);
+    // Coverage correction, per plane: the same kernel over the sampled support says
+    // how much of each plane's neighbourhood was actually imaged.
+    const { cover, first, last } = sampledPlanes(obs, grid);
+    const smoothedCover = blur1d(cover, sigmaVox[2]);
+    let max = 0;
+    const plane = w * h;
+    for (let k = 0; k < d; k++) {
+        // OUTSIDE the sampled range there is nothing to interpolate between, only
+        // one side to extrapolate from — so the field is zeroed rather than scaled.
+        // The blur leaves a positive tail past the first and last imaged planes, and
+        // keeping it would put estimated cells in front of the specimen's first
+        // section and behind its last, which is exactly what "smoothed BETWEEN the
+        // imaged sections" promises not to do.
+        if (k < first || k > last) {
+            field.fill(0, k * plane, (k + 1) * plane);
+            continue;
+        }
+        // Inside it, the correction BRIDGES gaps. Capping the amplification at 2x
+        // (coverage floored at 0.5) lifts a plane sitting between two imaged sections
+        // — where a bandwidth spanning one gap leaves coverage around a half —
+        // without inflating a trace of smoothing leakage into a signal.
+        const scale = 1 / Math.max(smoothedCover[k], 0.5);
+        for (let i = k * plane; i < (k + 1) * plane; i++) {
+            const v = field[i] * scale;
+            field[i] = v;
+            if (v > max)
+                max = v;
+        }
+    }
+    if (!(max > 0))
+        return null;
+    const out = new Uint8Array(field.length);
+    for (let i = 0; i < field.length; i++)
+        out[i] = Math.round((field[i] / max) * 255);
+    return out;
+}
+/**
+ * Default kernel for a grid: in-plane tight, along z at least the section
+ * spacing.
+ *
+ * The z term is the load-bearing one — 1.5 voxels of a grid whose depth voxel IS
+ * the section spacing puts σ just above one section gap, which is the smallest
+ * bandwidth that can bridge one without leaving a disc per plane. `smoothing`
+ * scales all three for the user control.
+ */
+export function defaultSigma(grid, smoothing = 1) {
+    return [
+        grid.voxelSize[0] * 1.5 * smoothing,
+        grid.voxelSize[1] * 1.5 * smoothing,
+        grid.voxelSize[2] * 1.5 * smoothing,
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-density.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-density.ts"],"names":[],"mappings":"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","sourcesContent":["import { SpatialDataset, SpatialObservations } from '../contracts/spatial-dataset.contract';\n\n/**\n * Turning a cell cloud into a density field — the honest way to render a cluster\n * in 3D when the sections it was measured on are hundreds of microns apart.\n *\n * Individual cells CANNOT be interpolated between sections: consecutive sections\n * sample entirely different cells, so there is no correspondence to interpolate\n * along, and inventing positions would fabricate observations indistinguishable\n * from measured ones. A density field is a different object: a continuous\n * estimate, legitimately defined between the planes that were imaged, and it\n * renders as a translucent cloud rather than as dots, so it reads as an estimate.\n *\n * Two things make the estimate honest rather than decorative, and both are\n * implemented here:\n *  - the kernel is **anisotropic**, with a z bandwidth at least the section\n *    spacing. An isotropic kernel leaves one disc per section — a sampling\n *    artefact that looks like biology;\n *  - the field is **coverage-normalised** along z (Nadaraya–Watson): unsampled\n *    planes would otherwise read as genuinely empty tissue rather than as tissue\n *    nobody imaged.\n */\n\n/** The voxel lattice a density field is estimated on. */\nexport interface DensityGrid {\n  width: number;\n  height: number;\n  depth: number;\n  /** World size of one voxel per axis, in the observations' units. */\n  voxelSize: [number, number, number];\n}\n\nexport interface DensityOptions {\n  /** Kernel σ per axis, in the observations' units. */\n  sigma: [number, number, number];\n  /** Observations to include. Every observation when absent. */\n  indices?: Uint32Array;\n}\n\n/**\n * The lattice to estimate on.\n *\n * A dataset with a registered volume estimates on that volume's own box, so the\n * field lands exactly on the anatomy it will be drawn inside — `stride` coarsens\n * it (density is smooth by construction, and an eighth of the voxels is an eighth\n * of the work) while keeping the physical extent identical, so the two still\n * align. Without a volume the box comes from the observations' own bounds.\n */\nexport function densityGrid(\n  dataset: SpatialDataset, stride = 2, targetLongAxis = 128, zStride = stride,\n): DensityGrid | null {\n  const volume = dataset.volume;\n  if (volume) {\n    const cells = (n: number, by: number) => Math.max(1, Math.ceil(n / by));\n    // z can be coarsened less than x/y — a gene map's sheets need one plane per\n    // imaged section, while its in-plane detail is smooth by construction. The\n    // physical extent is unchanged either way, so the box still aligns.\n    const [w, h, d] = [\n      cells(volume.width, stride), cells(volume.height, stride), cells(volume.depth, zStride),\n    ];\n    // Voxel size from the SPAN, not stride x original: `ceil` can add a fraction\n    // of a voxel, and scaling the original size would push the far edge past the\n    // reference volume's.\n    return {\n      width: w,\n      height: h,\n      depth: d,\n      voxelSize: [\n        (volume.width * volume.voxelSize[0]) / w,\n        (volume.height * volume.voxelSize[1]) / h,\n        (volume.depth * volume.voxelSize[2]) / d,\n      ],\n    };\n  }\n\n  const obs = dataset.observations;\n  if (!obs.z || obs.count === 0) return null;\n  // Measured from the coordinate ORIGIN, not from the cloud's own minimum: the box\n  // then has its near corner at the origin exactly as a volume's does, which is\n  // what lets a renderer centre either one with the same half-box offset. A cloud\n  // sitting far from the origin just gets a coarser grid, not a wrong one.\n  const extent = (v: Float32Array) => {\n    let hi = 0;\n    for (let i = 0; i < obs.count; i++) if (v[i] > hi) hi = v[i];\n    return Math.max(hi, 1);\n  };\n  const [sx, sy, sz] = [extent(obs.x), extent(obs.y), extent(obs.z)];\n  const voxel = Math.max(sx, sy, sz) / targetLongAxis;\n  return {\n    width: Math.max(1, Math.ceil(sx / voxel)),\n    height: Math.max(1, Math.ceil(sy / voxel)),\n    depth: Math.max(1, Math.ceil(sz / voxel)),\n    voxelSize: [voxel, voxel, voxel],\n  };\n}\n\n/**\n * In-place separable Gaussian along one axis of a w x h x d field.\n *\n * Exported because the gene-map volume estimates a different quantity on the same\n * lattice with the same kernel (see `spatial-expression.ts`): two copies of a\n * separable blur would be two chances to smooth the estimate and its normaliser\n * differently, which is the one thing a Nadaraya-Watson field cannot survive.\n */\nexport function blurVolumeAxis(\n  field: Float32Array, w: number, h: number, d: number, axis: 0 | 1 | 2, sigmaVox: number,\n): void {\n  if (!(sigmaVox > 0.01)) return;\n  const radius = Math.max(1, Math.ceil(sigmaVox * 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 * sigmaVox * sigmaVox));\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 : axis === 1 ? h : d;\n  const stride = axis === 0 ? 1 : axis === 1 ? w : w * h;\n  const lines = axis === 0 ? h * d : axis === 1 ? w * d : w * h;\n  const line = new Float32Array(len);\n  for (let l = 0; l < lines; l++) {\n    // Offset of this line's first element: the two axes that are not being\n    // blurred, laid back out in x-fastest order.\n    let base: number;\n    if (axis === 0) base = (l % h) * w + Math.floor(l / h) * w * h;\n    else if (axis === 1) base = (l % w) + Math.floor(l / w) * w * h;\n    else base = 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        // Clamp at the edges: zero-padding would darken the specimen's own\n        // boundary, which is exactly where a cluster often sits.\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 * Which z planes of the grid contain any observation at all — the sampled\n * support, taken from the WHOLE dataset rather than from the subset being\n * rasterised. A rare cluster is sparse because it is rare; the gaps between\n * sections are empty because nobody imaged there, and only the second is a\n * sampling artefact to correct for.\n */\nfunction sampledPlanes(\n  obs: SpatialObservations, grid: DensityGrid,\n): { cover: Float32Array; first: number; last: number } {\n  const cover = new Float32Array(grid.depth);\n  const z = obs.z;\n  if (!z) return { cover: cover.fill(1), first: 0, last: grid.depth - 1 };\n  let first = grid.depth;\n  let last = -1;\n  for (let i = 0; i < obs.count; i++) {\n    const k = Math.floor(z[i] / grid.voxelSize[2]);\n    if (k < 0 || k >= grid.depth) continue;\n    cover[k] = 1;\n    if (k < first) first = k;\n    if (k > last) last = k;\n  }\n  return { cover, first, last };\n}\n\n/** Blur a 1D profile with the same kernel `blurVolumeAxis` uses, so the correction and\n *  the field are smoothed identically. */\nfunction blur1d(profile: Float32Array, sigmaVox: number): Float32Array {\n  const out = profile.slice();\n  blurVolumeAxis(out, 1, 1, out.length, 2, sigmaVox);\n  return out;\n}\n\n/**\n * Rasterise observations into a uint8 density field on `grid`.\n *\n * Returned as uint8 scaled to its own maximum: a `VolumeLayer` renders 0..255, and\n * the absolute cell count per voxel is not the readable quantity anyway — where\n * the cluster is dense RELATIVE to itself is. Null when nothing lands on the grid,\n * so the caller draws no layer rather than an empty box.\n */\nexport function rasterizeDensity(\n  obs: SpatialObservations, grid: DensityGrid, opts: DensityOptions,\n): Uint8Array | null {\n  const { width: w, height: h, depth: d, voxelSize } = grid;\n  const field = 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  for (let k = 0; k < n; k++) {\n    const i = idx ? idx[k] : k;\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    field[(vz * h + vy) * w + vx] += 1;\n    placed++;\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  blurVolumeAxis(field, w, h, d, 0, sigmaVox[0]);\n  blurVolumeAxis(field, w, h, d, 1, sigmaVox[1]);\n  blurVolumeAxis(field, w, h, d, 2, sigmaVox[2]);\n\n  // Coverage correction, per plane: the same kernel over the sampled support says\n  // how much of each plane's neighbourhood was actually imaged.\n  const { cover, first, last } = sampledPlanes(obs, grid);\n  const smoothedCover = blur1d(cover, sigmaVox[2]);\n  let max = 0;\n  const plane = w * h;\n  for (let k = 0; k < d; k++) {\n    // OUTSIDE the sampled range there is nothing to interpolate between, only\n    // one side to extrapolate from — so the field is zeroed rather than scaled.\n    // The blur leaves a positive tail past the first and last imaged planes, and\n    // keeping it would put estimated cells in front of the specimen's first\n    // section and behind its last, which is exactly what \"smoothed BETWEEN the\n    // imaged sections\" promises not to do.\n    if (k < first || k > last) {\n      field.fill(0, k * plane, (k + 1) * plane);\n      continue;\n    }\n    // Inside it, the correction BRIDGES gaps. Capping the amplification at 2x\n    // (coverage floored at 0.5) lifts a plane sitting between two imaged sections\n    // — where a bandwidth spanning one gap leaves coverage around a half —\n    // without inflating a trace of smoothing leakage into a signal.\n    const scale = 1 / Math.max(smoothedCover[k], 0.5);\n    for (let i = k * plane; i < (k + 1) * plane; i++) {\n      const v = field[i] * scale;\n      field[i] = v;\n      if (v > max) max = v;\n    }\n  }\n  if (!(max > 0)) return null;\n\n  const out = new Uint8Array(field.length);\n  for (let i = 0; i < field.length; i++) out[i] = Math.round((field[i] / max) * 255);\n  return out;\n}\n\n/**\n * Default kernel for a grid: in-plane tight, along z at least the section\n * spacing.\n *\n * The z term is the load-bearing one — 1.5 voxels of a grid whose depth voxel IS\n * the section spacing puts σ just above one section gap, which is the smallest\n * bandwidth that can bridge one without leaving a disc per plane. `smoothing`\n * scales all three for the user control.\n */\nexport function defaultSigma(grid: DensityGrid, smoothing = 1): [number, number, number] {\n  return [\n    grid.voxelSize[0] * 1.5 * smoothing,\n    grid.voxelSize[1] * 1.5 * smoothing,\n    grid.voxelSize[2] * 1.5 * smoothing,\n  ];\n}\n"]}