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

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

@@ -0,0 +1,264 @@
+/** An empty selection over `count` observations. */
+export function emptySelection(count = 0) {
+    return { mask: new Uint8Array(count), count: 0 };
+}
+/** Number of set entries in a mask. */
+export function countMask(mask) {
+    let n = 0;
+    for (let i = 0; i < mask.length; i++)
+        if (mask[i])
+            n++;
+    return n;
+}
+/** Selected indices, for export or a downstream query. */
+export function maskToIndices(mask) {
+    const out = new Uint32Array(countMask(mask));
+    let at = 0;
+    for (let i = 0; i < mask.length; i++)
+        if (mask[i])
+            out[at++] = i;
+    return out;
+}
+/**
+ * Renderer-facing inverse: which observations to MUTE. With nothing selected
+ * nothing is muted (the whole tissue reads normally); with a selection, every
+ * unselected observation is muted — the CosMx highlight-vs-mute rule.
+ */
+export function mutedFromSelection(selection) {
+    if (selection.count === 0)
+        return null;
+    const muted = new Uint8Array(selection.mask.length);
+    for (let i = 0; i < muted.length; i++)
+        muted[i] = selection.mask[i] ? 0 : 1;
+    return muted;
+}
+/** Even-odd ray cast: is (px, py) inside the closed ring xs/ys? */
+export function pointInRing(xs, ys, px, py) {
+    let inside = false;
+    const n = xs.length;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const yi = ys[i];
+        const yj = ys[j];
+        // Half-open comparison so a vertex on the ray is counted once, not twice.
+        if ((yi > py) !== (yj > py)) {
+            const t = (py - yi) / (yj - yi);
+            if (px < xs[i] + t * (xs[j] - xs[i]))
+                inside = !inside;
+        }
+    }
+    return inside;
+}
+function ringBounds(xs, ys) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (let i = 0; i < xs.length; i++) {
+        if (xs[i] < minX)
+            minX = xs[i];
+        if (xs[i] > maxX)
+            maxX = xs[i];
+        if (ys[i] < minY)
+            minY = ys[i];
+        if (ys[i] > maxY)
+            maxY = ys[i];
+    }
+    return { minX, minY, maxX, maxY };
+}
+function inBounds(b, px, py) {
+    return px >= b.minX && px <= b.maxX && py >= b.minY && py <= b.maxY;
+}
+/** Polygon-with-holes: inside the exterior and outside every hole. */
+function polygonShape(xs, ys, holes) {
+    if (xs.length < 3)
+        return null;
+    const bounds = ringBounds(xs, ys);
+    return {
+        bounds,
+        hit: (px, py) => {
+            if (!pointInRing(xs, ys, px, py))
+                return false;
+            // The region model is explicit: a point inside the exterior AND inside a
+            // hole is OUTSIDE the region.
+            for (const ring of holes ?? []) {
+                if (ring.length >= 3
+                    && pointInRing(ring.map((p) => p[0]), ring.map((p) => p[1]), px, py)) {
+                    return false;
+                }
+            }
+            return true;
+        },
+    };
+}
+/**
+ * Flatten a region to testable shapes. Returns an empty array for anything that
+ * encloses no area — an open polyline, an intensity-profile line, a degenerate
+ * rectangle — so those never contribute to a selection.
+ */
+export function regionShapes(region) {
+    // Profile lines belong to the intensity tool, not the annotation set.
+    if (region?.kind === 'profile')
+        return [];
+    const b = region?.bounds;
+    if (!b)
+        return [];
+    if (Array.isArray(b.polygons)) {
+        return b.polygons.flatMap((p) => p.closed === false ? [] : (polygonShape(p.xpoints ?? [], p.ypoints ?? [], p.holes) ?? []));
+    }
+    if (Array.isArray(b.xpoints)) {
+        if (b.closed === false)
+            return []; // open polyline encloses nothing
+        const shape = polygonShape(b.xpoints, b.ypoints ?? [], b.holes);
+        return shape ? [shape] : [];
+    }
+    if (typeof b.width === 'number' && typeof b.height === 'number') {
+        const x = b.x ?? 0;
+        const y = b.y ?? 0;
+        // Normalise a rectangle dragged right-to-left / bottom-to-top.
+        const minX = Math.min(x, x + b.width);
+        const maxX = Math.max(x, x + b.width);
+        const minY = Math.min(y, y + b.height);
+        const maxY = Math.max(y, y + b.height);
+        if (maxX === minX || maxY === minY)
+            return [];
+        const bounds = { minX, minY, maxX, maxY };
+        return [{ bounds, hit: (px, py) => inBounds(bounds, px, py) }];
+    }
+    return [];
+}
+/**
+ * Observations inside ANY of `regions` (union). Coordinates are transformed by
+ * `imageRef` first, so the test happens in the same world space the regions were
+ * drawn in.
+ *
+ * `candidates`, when given, restricts the test to those observation indices — how
+ * a 2D view of a 3D dataset keeps a drawn region meaning what it looks like it
+ * means: the shape was drawn over ONE section, so it selects that section's cells
+ * rather than the whole depth of the specimen behind them. The returned mask stays
+ * indexed by observation, so every consumer (charts, legend, the 3D cloud) reads it
+ * the same way.
+ */
+/**
+ * A selection from an explicit list of observation indices.
+ *
+ * What a lasso in a linked plot produces: the plot knows which points the user drew
+ * around, and the map needs that as a mask over ALL observations. Out-of-range and
+ * duplicate indices are ignored rather than rejected — a plot may hand back the same
+ * point twice, and a stale index from a plot drawn before a dataset change must not
+ * throw in the middle of a selection gesture.
+ */
+export function selectByIndices(indices, observationCount) {
+    const mask = new Uint8Array(observationCount);
+    let count = 0;
+    for (const i of indices) {
+        if (!Number.isInteger(i) || i < 0 || i >= observationCount)
+            continue;
+        if (mask[i])
+            continue;
+        mask[i] = 1;
+        count++;
+    }
+    return { mask, count };
+}
+export function selectInRegions(observations, imageRef, regions, candidates) {
+    const n = observations.count;
+    const mask = new Uint8Array(n);
+    const shapes = regions.flatMap((r) => regionShapes(r));
+    if (shapes.length === 0)
+        return { mask, count: 0 };
+    const [sx, sy] = imageRef?.scale ?? [1, 1];
+    const [tx, ty] = imageRef?.translate ?? [0, 0];
+    let count = 0;
+    const total = candidates ? candidates.length : n;
+    for (let k = 0; k < total; k++) {
+        const i = candidates ? candidates[k] : k;
+        const px = observations.x[i] * sx + tx;
+        const py = observations.y[i] * sy + ty;
+        for (const shape of shapes) {
+            // Bounds first: a ray cast per observation per region would dominate at
+            // 10^5 observations, and most points miss most regions.
+            if (!inBounds(shape.bounds, px, py))
+                continue;
+            if (shape.hit(px, py)) {
+                mask[i] = 1;
+                count++;
+                break;
+            }
+        }
+    }
+    return { mask, count };
+}
+/**
+ * Select observations whose SCREEN projection falls inside the drawn regions.
+ *
+ * This is how a region selection works in the 3D cloud. There is no data-space
+ * affine to map a drawn shape through, because the shape was drawn on a 2D screen
+ * against a perspective camera — so the observations come the other way, already
+ * projected to canvas pixels by the renderer (which owns the camera), and the
+ * regions are tested in that same screen space.
+ *
+ * The consequence is worth being explicit about: a screen-space lasso selects
+ * through the WHOLE DEPTH of the cloud, like a cookie cutter, not a slab at some
+ * chosen z. That is inherent to drawing on a flat screen, and it is what napari
+ * and every other orbit-camera point picker do. Orbit and draw again to cut from
+ * another angle.
+ *
+ * `screen` is `[x0, y0, x1, y1, …]` in canvas pixels, `count` entries long. An
+ * observation the camera puts behind the eye is given NaN by the projector and
+ * never selected.
+ */
+export function selectInRegionsProjected(screen, count, regions) {
+    const mask = new Uint8Array(count);
+    const shapes = regions.flatMap((r) => regionShapes(r));
+    if (shapes.length === 0)
+        return { mask, count: 0 };
+    let hits = 0;
+    for (let i = 0; i < count; i++) {
+        const px = screen[i * 2];
+        const py = screen[i * 2 + 1];
+        // Behind the camera, or otherwise unprojectable.
+        if (!Number.isFinite(px) || !Number.isFinite(py))
+            continue;
+        for (const shape of shapes) {
+            if (!inBounds(shape.bounds, px, py))
+                continue;
+            if (shape.hit(px, py)) {
+                mask[i] = 1;
+                hits++;
+                break;
+            }
+        }
+    }
+    return { mask, count: hits };
+}
+/** Every observation whose categorical code equals `code` — the legend click. */
+/**
+ * Whether two selections hold exactly the same observations.
+ *
+ * Lets a click toggle against the SELECTION rather than against a remembered
+ * click: picking a class in the legend and then clicking that same class on the
+ * canvas should clear it, and a remembered click cannot know about the legend.
+ * Counts are compared first, so two different selections usually cost nothing.
+ */
+export function sameSelection(a, b) {
+    if (a.count !== b.count)
+        return false;
+    if (a.mask.length !== b.mask.length)
+        return false;
+    for (let i = 0; i < a.mask.length; i++) {
+        // Normalised to 0/1: the masks are flags, and a writer is free to use any
+        // non-zero value for "selected".
+        if ((a.mask[i] ? 1 : 0) !== (b.mask[i] ? 1 : 0))
+            return false;
+    }
+    return true;
+}
+export function selectByCategory(codes, code) {
+    const mask = new Uint8Array(codes.length);
+    let count = 0;
+    for (let i = 0; i < codes.length; i++) {
+        if (codes[i] === code) {
+            mask[i] = 1;
+            count++;
+        }
+    }
+    return { mask, count };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"spatial-selection.js","sourceRoot":"","sources":["../../../../src/lib/spatial/spatial-selection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Region } from '../models/region';\nimport { SpatialImageRef, SpatialObservations } from '../contracts/spatial-dataset.contract';\n\n/**\n * Which observations fall inside a set of drawn regions.\n *\n * Pure, like `spatial-encoding.ts` — no store, no renderer — so the geometry is\n * testable on its own.\n *\n * WHY THIS IS THE WHOLE SELECTION MECHANISM\n * -----------------------------------------\n * Regions already come from every on-canvas tool the library has: rectangle,\n * polygon, freehand, magic wand, brush. Testing observations against them turns\n * all of those into spatial-omics selection tools without adding a single new\n * canvas interaction — which is why there is no bespoke marquee here.\n *\n * COORDINATE FRAMES\n * -----------------\n * Regions are drawn in WORLD (image) coordinates. Observations live in the\n * dataset's own frame and reach the world through `imageRef` — so they are\n * transformed forward before testing, matching exactly what the renderer draws.\n */\n\n/** A selection over N observations: `mask[i] === 1` when i is selected. */\nexport interface SpatialSelectionMask {\n  mask: Uint8Array;\n  count: number;\n}\n\n/** An empty selection over `count` observations. */\nexport function emptySelection(count = 0): SpatialSelectionMask {\n  return { mask: new Uint8Array(count), count: 0 };\n}\n\n/** Number of set entries in a mask. */\nexport function countMask(mask: Uint8Array): number {\n  let n = 0;\n  for (let i = 0; i < mask.length; i++) if (mask[i]) n++;\n  return n;\n}\n\n/** Selected indices, for export or a downstream query. */\nexport function maskToIndices(mask: Uint8Array): Uint32Array {\n  const out = new Uint32Array(countMask(mask));\n  let at = 0;\n  for (let i = 0; i < mask.length; i++) if (mask[i]) out[at++] = i;\n  return out;\n}\n\n/**\n * Renderer-facing inverse: which observations to MUTE. With nothing selected\n * nothing is muted (the whole tissue reads normally); with a selection, every\n * unselected observation is muted — the CosMx highlight-vs-mute rule.\n */\nexport function mutedFromSelection(selection: SpatialSelectionMask): Uint8Array | null {\n  if (selection.count === 0) return null;\n  const muted = new Uint8Array(selection.mask.length);\n  for (let i = 0; i < muted.length; i++) muted[i] = selection.mask[i] ? 0 : 1;\n  return muted;\n}\n\n/** Even-odd ray cast: is (px, py) inside the closed ring xs/ys? */\nexport function pointInRing(xs: readonly number[], ys: readonly number[], px: number, py: number): boolean {\n  let inside = false;\n  const n = xs.length;\n  for (let i = 0, j = n - 1; i < n; j = i++) {\n    const yi = ys[i];\n    const yj = ys[j];\n    // Half-open comparison so a vertex on the ray is counted once, not twice.\n    if ((yi > py) !== (yj > py)) {\n      const t = (py - yi) / (yj - yi);\n      if (px < xs[i] + t * (xs[j] - xs[i])) inside = !inside;\n    }\n  }\n  return inside;\n}\n\n/** Axis-aligned bounds of a ring, for a cheap reject before the ray cast. */\ninterface Bounds { minX: number; minY: number; maxX: number; maxY: number }\n\nfunction ringBounds(xs: readonly number[], ys: readonly number[]): Bounds {\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  for (let i = 0; i < xs.length; i++) {\n    if (xs[i] < minX) minX = xs[i];\n    if (xs[i] > maxX) maxX = xs[i];\n    if (ys[i] < minY) minY = ys[i];\n    if (ys[i] > maxY) maxY = ys[i];\n  }\n  return { minX, minY, maxX, maxY };\n}\n\nfunction inBounds(b: Bounds, px: number, py: number): boolean {\n  return px >= b.minX && px <= b.maxX && py >= b.minY && py <= b.maxY;\n}\n\n/** A region flattened to something testable: bounds + a hit test. */\ninterface Shape {\n  bounds: Bounds;\n  hit(px: number, py: number): boolean;\n}\n\n/** Polygon-with-holes: inside the exterior and outside every hole. */\nfunction polygonShape(\n  xs: number[], ys: number[], holes?: number[][][],\n): Shape | null {\n  if (xs.length < 3) return null;\n  const bounds = ringBounds(xs, ys);\n  return {\n    bounds,\n    hit: (px, py) => {\n      if (!pointInRing(xs, ys, px, py)) return false;\n      // The region model is explicit: a point inside the exterior AND inside a\n      // hole is OUTSIDE the region.\n      for (const ring of holes ?? []) {\n        if (ring.length >= 3\n          && pointInRing(ring.map((p) => p[0]), ring.map((p) => p[1]), px, py)) {\n          return false;\n        }\n      }\n      return true;\n    },\n  };\n}\n\n/**\n * Flatten a region to testable shapes. Returns an empty array for anything that\n * encloses no area — an open polyline, an intensity-profile line, a degenerate\n * rectangle — so those never contribute to a selection.\n */\nexport function regionShapes(region: Region): Shape[] {\n  // Profile lines belong to the intensity tool, not the annotation set.\n  if ((region as unknown as { kind?: string })?.kind === 'profile') return [];\n  const b = region?.bounds as unknown as {\n    x?: number; y?: number; width?: number; height?: number;\n    xpoints?: number[]; ypoints?: number[]; closed?: boolean; holes?: number[][][];\n    polygons?: { xpoints: number[]; ypoints: number[]; closed?: boolean; holes?: number[][][] }[];\n  } | null | undefined;\n  if (!b) return [];\n\n  if (Array.isArray(b.polygons)) {\n    return b.polygons.flatMap((p) =>\n      p.closed === false ? [] : (polygonShape(p.xpoints ?? [], p.ypoints ?? [], p.holes) ?? []));\n  }\n  if (Array.isArray(b.xpoints)) {\n    if (b.closed === false) return []; // open polyline encloses nothing\n    const shape = polygonShape(b.xpoints, b.ypoints ?? [], b.holes);\n    return shape ? [shape] : [];\n  }\n  if (typeof b.width === 'number' && typeof b.height === 'number') {\n    const x = b.x ?? 0;\n    const y = b.y ?? 0;\n    // Normalise a rectangle dragged right-to-left / bottom-to-top.\n    const minX = Math.min(x, x + b.width);\n    const maxX = Math.max(x, x + b.width);\n    const minY = Math.min(y, y + b.height);\n    const maxY = Math.max(y, y + b.height);\n    if (maxX === minX || maxY === minY) return [];\n    const bounds = { minX, minY, maxX, maxY };\n    return [{ bounds, hit: (px, py) => inBounds(bounds, px, py) }];\n  }\n  return [];\n}\n\n/**\n * Observations inside ANY of `regions` (union). Coordinates are transformed by\n * `imageRef` first, so the test happens in the same world space the regions were\n * drawn in.\n *\n * `candidates`, when given, restricts the test to those observation indices — how\n * a 2D view of a 3D dataset keeps a drawn region meaning what it looks like it\n * means: the shape was drawn over ONE section, so it selects that section's cells\n * rather than the whole depth of the specimen behind them. The returned mask stays\n * indexed by observation, so every consumer (charts, legend, the 3D cloud) reads it\n * the same way.\n */\n/**\n * A selection from an explicit list of observation indices.\n *\n * What a lasso in a linked plot produces: the plot knows which points the user drew\n * around, and the map needs that as a mask over ALL observations. Out-of-range and\n * duplicate indices are ignored rather than rejected — a plot may hand back the same\n * point twice, and a stale index from a plot drawn before a dataset change must not\n * throw in the middle of a selection gesture.\n */\nexport function selectByIndices(\n  indices: Iterable<number>, observationCount: number,\n): SpatialSelectionMask {\n  const mask = new Uint8Array(observationCount);\n  let count = 0;\n  for (const i of indices) {\n    if (!Number.isInteger(i) || i < 0 || i >= observationCount) continue;\n    if (mask[i]) continue;\n    mask[i] = 1;\n    count++;\n  }\n  return { mask, count };\n}\n\nexport function selectInRegions(\n  observations: SpatialObservations,\n  imageRef: SpatialImageRef | undefined,\n  regions: readonly Region[],\n  candidates?: Uint32Array,\n): SpatialSelectionMask {\n  const n = observations.count;\n  const mask = new Uint8Array(n);\n  const shapes = regions.flatMap((r) => regionShapes(r));\n  if (shapes.length === 0) return { mask, count: 0 };\n\n  const [sx, sy] = imageRef?.scale ?? [1, 1];\n  const [tx, ty] = imageRef?.translate ?? [0, 0];\n  let count = 0;\n  const total = candidates ? candidates.length : n;\n  for (let k = 0; k < total; k++) {\n    const i = candidates ? candidates[k] : k;\n    const px = observations.x[i] * sx + tx;\n    const py = observations.y[i] * sy + ty;\n    for (const shape of shapes) {\n      // Bounds first: a ray cast per observation per region would dominate at\n      // 10^5 observations, and most points miss most regions.\n      if (!inBounds(shape.bounds, px, py)) continue;\n      if (shape.hit(px, py)) {\n        mask[i] = 1;\n        count++;\n        break;\n      }\n    }\n  }\n  return { mask, count };\n}\n\n/**\n * Select observations whose SCREEN projection falls inside the drawn regions.\n *\n * This is how a region selection works in the 3D cloud. There is no data-space\n * affine to map a drawn shape through, because the shape was drawn on a 2D screen\n * against a perspective camera — so the observations come the other way, already\n * projected to canvas pixels by the renderer (which owns the camera), and the\n * regions are tested in that same screen space.\n *\n * The consequence is worth being explicit about: a screen-space lasso selects\n * through the WHOLE DEPTH of the cloud, like a cookie cutter, not a slab at some\n * chosen z. That is inherent to drawing on a flat screen, and it is what napari\n * and every other orbit-camera point picker do. Orbit and draw again to cut from\n * another angle.\n *\n * `screen` is `[x0, y0, x1, y1, …]` in canvas pixels, `count` entries long. An\n * observation the camera puts behind the eye is given NaN by the projector and\n * never selected.\n */\nexport function selectInRegionsProjected(\n  screen: Float32Array,\n  count: number,\n  regions: readonly Region[],\n): SpatialSelectionMask {\n  const mask = new Uint8Array(count);\n  const shapes = regions.flatMap((r) => regionShapes(r));\n  if (shapes.length === 0) return { mask, count: 0 };\n\n  let hits = 0;\n  for (let i = 0; i < count; i++) {\n    const px = screen[i * 2];\n    const py = screen[i * 2 + 1];\n    // Behind the camera, or otherwise unprojectable.\n    if (!Number.isFinite(px) || !Number.isFinite(py)) continue;\n    for (const shape of shapes) {\n      if (!inBounds(shape.bounds, px, py)) continue;\n      if (shape.hit(px, py)) {\n        mask[i] = 1;\n        hits++;\n        break;\n      }\n    }\n  }\n  return { mask, count: hits };\n}\n\n/** Every observation whose categorical code equals `code` — the legend click. */\n/**\n * Whether two selections hold exactly the same observations.\n *\n * Lets a click toggle against the SELECTION rather than against a remembered\n * click: picking a class in the legend and then clicking that same class on the\n * canvas should clear it, and a remembered click cannot know about the legend.\n * Counts are compared first, so two different selections usually cost nothing.\n */\nexport function sameSelection(a: SpatialSelectionMask, b: SpatialSelectionMask): boolean {\n  if (a.count !== b.count) return false;\n  if (a.mask.length !== b.mask.length) return false;\n  for (let i = 0; i < a.mask.length; i++) {\n    // Normalised to 0/1: the masks are flags, and a writer is free to use any\n    // non-zero value for \"selected\".\n    if ((a.mask[i] ? 1 : 0) !== (b.mask[i] ? 1 : 0)) return false;\n  }\n  return true;\n}\n\nexport function selectByCategory(codes: Uint16Array, code: number): SpatialSelectionMask {\n  const mask = new Uint8Array(codes.length);\n  let count = 0;\n  for (let i = 0; i < codes.length; i++) {\n    if (codes[i] === code) {\n      mask[i] = 1;\n      count++;\n    }\n  }\n  return { mask, count };\n}\n"]}

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

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

package/esm2022/lib/spatial/tsne-worker.mjs

@@ -0,0 +1,10 @@
+/**
+ * Factory for the t-SNE Web Worker, isolated in its own module so the `import.meta.url`
+ * reference — which the bundler needs in order to locate the worker — is never pulled
+ * into the ts-jest CommonJS compile of anything that uses it. Unit tests `jest.mock` this
+ * module, or pass their own factory. Same arrangement as `mask-worker.ts`.
+ */
+export function createTsneWorker() {
+    return new Worker(new URL('./tsne.worker', import.meta.url), { type: 'module' });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNuZS13b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NwYXRpYWwvdHNuZS13b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsZ0JBQWdCO0lBQzlCLE9BQU8sSUFBSSxNQUFNLENBQUMsSUFBSSxHQUFHLENBQUMsZUFBZSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztBQUNuRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBGYWN0b3J5IGZvciB0aGUgdC1TTkUgV2ViIFdvcmtlciwgaXNvbGF0ZWQgaW4gaXRzIG93biBtb2R1bGUgc28gdGhlIGBpbXBvcnQubWV0YS51cmxgXG4gKiByZWZlcmVuY2Ug4oCUIHdoaWNoIHRoZSBidW5kbGVyIG5lZWRzIGluIG9yZGVyIHRvIGxvY2F0ZSB0aGUgd29ya2VyIOKAlCBpcyBuZXZlciBwdWxsZWRcbiAqIGludG8gdGhlIHRzLWplc3QgQ29tbW9uSlMgY29tcGlsZSBvZiBhbnl0aGluZyB0aGF0IHVzZXMgaXQuIFVuaXQgdGVzdHMgYGplc3QubW9ja2AgdGhpc1xuICogbW9kdWxlLCBvciBwYXNzIHRoZWlyIG93biBmYWN0b3J5LiBTYW1lIGFycmFuZ2VtZW50IGFzIGBtYXNrLXdvcmtlci50c2AuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVUc25lV29ya2VyKCk6IFdvcmtlciB7XG4gIHJldHVybiBuZXcgV29ya2VyKG5ldyBVUkwoJy4vdHNuZS53b3JrZXInLCBpbXBvcnQubWV0YS51cmwpLCB7IHR5cGU6ICdtb2R1bGUnIH0pO1xufVxuIl19

package/esm2022/lib/spatial/world-grid.mjs

@@ -0,0 +1,77 @@
+/**
+ * How finely a drawn shape's vertices may be placed in world space.
+ *
+ * Region geometry has always been stored in whole world units, and for an image that is
+ * exactly right: world units ARE pixels, a region should align to them, and integers keep
+ * the stored geometry exact and tidy.
+ *
+ * It is wrong for a dataset whose coordinates are not pixels. seqFISH's observations span
+ * about 5 x 7 units in total, so snapping vertices to integers leaves roughly SIX BY EIGHT
+ * distinct positions in the whole sample — every ROI collapses to the same handful of
+ * boxes and drawing a fine shape is not possible at any zoom. Nothing errors; the tool
+ * simply cannot express what the user is drawing.
+ *
+ * So the step is chosen from the world's own extent rather than assumed to be one. An
+ * image keeps integers, because its extent is thousands of units and a finer step would
+ * buy nothing; a unitless dataset gets a step fine enough to draw with.
+ *
+ * Pure — no renderer, no store — so both region overlays can share one answer, and the
+ * napari and OSD paths cannot drift into disagreeing about what a vertex may be.
+ */
+/** One world unit: the step for a world whose units are image pixels. */
+export const PIXEL_WORLD_QUANTUM = 1;
+/**
+ * Distinct positions a drawn shape should be able to reach across the world's extent.
+ *
+ * Set by what a person can actually place with a pointer, not by float precision: a few
+ * thousand steps across the sample is finer than any screen it will be drawn on, so the
+ * limit stops being the grid and becomes the hand.
+ */
+export const WORLD_GRID_STEPS = 4096;
+/**
+ * The step size for a world of this extent, for a world whose units are NOT pixels.
+ *
+ * The caller decides which world it has, because the extent cannot say: a 2,000 unit world
+ * is a small slide if the units are pixels and an enormous one if they are microns, and
+ * only the caller knows which. An image keeps {@link PIXEL_WORLD_QUANTUM} by never asking.
+ *
+ * Never returns anything coarser than {@link PIXEL_WORLD_QUANTUM}. A non-pixel world can
+ * still be large — the Allen atlas is ~11,000 microns across — and there a finer step than
+ * one unit buys nothing.
+ *
+ * Rounded DOWN to a power of ten, so the step is a number a person reading the stored
+ * geometry can recognise — 0.001 rather than 0.0017044 — and so it does not shift when the
+ * extent changes slightly between datasets.
+ *
+ * A non-finite or empty extent falls back to the pixel grid: an unknown world is treated
+ * as the conservative, established case rather than given an invented precision.
+ */
+export function worldQuantumForExtent(spanX, spanY) {
+    const span = Math.max(spanX, spanY);
+    if (!Number.isFinite(span) || span <= 0)
+        return PIXEL_WORLD_QUANTUM;
+    const wanted = span / WORLD_GRID_STEPS;
+    if (wanted >= PIXEL_WORLD_QUANTUM)
+        return PIXEL_WORLD_QUANTUM;
+    return 10 ** Math.floor(Math.log10(wanted));
+}
+/**
+ * Snap one world coordinate to the grid.
+ *
+ * A step of zero or less means no snapping — the caller keeps full float precision.
+ * Division and multiplication by the step leaves a float artefact (0.001 * 3 is not
+ * exactly 0.003), so the result is rounded to the step's own number of decimals; without
+ * that, "tidy" geometry acquires a trail of digits the grid was supposed to remove.
+ */
+export function snapToWorldGrid(value, quantum) {
+    if (!Number.isFinite(value))
+        return value;
+    if (!Number.isFinite(quantum) || quantum <= 0)
+        return value;
+    if (quantum === PIXEL_WORLD_QUANTUM)
+        return Math.round(value);
+    const snapped = Math.round(value / quantum) * quantum;
+    const decimals = Math.max(0, Math.min(20, -Math.floor(Math.log10(quantum))));
+    return Number(snapped.toFixed(decimals));
+}
+//# sourceMappingURL=data:application/json;base64,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