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

package/esm2022/lib/spatial/spatial-volume-image.mjs

@@ -95,9 +95,7 @@ export async function buildVolumeStackImage(dataset, voxels) {
             // and a name SHARED by two datasets (only `id` is required to be unique)
             // would serve one dataset's slices for the other.
             fileName: `${dataset.name} · reference volume [${dataset.id}]`,
-            imageMeta: [
-                { channelCount: 1, rgbChannels: 1, x: width, y: height, z: depth, mppX, mppY, mppZ },
-            ],
+            imageMeta: [{ channelCount: 1, rgbChannels: 1, x: width, y: height, z: depth, mppX, mppY, mppZ }],
             // Blob URLs are complete images: OSD must open them directly, not ask a tile
             // server for a pyramid that does not exist.
             tiled: false,
@@ -160,4 +158,4 @@ export function observationsInSlice(obs, volume, slice) {
     }
     return out.subarray(0, n);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-volume-image.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-volume-image.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from '../contracts/image.contract';\nimport {\n  SpatialDataset, SpatialImageRef, SpatialObservations, SpatialVolumeMeta,\n} from '../contracts/spatial-dataset.contract';\n\n/**\n * A dataset's reference volume, encoded as the z-stack image the 2D path renders,\n * plus the blob URLs backing it.\n *\n * The URLs belong to the CALLER: nothing else can know when the image stops being\n * displayed, and a dataset switch that forgets to revoke them leaks a volume's\n * worth of PNGs per switch.\n */\nexport interface VolumeStackImage {\n  info: IImageInfo;\n  urls: string[];\n}\n\n/** Encode one canvas as a PNG blob, over whichever canvas flavour this runtime has. */\nasync function toPngBlob(canvas: HTMLCanvasElement | OffscreenCanvas): Promise<Blob> {\n  if ('convertToBlob' in canvas) return canvas.convertToBlob({ type: 'image/png' });\n  return new Promise<Blob>((resolve, reject) => {\n    canvas.toBlob((blob) => (blob ? resolve(blob) : reject(new Error('toBlob produced nothing'))), 'image/png');\n  });\n}\n\n/**\n * Turn a spatial dataset's registered volume into a scrubbable z-stack image.\n *\n * A 3D omics dataset arrives as one volume and NO `imageRef`, so there is no image\n * behind it — which left every image-shaped surface (the Image view, the slice\n * bar, the contrast window, regions) with nothing to work on, and the Image view\n * showing whatever slide happened to be loaded before. Encoding each z plane as a\n * blob PNG makes the volume itself the image, so the existing stack machinery\n * drives it unchanged: the same `urls[z]` + `isStack` shape a host emits for a\n * multi-page TIFF, which is exactly what this volume is.\n *\n * Every plane is encoded up front rather than on demand, because the slice count\n * comes from `urls.length` — the component has to know the depth before the user\n * scrubs. The voxels are already resident (megabytes, fetched in one call), and a\n * plane is a few KB of PNG, so the cost is bounded by the volume the host already\n * chose to fetch.\n *\n * Returns null when the dataset declares no volume, or the byte count contradicts\n * the declared geometry — a short buffer would silently produce slices of shifted\n * anatomy, which is worse than no image at all.\n */\nexport async function buildVolumeStackImage(\n  dataset: SpatialDataset,\n  voxels: Uint8Array,\n): Promise<VolumeStackImage | null> {\n  const meta = dataset.volume;\n  if (!meta) return null;\n  const { width, height, depth } = meta;\n  const plane = width * height;\n  if (voxels.length !== plane * depth) {\n    console.warn(\n      `[spatial] volume is ${voxels.length} bytes but its geometry declares ` +\n        `${plane * depth} (${width}x${height}x${depth}) — not rendering it as an image`,\n    );\n    return null;\n  }\n\n  let canvas: HTMLCanvasElement | OffscreenCanvas;\n  if (typeof OffscreenCanvas !== 'undefined') {\n    canvas = new OffscreenCanvas(width, height);\n  } else {\n    canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n  }\n  const ctx = canvas.getContext('2d') as\n    | CanvasRenderingContext2D\n    | OffscreenCanvasRenderingContext2D\n    | null;\n  if (!ctx) throw new Error('[spatial] volume slice encode: 2D context unavailable');\n\n  // One canvas and one RGBA buffer for the whole stack — a canvas per plane would\n  // be `depth` GPU-backed surfaces alive at once for no gain.\n  const rgba = new Uint8ClampedArray(plane * 4);\n  const urls: string[] = [];\n  for (let z = 0; z < depth; z++) {\n    const base = z * plane;\n    for (let i = 0; i < plane; i++) {\n      const v = voxels[base + i];\n      const o = i * 4;\n      rgba[o] = v;\n      rgba[o + 1] = v;\n      rgba[o + 2] = v;\n      rgba[o + 3] = 255;\n    }\n    ctx.putImageData(new ImageData(rgba, width, height), 0, 0);\n    urls.push(URL.createObjectURL(await toPngBlob(canvas)));\n  }\n\n  // voxelSize is in the OBSERVATIONS' units, so it only means microns once\n  // `micronsPerUnit` says so. Absent, the unit is unknown and mpp stays null —\n  // the contract's rule for the scale bar: no bar beats a bar that looks like a\n  // measurement and is not one.\n  const perUnit = dataset.micronsPerUnit;\n  const mppX = perUnit != null ? meta.voxelSize[0] * perUnit : null;\n  const mppY = perUnit != null ? meta.voxelSize[1] * perUnit : null;\n  // The z counterpart, which is what carries the volume's anisotropy into the\n  // Volume / Isosurface views: they raymarch the image stack, and a stack with no\n  // declared slice spacing can only be given a shape-only world box.\n  const mppZ = perUnit != null ? meta.voxelSize[2] * perUnit : null;\n\n  return {\n    urls,\n    info: {\n      // A scalar field: one band, no colour of its own — which is also what puts\n      // the scalar modes (Heatmap / Contour / Surface / Volume) legitimately on\n      // offer for a dataset that has no camera image anywhere in it.\n      isGrayscale: true,\n      trueImageSize: [width, height],\n      urls,\n      isStack: depth > 1,\n      showStack: false,\n      scaleRatio: true,\n      // Stable AND unique per dataset: the slice-blob cache keys off the file name,\n      // so a name that changed per load would re-fetch a volume that never moved —\n      // and a name SHARED by two datasets (only `id` is required to be unique)\n      // would serve one dataset's slices for the other.\n      fileName: `${dataset.name} · reference volume [${dataset.id}]`,\n      imageMeta: [\n        { channelCount: 1, rgbChannels: 1, x: width, y: height, z: depth, mppX, mppY, mppZ },\n      ],\n      // Blob URLs are complete images: OSD must open them directly, not ask a tile\n      // server for a pyramid that does not exist.\n      tiled: false,\n      // Open mid-volume. The first and last planes of an anatomical volume are\n      // outside the specimen — opening on slice 0 shows an empty frame and reads\n      // as a failed load.\n      initialZIndex: depth > 1 ? depth >> 1 : undefined,\n    },\n  };\n}\n\n/**\n * The data→image affine a registered volume implies.\n *\n * Once the volume IS the image ({@link buildVolumeStackImage}), one slice is a\n * `width x height` pixel grid whose voxel `(i, j)` covers\n * `[i * voxelSize[0], (i + 1) * voxelSize[0])` of the observations' coordinate\n * space — the contract's rule that the volume's near corner sits at the\n * coordinate origin. So observations reach pixel space by dividing out the voxel\n * size, and nothing has to move.\n *\n * Shaped as a `SpatialImageRef` on purpose: the marker layer and the ROI\n * selection then take the SAME transform they take for a dataset that ships a\n * real `imageRef`, instead of each growing a volume special case.\n */\nexport function volumeImageRef(\n  volume: SpatialVolumeMeta, micronsPerUnit?: number,\n): SpatialImageRef {\n  const [vx, vy] = volume.voxelSize;\n  return {\n    scale: [1 / vx, 1 / vy],\n    translate: [0, 0],\n    ...(micronsPerUnit != null ? { mppX: vx * micronsPerUnit, mppY: vy * micronsPerUnit } : {}),\n  };\n}\n\n/** The voxel plane a coordinate falls in, clamped into the volume. */\nexport function sliceIndexOf(z: number, volume: SpatialVolumeMeta): number {\n  const k = Math.floor(z / volume.voxelSize[2]);\n  return Math.max(0, Math.min(volume.depth - 1, k));\n}\n\n/**\n * Indices of the observations that fall in one voxel plane of the volume.\n *\n * A 2D view of a 3D dataset shows ONE plane, so it must draw one plane's\n * observations: without this the whole depth of the specimen piles onto a single\n * section and reads as a solid smear rather than a section's cells. The plane is\n * a slab `voxelSize[2]` thick, which is exactly the sampling the volume itself\n * has — for serial sections registered into a common frame, one slab is one\n * section.\n *\n * Every observation is in the plane when the dataset carries no z: a genuinely\n * flat dataset over a volume has nothing to filter on.\n */\nexport function observationsInSlice(\n  obs: SpatialObservations, volume: SpatialVolumeMeta, slice: number,\n): Uint32Array {\n  const z = obs.z;\n  if (!z) return Uint32Array.from({ length: obs.count }, (_, i) => i);\n  const out = new Uint32Array(obs.count);\n  let n = 0;\n  for (let i = 0; i < obs.count; i++) {\n    if (sliceIndexOf(z[i], volume) === slice) out[n++] = i;\n  }\n  return out.subarray(0, n);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-volume-image.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-volume-image.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from '../contracts/image.contract';\nimport {\n  SpatialDataset,\n  SpatialImageRef,\n  SpatialObservations,\n  SpatialVolumeMeta,\n} from '../contracts/spatial-dataset.contract';\n\n/**\n * A dataset's reference volume, encoded as the z-stack image the 2D path renders,\n * plus the blob URLs backing it.\n *\n * The URLs belong to the CALLER: nothing else can know when the image stops being\n * displayed, and a dataset switch that forgets to revoke them leaks a volume's\n * worth of PNGs per switch.\n */\nexport interface VolumeStackImage {\n  info: IImageInfo;\n  urls: string[];\n}\n\n/** Encode one canvas as a PNG blob, over whichever canvas flavour this runtime has. */\nasync function toPngBlob(canvas: HTMLCanvasElement | OffscreenCanvas): Promise<Blob> {\n  if ('convertToBlob' in canvas) return canvas.convertToBlob({ type: 'image/png' });\n  return new Promise<Blob>((resolve, reject) => {\n    canvas.toBlob((blob) => (blob ? resolve(blob) : reject(new Error('toBlob produced nothing'))), 'image/png');\n  });\n}\n\n/**\n * Turn a spatial dataset's registered volume into a scrubbable z-stack image.\n *\n * A 3D omics dataset arrives as one volume and NO `imageRef`, so there is no image\n * behind it — which left every image-shaped surface (the Image view, the slice\n * bar, the contrast window, regions) with nothing to work on, and the Image view\n * showing whatever slide happened to be loaded before. Encoding each z plane as a\n * blob PNG makes the volume itself the image, so the existing stack machinery\n * drives it unchanged: the same `urls[z]` + `isStack` shape a host emits for a\n * multi-page TIFF, which is exactly what this volume is.\n *\n * Every plane is encoded up front rather than on demand, because the slice count\n * comes from `urls.length` — the component has to know the depth before the user\n * scrubs. The voxels are already resident (megabytes, fetched in one call), and a\n * plane is a few KB of PNG, so the cost is bounded by the volume the host already\n * chose to fetch.\n *\n * Returns null when the dataset declares no volume, or the byte count contradicts\n * the declared geometry — a short buffer would silently produce slices of shifted\n * anatomy, which is worse than no image at all.\n */\nexport async function buildVolumeStackImage(\n  dataset: SpatialDataset,\n  voxels: Uint8Array,\n): Promise<VolumeStackImage | null> {\n  const meta = dataset.volume;\n  if (!meta) return null;\n  const { width, height, depth } = meta;\n  const plane = width * height;\n  if (voxels.length !== plane * depth) {\n    console.warn(\n      `[spatial] volume is ${voxels.length} bytes but its geometry declares ` +\n        `${plane * depth} (${width}x${height}x${depth}) — not rendering it as an image`,\n    );\n    return null;\n  }\n\n  let canvas: HTMLCanvasElement | OffscreenCanvas;\n  if (typeof OffscreenCanvas !== 'undefined') {\n    canvas = new OffscreenCanvas(width, height);\n  } else {\n    canvas = document.createElement('canvas');\n    canvas.width = width;\n    canvas.height = height;\n  }\n  const ctx = canvas.getContext('2d') as CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;\n  if (!ctx) throw new Error('[spatial] volume slice encode: 2D context unavailable');\n\n  // One canvas and one RGBA buffer for the whole stack — a canvas per plane would\n  // be `depth` GPU-backed surfaces alive at once for no gain.\n  const rgba = new Uint8ClampedArray(plane * 4);\n  const urls: string[] = [];\n  for (let z = 0; z < depth; z++) {\n    const base = z * plane;\n    for (let i = 0; i < plane; i++) {\n      const v = voxels[base + i];\n      const o = i * 4;\n      rgba[o] = v;\n      rgba[o + 1] = v;\n      rgba[o + 2] = v;\n      rgba[o + 3] = 255;\n    }\n    ctx.putImageData(new ImageData(rgba, width, height), 0, 0);\n    urls.push(URL.createObjectURL(await toPngBlob(canvas)));\n  }\n\n  // voxelSize is in the OBSERVATIONS' units, so it only means microns once\n  // `micronsPerUnit` says so. Absent, the unit is unknown and mpp stays null —\n  // the contract's rule for the scale bar: no bar beats a bar that looks like a\n  // measurement and is not one.\n  const perUnit = dataset.micronsPerUnit;\n  const mppX = perUnit != null ? meta.voxelSize[0] * perUnit : null;\n  const mppY = perUnit != null ? meta.voxelSize[1] * perUnit : null;\n  // The z counterpart, which is what carries the volume's anisotropy into the\n  // Volume / Isosurface views: they raymarch the image stack, and a stack with no\n  // declared slice spacing can only be given a shape-only world box.\n  const mppZ = perUnit != null ? meta.voxelSize[2] * perUnit : null;\n\n  return {\n    urls,\n    info: {\n      // A scalar field: one band, no colour of its own — which is also what puts\n      // the scalar modes (Heatmap / Contour / Surface / Volume) legitimately on\n      // offer for a dataset that has no camera image anywhere in it.\n      isGrayscale: true,\n      trueImageSize: [width, height],\n      urls,\n      isStack: depth > 1,\n      showStack: false,\n      scaleRatio: true,\n      // Stable AND unique per dataset: the slice-blob cache keys off the file name,\n      // so a name that changed per load would re-fetch a volume that never moved —\n      // and a name SHARED by two datasets (only `id` is required to be unique)\n      // would serve one dataset's slices for the other.\n      fileName: `${dataset.name} · reference volume [${dataset.id}]`,\n      imageMeta: [{ channelCount: 1, rgbChannels: 1, x: width, y: height, z: depth, mppX, mppY, mppZ }],\n      // Blob URLs are complete images: OSD must open them directly, not ask a tile\n      // server for a pyramid that does not exist.\n      tiled: false,\n      // Open mid-volume. The first and last planes of an anatomical volume are\n      // outside the specimen — opening on slice 0 shows an empty frame and reads\n      // as a failed load.\n      initialZIndex: depth > 1 ? depth >> 1 : undefined,\n    },\n  };\n}\n\n/**\n * The data→image affine a registered volume implies.\n *\n * Once the volume IS the image ({@link buildVolumeStackImage}), one slice is a\n * `width x height` pixel grid whose voxel `(i, j)` covers\n * `[i * voxelSize[0], (i + 1) * voxelSize[0])` of the observations' coordinate\n * space — the contract's rule that the volume's near corner sits at the\n * coordinate origin. So observations reach pixel space by dividing out the voxel\n * size, and nothing has to move.\n *\n * Shaped as a `SpatialImageRef` on purpose: the marker layer and the ROI\n * selection then take the SAME transform they take for a dataset that ships a\n * real `imageRef`, instead of each growing a volume special case.\n */\nexport function volumeImageRef(volume: SpatialVolumeMeta, micronsPerUnit?: number): SpatialImageRef {\n  const [vx, vy] = volume.voxelSize;\n  return {\n    scale: [1 / vx, 1 / vy],\n    translate: [0, 0],\n    ...(micronsPerUnit != null ? { mppX: vx * micronsPerUnit, mppY: vy * micronsPerUnit } : {}),\n  };\n}\n\n/** The voxel plane a coordinate falls in, clamped into the volume. */\nexport function sliceIndexOf(z: number, volume: SpatialVolumeMeta): number {\n  const k = Math.floor(z / volume.voxelSize[2]);\n  return Math.max(0, Math.min(volume.depth - 1, k));\n}\n\n/**\n * Indices of the observations that fall in one voxel plane of the volume.\n *\n * A 2D view of a 3D dataset shows ONE plane, so it must draw one plane's\n * observations: without this the whole depth of the specimen piles onto a single\n * section and reads as a solid smear rather than a section's cells. The plane is\n * a slab `voxelSize[2]` thick, which is exactly the sampling the volume itself\n * has — for serial sections registered into a common frame, one slab is one\n * section.\n *\n * Every observation is in the plane when the dataset carries no z: a genuinely\n * flat dataset over a volume has nothing to filter on.\n */\nexport function observationsInSlice(\n  obs: SpatialObservations,\n  volume: SpatialVolumeMeta,\n  slice: number,\n): Uint32Array {\n  const z = obs.z;\n  if (!z) return Uint32Array.from({ length: obs.count }, (_, i) => i);\n  const out = new Uint32Array(obs.count);\n  let n = 0;\n  for (let i = 0; i < obs.count; i++) {\n    if (sliceIndexOf(z[i], volume) === slice) out[n++] = i;\n  }\n  return out.subarray(0, n);\n}\n"]}

package/esm2022/lib/spatial/stats.mjs

@@ -0,0 +1,71 @@
+/**
+ * Percentiles for the spatial code: one "collect, sort, index" routine instead of one per
+ * caller.
+ *
+ * The callers used to differ in rounding (`round(p·(n-1))` against `floor(p·n)`), in
+ * sampling and in filtering, so windows computed for the same data in different views
+ * could disagree. Here there is one rule for each:
+ *
+ *  - **Rank**: `round(p·(n-1))` — the nearest rank. `floor(p·n)` is biased upward and
+ *    hands back the maximum for `p = 0.99` on a hundred values, outlier included.
+ *  - **Sort**: a typed-array sort, which is native and numeric — several times faster
+ *    than a comparator sort of a boxed `number[]`, and far lighter on the heap.
+ *  - **Sample**: past `2·sampleSize` qualifying values, every `floor(count/sampleSize)`-th
+ *    one, which is plenty for a display window and keeps a 3.7M-cell recolour from
+ *    sorting 3.7M values.
+ */
+/**
+ * The `ps` quantiles (each 0..1, clamped) of the values that qualify, or null when none do.
+ */
+export function quantiles(values, ps, opts = {}) {
+    const positive = opts.filter === 'positive';
+    const where = opts.where;
+    const n = values.length;
+    const keep = (i) => {
+        const v = values[i];
+        if (positive ? !(v > 0) : !Number.isFinite(v))
+            return false;
+        return !where || where[i] > 0;
+    };
+    let count = 0;
+    for (let i = 0; i < n; i++)
+        if (keep(i))
+            count++;
+    if (count === 0)
+        return null;
+    const step = opts.sampleSize && count >= 2 * opts.sampleSize ? Math.floor(count / opts.sampleSize) : 1;
+    const sample = new Float64Array(Math.ceil(count / step));
+    let seen = 0;
+    let k = 0;
+    for (let i = 0; i < n && k < sample.length; i++) {
+        if (!keep(i))
+            continue;
+        if (seen++ % step === 0)
+            sample[k++] = values[i];
+    }
+    const sorted = sample.subarray(0, k).sort();
+    const last = sorted.length - 1;
+    return ps.map((p) => {
+        const f = Math.max(0, Math.min(1, Number.isFinite(p) ? p : 0));
+        return sorted[Math.round(f * last)];
+    });
+}
+/** One quantile; see {@link quantiles}. */
+export function quantile(values, p, opts = {}) {
+    return quantiles(values, [p], opts)?.[0] ?? null;
+}
+/** Sample size for a contrast window: a display window does not need every value. */
+export const WINDOW_SAMPLE_SIZE = 65_536;
+/**
+ * A `[lo, hi]` percentile window over the qualifying values, never flat or inverted
+ * (a flat window would divide by zero downstream, so it is widened by one), and `[0, 1]`
+ * when nothing qualifies, so callers always get a usable window.
+ */
+export function percentileWindow(values, lo, hi, opts = {}) {
+    const q = quantiles(values, [lo, hi], { sampleSize: WINDOW_SAMPLE_SIZE, ...opts });
+    if (!q)
+        return [0, 1];
+    const [min, max] = q;
+    return max > min ? [min, max] : [min, min + 1];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stats.js","sourceRoot":"","sources":["../../../../src/lib/spatial/stats.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Percentiles for the spatial code: one \"collect, sort, index\" routine instead of one per\n * caller.\n *\n * The callers used to differ in rounding (`round(p·(n-1))` against `floor(p·n)`), in\n * sampling and in filtering, so windows computed for the same data in different views\n * could disagree. Here there is one rule for each:\n *\n *  - **Rank**: `round(p·(n-1))` — the nearest rank. `floor(p·n)` is biased upward and\n *    hands back the maximum for `p = 0.99` on a hundred values, outlier included.\n *  - **Sort**: a typed-array sort, which is native and numeric — several times faster\n *    than a comparator sort of a boxed `number[]`, and far lighter on the heap.\n *  - **Sample**: past `2·sampleSize` qualifying values, every `floor(count/sampleSize)`-th\n *    one, which is plenty for a display window and keeps a 3.7M-cell recolour from\n *    sorting 3.7M values.\n */\n\nexport interface QuantileOptions {\n  /** Which values count: every finite one (the default), or only those above zero. */\n  filter?: 'finite' | 'positive';\n  /** Count index `i` only where `where[i] > 0` — e.g. a field's support. */\n  where?: ArrayLike<number>;\n  /** Sample down to about this many values (see the module doc); unsampled when absent. */\n  sampleSize?: number;\n}\n\n/**\n * The `ps` quantiles (each 0..1, clamped) of the values that qualify, or null when none do.\n */\nexport function quantiles(\n  values: ArrayLike<number>,\n  ps: readonly number[],\n  opts: QuantileOptions = {},\n): number[] | null {\n  const positive = opts.filter === 'positive';\n  const where = opts.where;\n  const n = values.length;\n  const keep = (i: number): boolean => {\n    const v = values[i];\n    if (positive ? !(v > 0) : !Number.isFinite(v)) return false;\n    return !where || where[i] > 0;\n  };\n\n  let count = 0;\n  for (let i = 0; i < n; i++) if (keep(i)) count++;\n  if (count === 0) return null;\n\n  const step = opts.sampleSize && count >= 2 * opts.sampleSize ? Math.floor(count / opts.sampleSize) : 1;\n  const sample = new Float64Array(Math.ceil(count / step));\n  let seen = 0;\n  let k = 0;\n  for (let i = 0; i < n && k < sample.length; i++) {\n    if (!keep(i)) continue;\n    if (seen++ % step === 0) sample[k++] = values[i];\n  }\n  const sorted = sample.subarray(0, k).sort();\n  const last = sorted.length - 1;\n  return ps.map((p) => {\n    const f = Math.max(0, Math.min(1, Number.isFinite(p) ? p : 0));\n    return sorted[Math.round(f * last)];\n  });\n}\n\n/** One quantile; see {@link quantiles}. */\nexport function quantile(values: ArrayLike<number>, p: number, opts: QuantileOptions = {}): number | null {\n  return quantiles(values, [p], opts)?.[0] ?? null;\n}\n\n/** Sample size for a contrast window: a display window does not need every value. */\nexport const WINDOW_SAMPLE_SIZE = 65_536;\n\n/**\n * A `[lo, hi]` percentile window over the qualifying values, never flat or inverted\n * (a flat window would divide by zero downstream, so it is widened by one), and `[0, 1]`\n * when nothing qualifies, so callers always get a usable window.\n */\nexport function percentileWindow(\n  values: ArrayLike<number>,\n  lo: number,\n  hi: number,\n  opts: QuantileOptions = {},\n): [number, number] {\n  const q = quantiles(values, [lo, hi], { sampleSize: WINDOW_SAMPLE_SIZE, ...opts });\n  if (!q) return [0, 1];\n  const [min, max] = q;\n  return max > min ? [min, max] : [min, min + 1];\n}\n"]}

package/esm2022/lib/spatial/transcript-grouping.mjs

@@ -0,0 +1,307 @@
+/**
+ * Transcript grouping and marker sizing: how many transcripts one marker stands for at the
+ * current zoom, how big it is drawn, and which colour each gene-tree cluster takes. Pure, so
+ * the budget policy is testable without a viewer.
+ */
+import { visibleArea } from './lod';
+import { quantile } from './stats';
+/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */
+export const GROUP_MIN_SPACING_PX = 14;
+/**
+ * The bin a selection of genes is grouped into at this zoom, in observation units, or null
+ * to draw every transcript. Bins follow the all-gene pyramid's ladder (`baseBin` × 2^m) so a
+ * gene selection and "all genes" group alike: the finest bin whose markers land at least
+ * `spacingPx` apart on screen. Once the finest bin is that wide, transcripts are drawn as
+ * themselves.
+ */
+export function geneBinSize(pxPerUnit, baseBin, levels = 7, spacingPx = GROUP_MIN_SPACING_PX) {
+    if (!(pxPerUnit > 0) || !(baseBin > 0))
+        return null;
+    if (baseBin * pxPerUnit >= spacingPx)
+        return null;
+    for (let m = 1; m < levels; m++) {
+        const bin = baseBin * 2 ** m;
+        if (bin * pxPerUnit >= spacingPx)
+            return bin;
+    }
+    return baseBin * 2 ** (levels - 1);
+}
+/** The entries of `t` inside `rect` (observation units). */
+export function clipTranscripts(t, rect) {
+    const keep = [];
+    for (let i = 0; i < t.count; i++) {
+        if (t.x[i] >= rect.x0 && t.x[i] <= rect.x1 && t.y[i] >= rect.y0 && t.y[i] <= rect.y1)
+            keep.push(i);
+    }
+    if (keep.length === t.count)
+        return t;
+    const pick = (a) => {
+        const out = new a.constructor(keep.length);
+        keep.forEach((src, i) => {
+            out[i] = a[src];
+        });
+        return out;
+    };
+    return {
+        count: keep.length,
+        aggregated: t.aggregated,
+        x: pick(t.x),
+        y: pick(t.y),
+        z: pick(t.z),
+        weight: pick(t.weight),
+        observation: pick(t.observation),
+        gene: pick(t.gene),
+    };
+}
+// ── Grouping ──────────────────────────────────────────────────────────────────────────
+/**
+ * Group transcripts into `bin`-wide squares of a grid anchored at the origin (so a pan does
+ * not move them), one entry per (group, square): `groupOf(gene slot)` says which group a gene
+ * is in — its cluster in the gene tree, or itself. Each entry sits at its transcripts'
+ * centroid, weighted by how many each stands for; it takes the gene and the cell holding most
+ * of them, each summed over all its transcripts in the entry. `group[i]` is entry i's group.
+ */
+export function groupTranscripts(t, bin, groupOf = (g) => g) {
+    // Hot on every pan and zoom, so nothing is allocated per transcript: the (group, square)
+    // key is a number over the tile's own bounded extent rather than a template string, and
+    // the per-entry gene and cell tallies share two flat maps instead of two Maps per entry.
+    const count = t.count;
+    const gks = new Int32Array(count);
+    let minBx = Infinity;
+    let maxBx = -Infinity;
+    let minBy = Infinity;
+    let maxBy = -Infinity;
+    for (let i = 0; i < count; i++) {
+        gks[i] = groupOf(t.gene[i]);
+        const bx = Math.floor(t.x[i] / bin);
+        const by = Math.floor(t.y[i] / bin);
+        if (bx < minBx)
+            minBx = bx;
+        if (bx > maxBx)
+            maxBx = bx;
+        if (by < minBy)
+            minBy = by;
+        if (by > maxBy)
+            maxBy = by;
+    }
+    // One spare column and row for a square that is not finite (a NaN coordinate), so such
+    // transcripts still group together rather than colliding with a real square.
+    const cols = Number.isFinite(maxBx - minBx) ? maxBx - minBx + 2 : 1;
+    const rows = Number.isFinite(maxBy - minBy) ? maxBy - minBy + 2 : 1;
+    const col = (v) => {
+        const b = Math.floor(v / bin);
+        return Number.isFinite(b) ? b - minBx : cols - 1;
+    };
+    const row = (v) => {
+        const b = Math.floor(v / bin);
+        return Number.isFinite(b) ? b - minBy : rows - 1;
+    };
+    const index = new Map();
+    const sx = [];
+    const sy = [];
+    const sz = [];
+    const w = [];
+    const grp = [];
+    // Per entry, how many transcripts of each gene (the dominant one gives the icon and colour)
+    // and in each cell (the dominant one is the entry's cell).
+    const genes = new DominantTally();
+    const cells = new DominantTally();
+    for (let i = 0; i < count; i++) {
+        const gk = gks[i];
+        const key = (gk * rows + row(t.y[i])) * cols + col(t.x[i]);
+        let k = index.get(key);
+        const wi = t.weight[i] || 1;
+        if (k === undefined) {
+            k = w.length;
+            index.set(key, k);
+            sx.push(0);
+            sy.push(0);
+            sz.push(0);
+            w.push(0);
+            grp.push(gk);
+        }
+        sx[k] += t.x[i] * wi;
+        sy[k] += t.y[i] * wi;
+        sz[k] += t.z[i] * wi;
+        w[k] += wi;
+        genes.add(k, t.gene[i], wi);
+        cells.add(k, t.observation[i], wi);
+    }
+    const n = w.length;
+    const tile = {
+        count: n,
+        aggregated: true,
+        x: new Float32Array(n),
+        y: new Float32Array(n),
+        z: new Float32Array(n),
+        weight: new Uint32Array(n),
+        observation: new Uint32Array(n),
+        gene: new Uint16Array(n),
+    };
+    const group = new Int32Array(n);
+    for (let k = 0; k < n; k++) {
+        tile.x[k] = sx[k] / w[k];
+        tile.y[k] = sy[k] / w[k];
+        tile.z[k] = sz[k] / w[k];
+        tile.weight[k] = w[k];
+        tile.observation[k] = cells.dominant(k);
+        tile.gene[k] = genes.dominant(k);
+        group[k] = grp[k];
+    }
+    return { tile, group };
+}
+/**
+ * Weighted tallies of u32 keys per entry, tracking each entry's dominant key as it goes:
+ * the key with the largest total, the first seen on a tie.
+ *
+ * One map for every entry, keyed `entry · 2^32 + key` — exact while entries stay below
+ * 2^21, far above any marker budget.
+ */
+class DominantTally {
+    constructor() {
+        this.total = new Map();
+        this.firstSeen = new Map();
+        this.seq = 0;
+        this.bestKey = [];
+        this.bestTotal = [];
+        this.bestSeen = [];
+    }
+    static { this.KEY_SPAN = 2 ** 32; }
+    add(entry, key, weight) {
+        const id = entry * DominantTally.KEY_SPAN + key;
+        const v = (this.total.get(id) ?? 0) + weight;
+        this.total.set(id, v);
+        let first = this.firstSeen.get(id);
+        if (first === undefined) {
+            first = this.seq++;
+            this.firstSeen.set(id, first);
+        }
+        const top = this.bestTotal[entry];
+        if (top === undefined || v > top || (v === top && first < this.bestSeen[entry])) {
+            this.bestKey[entry] = key;
+            this.bestTotal[entry] = v;
+            this.bestSeen[entry] = first;
+        }
+    }
+    dominant(entry) {
+        return this.bestKey[entry] ?? 0;
+    }
+}
+// ── Cluster colours ───────────────────────────────────────────────────────────────────
+/**
+ * The colour of each gene-tree cluster of a selection, for colouring transcripts by cluster: a
+ * cluster named like a group of the cells' grouping takes that group's colour (its cells and its
+ * transcripts agree); the others take palette colours in tree order. Clusters are the tree's
+ * groups holding a selected gene, then each ungrouped selected gene on its own. Every gene of a
+ * cluster gets the same colour — the tree's swatches and the markers use this one map.
+ */
+export function clusterColorMap(genes, groups, cellColors, palette) {
+    const chosen = new Set(genes);
+    const names = [];
+    const grouped = new Set();
+    for (const g of groups) {
+        const mine = g.genes.filter((x) => chosen.has(x) && !grouped.has(x));
+        if (!mine.length)
+            continue;
+        mine.forEach((x) => grouped.add(x));
+        names.push(g.name);
+    }
+    for (const gene of genes)
+        if (!grouped.has(gene))
+            names.push(gene);
+    const out = new Map();
+    let k = 0;
+    for (const name of names) {
+        if (out.has(name))
+            continue;
+        out.set(name, cellColors.get(name) ?? palette[k++ % palette.length]);
+    }
+    return out;
+}
+/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */
+export function clusterOfGene(gene, groups) {
+    return groups.find((g) => g.genes.includes(gene))?.name ?? gene;
+}
+// ── Marker sizing ─────────────────────────────────────────────────────────────────────
+/** Smallest transcript marker, in canvas pixels. */
+export const TRANSCRIPT_MIN_PX = 4;
+/** Largest transcript marker, in canvas pixels. */
+export const TRANSCRIPT_MAX_PX = 32;
+/**
+ * Physical diameter a single transcript is drawn at, in µm — clearly larger than the
+ * imaged spot (~0.3 µm) so it stays legible, and small enough that neighbouring
+ * molecules inside one cell stay apart.
+ */
+export const TRANSCRIPT_PHYSICAL_UM = 1.2;
+/**
+ * Marker diameter in canvas pixels for an entry standing for `weight` transcripts.
+ *
+ * The convention spatial viewers share (deck.gl's `radiusMinPixels`/`radiusMaxPixels`,
+ * Xenium Explorer's transcript size): a PHYSICAL size, clamped to a screen-pixel range.
+ * Zoomed out, markers sit at the minimum and never vanish; zoomed in, they grow with the
+ * tissue instead of shrinking to specks next to cells hundreds of pixels wide. A fixed
+ * screen size does the opposite at high zoom, which is what made transcripts disappear
+ * at pixel-level zoom.
+ *
+ * Aggregates grow with the cube root of their count: area ∝ count would let one dense
+ * aggregate swallow its neighbours, the cube root keeps a 1000-transcript cluster clearly
+ * larger than a 10-transcript one without covering the tile.
+ *
+ * `pxPerMicron` is omitted for data with no known physical unit; the marker is then
+ * screen-sized only.
+ */
+export function transcriptMarkerPx(weight, scale = 1, pxPerMicron) {
+    const counted = TRANSCRIPT_MIN_PX * Math.cbrt(Math.max(1, weight));
+    const physical = pxPerMicron ? TRANSCRIPT_PHYSICAL_UM * pxPerMicron : 0;
+    const px = Math.max(counted, physical) * scale;
+    return Math.min(TRANSCRIPT_MAX_PX * Math.max(scale, 1), Math.max(TRANSCRIPT_MIN_PX * scale, px));
+}
+/**
+ * How to draw every transcript in view without exceeding `budget` markers.
+ *
+ * - The transcripts themselves, once the estimated count in view fits the budget.
+ * - Otherwise the finest pyramid level whose bins are at least `minSpacingPx` apart on
+ *   screen and number no more than the budget — groups big enough to read, few enough
+ *   to draw.
+ *
+ * The count in view is estimated from the average density, which over- or under-shoots
+ * locally; the renderer still caps what it draws, so an estimate is enough to choose.
+ */
+export function allGenesPlan(o) {
+    const area = visibleArea(o.rect, o.bounds);
+    if (!(area > 0))
+        return { kind: 'none' };
+    const b = o.bounds;
+    const density = o.total / Math.max(1, (b[2] - b[0]) * (b[3] - b[1]));
+    if (o.canIndividual && density * area <= o.budget)
+        return { kind: 'individual' };
+    if (!o.levels.length)
+        return { kind: 'none' };
+    const spacing = o.minSpacingPx ?? GROUP_MIN_SPACING_PX;
+    for (let l = 0; l < o.levels.length; l++) {
+        const bin = o.levels[l].binSize;
+        // Tissue rarely fills the view; 0.7 of the bins occupied is a fair guess.
+        if (bin * o.pxPerUnit >= spacing && (area / (bin * bin)) * 0.7 <= o.budget) {
+            return { kind: 'bins', level: l };
+        }
+    }
+    return { kind: 'bins', level: o.levels.length - 1 };
+}
+/**
+ * Diameter in px of a group of `count` transcripts in a bin `binPx` wide, where
+ * `refCount` is a typical busy bin in view (its 95th percentile).
+ *
+ * Area grows with the count — a bin with a quarter of the transcripts gets half the
+ * diameter — between a third of the bin (so a sparse bin is still visible) and a little
+ * over the full bin (so dense neighbours just touch rather than pile up).
+ */
+export function groupedMarkerPx(count, refCount, binPx, scale = 1) {
+    const f = Math.sqrt(Math.min(1, count / Math.max(1, refCount)));
+    const d = binPx * (0.35 + 0.75 * f) * scale;
+    return Math.max(TRANSCRIPT_MIN_PX * scale, Math.min(d, binPx * 1.2 * Math.max(scale, 1)));
+}
+/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */
+export function quantileOf(values, p) {
+    return quantile(values, p, { sampleSize: 4096 }) ?? 0;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcript-grouping.js","sourceRoot":"","sources":["../../../../src/lib/spatial/transcript-grouping.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Transcript grouping and marker sizing: how many transcripts one marker stands for at the\n * current zoom, how big it is drawn, and which colour each gene-tree cluster takes. Pure, so\n * the budget policy is testable without a viewer.\n */\n\nimport type { SpatialBounds, SpatialTranscriptTile } from '../contracts/spatial-dataset.contract';\nimport { DataRect, visibleArea } from './lod';\nimport { quantile } from './stats';\n\n/** Smallest on-screen spacing between groups, in px — below it groups read as noise. */\nexport const GROUP_MIN_SPACING_PX = 14;\n\n/**\n * The bin a selection of genes is grouped into at this zoom, in observation units, or null\n * to draw every transcript. Bins follow the all-gene pyramid's ladder (`baseBin` × 2^m) so a\n * gene selection and \"all genes\" group alike: the finest bin whose markers land at least\n * `spacingPx` apart on screen. Once the finest bin is that wide, transcripts are drawn as\n * themselves.\n */\nexport function geneBinSize(\n  pxPerUnit: number,\n  baseBin: number,\n  levels = 7,\n  spacingPx = GROUP_MIN_SPACING_PX,\n): number | null {\n  if (!(pxPerUnit > 0) || !(baseBin > 0)) return null;\n  if (baseBin * pxPerUnit >= spacingPx) return null;\n  for (let m = 1; m < levels; m++) {\n    const bin = baseBin * 2 ** m;\n    if (bin * pxPerUnit >= spacingPx) return bin;\n  }\n  return baseBin * 2 ** (levels - 1);\n}\n\n/** The entries of `t` inside `rect` (observation units). */\nexport function clipTranscripts(t: SpatialTranscriptTile, rect: DataRect): SpatialTranscriptTile {\n  const keep: number[] = [];\n  for (let i = 0; i < t.count; i++) {\n    if (t.x[i] >= rect.x0 && t.x[i] <= rect.x1 && t.y[i] >= rect.y0 && t.y[i] <= rect.y1) keep.push(i);\n  }\n  if (keep.length === t.count) return t;\n  const pick = <A extends Float32Array | Uint32Array | Uint16Array>(a: A): A => {\n    const out = new (a.constructor as new (n: number) => A)(keep.length);\n    keep.forEach((src, i) => {\n      out[i] = a[src];\n    });\n    return out;\n  };\n  return {\n    count: keep.length,\n    aggregated: t.aggregated,\n    x: pick(t.x),\n    y: pick(t.y),\n    z: pick(t.z),\n    weight: pick(t.weight),\n    observation: pick(t.observation),\n    gene: pick(t.gene),\n  };\n}\n\n// ── Grouping ──────────────────────────────────────────────────────────────────────────\n\n/**\n * Group transcripts into `bin`-wide squares of a grid anchored at the origin (so a pan does\n * not move them), one entry per (group, square): `groupOf(gene slot)` says which group a gene\n * is in — its cluster in the gene tree, or itself. Each entry sits at its transcripts'\n * centroid, weighted by how many each stands for; it takes the gene and the cell holding most\n * of them, each summed over all its transcripts in the entry. `group[i]` is entry i's group.\n */\nexport function groupTranscripts(\n  t: SpatialTranscriptTile,\n  bin: number,\n  groupOf: (geneSlot: number) => number = (g) => g,\n): { tile: SpatialTranscriptTile; group: Int32Array } {\n  // Hot on every pan and zoom, so nothing is allocated per transcript: the (group, square)\n  // key is a number over the tile's own bounded extent rather than a template string, and\n  // the per-entry gene and cell tallies share two flat maps instead of two Maps per entry.\n  const count = t.count;\n  const gks = new Int32Array(count);\n  let minBx = Infinity;\n  let maxBx = -Infinity;\n  let minBy = Infinity;\n  let maxBy = -Infinity;\n  for (let i = 0; i < count; i++) {\n    gks[i] = groupOf(t.gene[i]);\n    const bx = Math.floor(t.x[i] / bin);\n    const by = Math.floor(t.y[i] / bin);\n    if (bx < minBx) minBx = bx;\n    if (bx > maxBx) maxBx = bx;\n    if (by < minBy) minBy = by;\n    if (by > maxBy) maxBy = by;\n  }\n  // One spare column and row for a square that is not finite (a NaN coordinate), so such\n  // transcripts still group together rather than colliding with a real square.\n  const cols = Number.isFinite(maxBx - minBx) ? maxBx - minBx + 2 : 1;\n  const rows = Number.isFinite(maxBy - minBy) ? maxBy - minBy + 2 : 1;\n  const col = (v: number): number => {\n    const b = Math.floor(v / bin);\n    return Number.isFinite(b) ? b - minBx : cols - 1;\n  };\n  const row = (v: number): number => {\n    const b = Math.floor(v / bin);\n    return Number.isFinite(b) ? b - minBy : rows - 1;\n  };\n\n  const index = new Map<number, number>();\n  const sx: number[] = [];\n  const sy: number[] = [];\n  const sz: number[] = [];\n  const w: number[] = [];\n  const grp: number[] = [];\n  // Per entry, how many transcripts of each gene (the dominant one gives the icon and colour)\n  // and in each cell (the dominant one is the entry's cell).\n  const genes = new DominantTally();\n  const cells = new DominantTally();\n  for (let i = 0; i < count; i++) {\n    const gk = gks[i];\n    const key = (gk * rows + row(t.y[i])) * cols + col(t.x[i]);\n    let k = index.get(key);\n    const wi = t.weight[i] || 1;\n    if (k === undefined) {\n      k = w.length;\n      index.set(key, k);\n      sx.push(0);\n      sy.push(0);\n      sz.push(0);\n      w.push(0);\n      grp.push(gk);\n    }\n    sx[k] += t.x[i] * wi;\n    sy[k] += t.y[i] * wi;\n    sz[k] += t.z[i] * wi;\n    w[k] += wi;\n    genes.add(k, t.gene[i], wi);\n    cells.add(k, t.observation[i], wi);\n  }\n  const n = w.length;\n  const tile: SpatialTranscriptTile = {\n    count: n,\n    aggregated: true,\n    x: new Float32Array(n),\n    y: new Float32Array(n),\n    z: new Float32Array(n),\n    weight: new Uint32Array(n),\n    observation: new Uint32Array(n),\n    gene: new Uint16Array(n),\n  };\n  const group = new Int32Array(n);\n  for (let k = 0; k < n; k++) {\n    tile.x[k] = sx[k] / w[k];\n    tile.y[k] = sy[k] / w[k];\n    tile.z[k] = sz[k] / w[k];\n    tile.weight[k] = w[k];\n    tile.observation[k] = cells.dominant(k);\n    tile.gene[k] = genes.dominant(k);\n    group[k] = grp[k];\n  }\n  return { tile, group };\n}\n\n/**\n * Weighted tallies of u32 keys per entry, tracking each entry's dominant key as it goes:\n * the key with the largest total, the first seen on a tie.\n *\n * One map for every entry, keyed `entry · 2^32 + key` — exact while entries stay below\n * 2^21, far above any marker budget.\n */\nclass DominantTally {\n  private static readonly KEY_SPAN = 2 ** 32;\n  private readonly total = new Map<number, number>();\n  private readonly firstSeen = new Map<number, number>();\n  private seq = 0;\n  private readonly bestKey: number[] = [];\n  private readonly bestTotal: number[] = [];\n  private readonly bestSeen: number[] = [];\n\n  add(entry: number, key: number, weight: number): void {\n    const id = entry * DominantTally.KEY_SPAN + key;\n    const v = (this.total.get(id) ?? 0) + weight;\n    this.total.set(id, v);\n    let first = this.firstSeen.get(id);\n    if (first === undefined) {\n      first = this.seq++;\n      this.firstSeen.set(id, first);\n    }\n    const top = this.bestTotal[entry];\n    if (top === undefined || v > top || (v === top && first < this.bestSeen[entry])) {\n      this.bestKey[entry] = key;\n      this.bestTotal[entry] = v;\n      this.bestSeen[entry] = first;\n    }\n  }\n\n  dominant(entry: number): number {\n    return this.bestKey[entry] ?? 0;\n  }\n}\n\n// ── Cluster colours ───────────────────────────────────────────────────────────────────\n\n/**\n * The colour of each gene-tree cluster of a selection, for colouring transcripts by cluster: a\n * cluster named like a group of the cells' grouping takes that group's colour (its cells and its\n * transcripts agree); the others take palette colours in tree order. Clusters are the tree's\n * groups holding a selected gene, then each ungrouped selected gene on its own. Every gene of a\n * cluster gets the same colour — the tree's swatches and the markers use this one map.\n */\nexport function clusterColorMap(\n  genes: readonly string[],\n  groups: readonly { name: string; genes: readonly string[] }[],\n  cellColors: ReadonlyMap<string, string>,\n  palette: readonly string[],\n): Map<string, string> {\n  const chosen = new Set(genes);\n  const names: string[] = [];\n  const grouped = new Set<string>();\n  for (const g of groups) {\n    const mine = g.genes.filter((x) => chosen.has(x) && !grouped.has(x));\n    if (!mine.length) continue;\n    mine.forEach((x) => grouped.add(x));\n    names.push(g.name);\n  }\n  for (const gene of genes) if (!grouped.has(gene)) names.push(gene);\n  const out = new Map<string, string>();\n  let k = 0;\n  for (const name of names) {\n    if (out.has(name)) continue;\n    out.set(name, cellColors.get(name) ?? palette[k++ % palette.length]);\n  }\n  return out;\n}\n\n/** The cluster a selected gene is in: its first gene-tree group holding it, else itself. */\nexport function clusterOfGene(\n  gene: string,\n  groups: readonly { name: string; genes: readonly string[] }[],\n): string {\n  return groups.find((g) => g.genes.includes(gene))?.name ?? gene;\n}\n\n// ── Marker sizing ─────────────────────────────────────────────────────────────────────\n\n/** Smallest transcript marker, in canvas pixels. */\nexport const TRANSCRIPT_MIN_PX = 4;\n/** Largest transcript marker, in canvas pixels. */\nexport const TRANSCRIPT_MAX_PX = 32;\n/**\n * Physical diameter a single transcript is drawn at, in µm — clearly larger than the\n * imaged spot (~0.3 µm) so it stays legible, and small enough that neighbouring\n * molecules inside one cell stay apart.\n */\nexport const TRANSCRIPT_PHYSICAL_UM = 1.2;\n\n/**\n * Marker diameter in canvas pixels for an entry standing for `weight` transcripts.\n *\n * The convention spatial viewers share (deck.gl's `radiusMinPixels`/`radiusMaxPixels`,\n * Xenium Explorer's transcript size): a PHYSICAL size, clamped to a screen-pixel range.\n * Zoomed out, markers sit at the minimum and never vanish; zoomed in, they grow with the\n * tissue instead of shrinking to specks next to cells hundreds of pixels wide. A fixed\n * screen size does the opposite at high zoom, which is what made transcripts disappear\n * at pixel-level zoom.\n *\n * Aggregates grow with the cube root of their count: area ∝ count would let one dense\n * aggregate swallow its neighbours, the cube root keeps a 1000-transcript cluster clearly\n * larger than a 10-transcript one without covering the tile.\n *\n * `pxPerMicron` is omitted for data with no known physical unit; the marker is then\n * screen-sized only.\n */\nexport function transcriptMarkerPx(weight: number, scale = 1, pxPerMicron?: number): number {\n  const counted = TRANSCRIPT_MIN_PX * Math.cbrt(Math.max(1, weight));\n  const physical = pxPerMicron ? TRANSCRIPT_PHYSICAL_UM * pxPerMicron : 0;\n  const px = Math.max(counted, physical) * scale;\n  return Math.min(TRANSCRIPT_MAX_PX * Math.max(scale, 1), Math.max(TRANSCRIPT_MIN_PX * scale, px));\n}\n\n// ── All-gene transcripts: grouping under a marker budget ─────────────────────────────\n\n/**\n * How \"all genes\" is drawn at the current zoom: individual transcripts, a bin level, or nothing.\n */\nexport type AllGenesPlan = { kind: 'individual' } | { kind: 'bins'; level: number } | { kind: 'none' };\n\n/**\n * How to draw every transcript in view without exceeding `budget` markers.\n *\n * - The transcripts themselves, once the estimated count in view fits the budget.\n * - Otherwise the finest pyramid level whose bins are at least `minSpacingPx` apart on\n *   screen and number no more than the budget — groups big enough to read, few enough\n *   to draw.\n *\n * The count in view is estimated from the average density, which over- or under-shoots\n * locally; the renderer still caps what it draws, so an estimate is enough to choose.\n */\nexport function allGenesPlan(o: {\n  rect: DataRect;\n  bounds: SpatialBounds;\n  total: number;\n  pxPerUnit: number;\n  levels: readonly { binSize: number }[];\n  budget: number;\n  canIndividual: boolean;\n  minSpacingPx?: number;\n}): AllGenesPlan {\n  const area = visibleArea(o.rect, o.bounds);\n  if (!(area > 0)) return { kind: 'none' };\n  const b = o.bounds;\n  const density = o.total / Math.max(1, (b[2] - b[0]) * (b[3] - b[1]));\n  if (o.canIndividual && density * area <= o.budget) return { kind: 'individual' };\n  if (!o.levels.length) return { kind: 'none' };\n  const spacing = o.minSpacingPx ?? GROUP_MIN_SPACING_PX;\n  for (let l = 0; l < o.levels.length; l++) {\n    const bin = o.levels[l].binSize;\n    // Tissue rarely fills the view; 0.7 of the bins occupied is a fair guess.\n    if (bin * o.pxPerUnit >= spacing && (area / (bin * bin)) * 0.7 <= o.budget) {\n      return { kind: 'bins', level: l };\n    }\n  }\n  return { kind: 'bins', level: o.levels.length - 1 };\n}\n\n/**\n * Diameter in px of a group of `count` transcripts in a bin `binPx` wide, where\n * `refCount` is a typical busy bin in view (its 95th percentile).\n *\n * Area grows with the count — a bin with a quarter of the transcripts gets half the\n * diameter — between a third of the bin (so a sparse bin is still visible) and a little\n * over the full bin (so dense neighbours just touch rather than pile up).\n */\nexport function groupedMarkerPx(count: number, refCount: number, binPx: number, scale = 1): number {\n  const f = Math.sqrt(Math.min(1, count / Math.max(1, refCount)));\n  const d = binPx * (0.35 + 0.75 * f) * scale;\n  return Math.max(TRANSCRIPT_MIN_PX * scale, Math.min(d, binPx * 1.2 * Math.max(scale, 1)));\n}\n\n/** The `p` quantile (0..1) of a count vector — a sample of it for large vectors. */\nexport function quantileOf(values: ArrayLike<number>, p: number): number {\n  return quantile(values, p, { sampleSize: 4096 }) ?? 0;\n}\n"]}