@jax-data-science/sci-image-visualizer 0.17.0 → 0.18.0

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

@@ -0,0 +1,83 @@
+import { isCategoricalColumn, } from '../contracts/spatial-dataset.contract';
+import { cellTypeColumnFor } from './lod';
+import { categoryColorsFor } from './spatial-encoding';
+/**
+ * The observations of a selection (a mask), described: how many, by the grouping they are coloured
+ * by (else the cell types), the mean of a few measurements — or, for one cell, its id, its groups
+ * and its values. Pure but for the port's columns (cached by it).
+ */
+/** At most this many measurements (continuous columns) are given. */
+export const OBSERVATION_DETAIL_COLUMNS = 6;
+/**
+ * Describe the observations `mask` selects (see {@link ObservationsDescription}): counted by the
+ * categorical column the view colours by, else the cell-type column; at most `maxMeasures`
+ * continuous columns averaged (or read, for one cell).
+ */
+export async function describeObservations(port, dataset, view, mask, maxMeasures = OBSERVATION_DETAIL_COLUMNS) {
+    const indices = [];
+    for (let i = 0; i < mask.length; i++)
+        if (mask[i])
+            indices.push(i);
+    const total = indices.length;
+    const one = total === 1 ? indices[0] : -1;
+    const categorical = dataset.columns.filter((c) => c.kind === 'categorical');
+    const colored = view.colorBy?.kind === 'column' ? view.colorBy.name : null;
+    const groupColumn = (colored && categorical.some((c) => c.name === colored) ? colored : null) ?? cellTypeColumnFor(dataset, view);
+    let groups = [];
+    const measures = [];
+    if (groupColumn && total) {
+        const column = await port.getColumn(groupColumn);
+        if (isCategoricalColumn(column)) {
+            const categories = column.meta.categories;
+            const colors = categoryColorsFor(groupColumn, column.meta, view.groupColors);
+            const counts = new Map();
+            for (const i of indices)
+                counts.set(column.codes[i], (counts.get(column.codes[i]) ?? 0) + 1);
+            groups = [...counts.entries()]
+                .map(([code, count]) => ({
+                name: categories[code] ?? '(none)',
+                count,
+                color: colors[code] ?? '#9e9e9e',
+            }))
+                .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+        }
+    }
+    if (total) {
+        // One cell: its other groupings first (its type, its cluster…), as text.
+        if (one >= 0) {
+            for (const meta of categorical.filter((c) => c.name !== groupColumn).slice(0, maxMeasures)) {
+                const column = await port.getColumn(meta.name);
+                if (!isCategoricalColumn(column))
+                    continue;
+                const name = column.meta.categories[column.codes[one]];
+                if (name !== undefined)
+                    measures.push({ name: meta.name, value: name, mean: false });
+            }
+        }
+        const continuous = dataset.columns.filter((c) => c.kind === 'continuous');
+        for (const meta of continuous.slice(0, maxMeasures)) {
+            const column = await port.getColumn(meta.name);
+            if (isCategoricalColumn(column))
+                continue;
+            let sum = 0;
+            let n = 0;
+            for (const i of indices) {
+                const v = column.values[i];
+                if (Number.isFinite(v)) {
+                    sum += v;
+                    n++;
+                }
+            }
+            if (n)
+                measures.push({ name: meta.name, value: sum / n, unit: meta.unit, mean: one < 0 });
+        }
+    }
+    return {
+        total,
+        groupColumn: groups.length ? groupColumn : null,
+        groups,
+        measures,
+        ...(one >= 0 ? { cellId: dataset.observations.ids?.[one] ?? String(one) } : {}),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"observations-in-selection.js","sourceRoot":"","sources":["../../../../src/lib/spatial/observations-in-selection.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SpatialViewState } from '../contracts/display-types';\nimport type { SpatialDataPort } from '../contracts/ports/spatial-data.port';\nimport {\n  type CategoricalColumnMeta,\n  type ContinuousColumnMeta,\n  type SpatialDataset,\n  isCategoricalColumn,\n} from '../contracts/spatial-dataset.contract';\nimport { cellTypeColumnFor } from './lod';\nimport { categoryColorsFor } from './spatial-encoding';\n\n/**\n * The observations of a selection (a mask), described: how many, by the grouping they are coloured\n * by (else the cell types), the mean of a few measurements — or, for one cell, its id, its groups\n * and its values. Pure but for the port's columns (cached by it).\n */\n\n/** At most this many measurements (continuous columns) are given. */\nexport const OBSERVATION_DETAIL_COLUMNS = 6;\n\n/** One group's observations in the selection. */\nexport interface GroupCount {\n  name: string;\n  count: number;\n  /** The group's colour, as the legend shows it. */\n  color: string;\n}\n\n/** What {@link describeObservations} finds. */\nexport interface ObservationsDescription {\n  total: number;\n  /** The grouping the observations are counted by, or null when the dataset has none. */\n  groupColumn: string | null;\n  /** Groups by count, most first (empty groups left out). */\n  groups: GroupCount[];\n  /**\n   * A few measurements: the mean over the selection (`mean` true), or one cell's own values. With\n   * one cell, its other groupings come first, as text.\n   */\n  measures: { name: string; value: string | number; unit?: string; mean: boolean }[];\n  /** The one cell's id, when the selection is one cell. */\n  cellId?: string;\n}\n\n/**\n * Describe the observations `mask` selects (see {@link ObservationsDescription}): counted by the\n * categorical column the view colours by, else the cell-type column; at most `maxMeasures`\n * continuous columns averaged (or read, for one cell).\n */\nexport async function describeObservations(\n  port: Pick<SpatialDataPort, 'getColumn'>,\n  dataset: SpatialDataset,\n  view: Pick<SpatialViewState, 'colorBy' | 'cellTypeColumn' | 'groupColors'>,\n  mask: Uint8Array,\n  maxMeasures = OBSERVATION_DETAIL_COLUMNS,\n): Promise<ObservationsDescription> {\n  const indices: number[] = [];\n  for (let i = 0; i < mask.length; i++) if (mask[i]) indices.push(i);\n  const total = indices.length;\n  const one = total === 1 ? indices[0] : -1;\n\n  const categorical = dataset.columns.filter((c): c is CategoricalColumnMeta => c.kind === 'categorical');\n  const colored = view.colorBy?.kind === 'column' ? view.colorBy.name : null;\n  const groupColumn =\n    (colored && categorical.some((c) => c.name === colored) ? colored : null) ?? cellTypeColumnFor(dataset, view);\n\n  let groups: GroupCount[] = [];\n  const measures: ObservationsDescription['measures'] = [];\n  if (groupColumn && total) {\n    const column = await port.getColumn(groupColumn);\n    if (isCategoricalColumn(column)) {\n      const categories = column.meta.categories;\n      const colors = categoryColorsFor(groupColumn, column.meta, view.groupColors);\n      const counts = new Map<number, number>();\n      for (const i of indices) counts.set(column.codes[i], (counts.get(column.codes[i]) ?? 0) + 1);\n      groups = [...counts.entries()]\n        .map(([code, count]) => ({\n          name: categories[code] ?? '(none)',\n          count,\n          color: colors[code] ?? '#9e9e9e',\n        }))\n        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));\n    }\n  }\n\n  if (total) {\n    // One cell: its other groupings first (its type, its cluster…), as text.\n    if (one >= 0) {\n      for (const meta of categorical.filter((c) => c.name !== groupColumn).slice(0, maxMeasures)) {\n        const column = await port.getColumn(meta.name);\n        if (!isCategoricalColumn(column)) continue;\n        const name = column.meta.categories[column.codes[one]];\n        if (name !== undefined) measures.push({ name: meta.name, value: name, mean: false });\n      }\n    }\n    const continuous = dataset.columns.filter((c): c is ContinuousColumnMeta => c.kind === 'continuous');\n    for (const meta of continuous.slice(0, maxMeasures)) {\n      const column = await port.getColumn(meta.name);\n      if (isCategoricalColumn(column)) continue;\n      let sum = 0;\n      let n = 0;\n      for (const i of indices) {\n        const v = column.values[i];\n        if (Number.isFinite(v)) {\n          sum += v;\n          n++;\n        }\n      }\n      if (n) measures.push({ name: meta.name, value: sum / n, unit: meta.unit, mean: one < 0 });\n    }\n  }\n\n  return {\n    total,\n    groupColumn: groups.length ? groupColumn : null,\n    groups,\n    measures,\n    ...(one >= 0 ? { cellId: dataset.observations.ids?.[one] ?? String(one) } : {}),\n  };\n}\n"]}

package/esm2022/lib/spatial/plane-cells.mjs

@@ -0,0 +1,119 @@
+/**
+ * A 3D segmentation's cells on one plane as the 2D view's cell layer draws them: the outlines of a
+ * boundary set's region set (`SpatialPolygonTilesMeta.sets[i].regionSource`, every cell outlined on
+ * every plane it spans), read from the region source's tiles of that plane, as rings owned by their
+ * observations, so the Cells panel's colouring, groups and selection apply to them as to any ring.
+ *
+ * A feature is a cell by its id: the cell's id among the observations' (`SpatialObservations.ids`),
+ * qualified by its slice (`<slice>:<id>`) as a folder region set serves it. Pure, like
+ * `spatial-tile-merge.ts`.
+ */
+/** Memoized per observations object: their ids to their indices. */
+const indices = new WeakMap();
+/** Each observation's index by its id, or null when the observations carry no ids. */
+export function observationIndex(obs) {
+    const hit = indices.get(obs);
+    if (hit !== undefined)
+        return hit;
+    const ids = obs.ids;
+    const out = ids ? new Map(ids.map((id, i) => [id, i])) : null;
+    indices.set(obs, out);
+    return out;
+}
+/** A feature's cell id: its id without the slice a folder region set qualifies it with. */
+export function cellIdOf(featureId) {
+    const at = featureId.indexOf(':');
+    return at < 0 ? featureId : featureId.slice(at + 1);
+}
+/**
+ * The rings of `tiles`' features (each once, though a feature is in every tile it meets), owned by
+ * their cells, in observation units (the region set's are the image's pixels: back through `ref`).
+ * A feature of no observation, and an open one (a polyline), is left out; each ring of a feature
+ * (its parts and holes) is a ring of its cell.
+ */
+export function planeCellRings(tiles, index, ref) {
+    const [sx, sy] = ref?.scale ?? [1, 1];
+    const [tx, ty] = ref?.translate ?? [0, 0];
+    const seen = new Set();
+    const rings = [];
+    const owners = [];
+    let vertices = 0;
+    for (const tile of tiles) {
+        for (const f of tile.features) {
+            if (f.open || seen.has(f.id))
+                continue;
+            seen.add(f.id);
+            const o = index.get(cellIdOf(f.id));
+            if (o === undefined)
+                continue;
+            for (const ring of f.rings) {
+                if (ring.length < 6)
+                    continue;
+                rings.push(ring);
+                owners.push(o);
+                vertices += ring.length / 2;
+            }
+        }
+    }
+    const coords = new Float32Array(vertices * 2);
+    const offsets = new Uint32Array(rings.length + 1);
+    let v = 0;
+    rings.forEach((ring, r) => {
+        offsets[r] = v;
+        for (let i = 0; i < ring.length; i += 2) {
+            coords[v * 2] = (ring[i] - tx) / sx;
+            coords[v * 2 + 1] = (ring[i + 1] - ty) / sy;
+            v++;
+        }
+    });
+    offsets[rings.length] = v;
+    return { count: rings.length, coords, offsets, observation: Uint32Array.from(owners) };
+}
+/**
+ * Each cell's outlines on every plane it spans, from the planes' tiles (a feature once, though in
+ * every tile it meets), for the 3D reconstruction of each cell by itself (`CellOutlines`, slice k
+ * at z = k). Only cells of `classes` (all when null), whose outlines' centre over all planes is in
+ * `within` (`[x0, y0, x1, y1]`, image px; anywhere when absent): the tiles fetched for an area hold
+ * the cells crossing its edge too, which belong to the area their centre is in.
+ */
+export function cellOutlinesFromTiles(planes, index, classes, within) {
+    const byCell = new Map();
+    for (const plane of planes) {
+        const seen = new Set();
+        for (const tile of plane.tiles) {
+            for (const f of tile.features) {
+                if (f.open || seen.has(f.id) || !f.rings.length)
+                    continue;
+                seen.add(f.id);
+                if (classes && !classes.has(f.label ?? ''))
+                    continue;
+                const cell = index.get(cellIdOf(f.id));
+                if (cell === undefined)
+                    continue;
+                let entry = byCell.get(cell);
+                if (!entry) {
+                    entry = { label: f.label, slices: [], box: [Infinity, Infinity, -Infinity, -Infinity] };
+                    byCell.set(cell, entry);
+                }
+                entry.slices.push({ z: plane.slice, rings: f.rings });
+                const b = entry.box;
+                b[0] = Math.min(b[0], f.bbox[0]);
+                b[1] = Math.min(b[1], f.bbox[1]);
+                b[2] = Math.max(b[2], f.bbox[2]);
+                b[3] = Math.max(b[3], f.bbox[3]);
+            }
+        }
+    }
+    const out = [];
+    for (const [cell, e] of byCell) {
+        if (within) {
+            const cx = (e.box[0] + e.box[2]) / 2;
+            const cy = (e.box[1] + e.box[3]) / 2;
+            if (cx < within[0] || cx >= within[2] || cy < within[1] || cy >= within[3])
+                continue;
+        }
+        out.push({ cell, label: e.label, slices: e.slices });
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plane-cells.js","sourceRoot":"","sources":["../../../../src/lib/spatial/plane-cells.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  SpatialImageRef,\n  SpatialObservations,\n  SpatialPolygonTile,\n} from '../contracts/spatial-dataset.contract';\nimport type { TileFeature } from '../region-source/region-tiles';\n\n/**\n * A 3D segmentation's cells on one plane as the 2D view's cell layer draws them: the outlines of a\n * boundary set's region set (`SpatialPolygonTilesMeta.sets[i].regionSource`, every cell outlined on\n * every plane it spans), read from the region source's tiles of that plane, as rings owned by their\n * observations, so the Cells panel's colouring, groups and selection apply to them as to any ring.\n *\n * A feature is a cell by its id: the cell's id among the observations' (`SpatialObservations.ids`),\n * qualified by its slice (`<slice>:<id>`) as a folder region set serves it. Pure, like\n * `spatial-tile-merge.ts`.\n */\n\n/** Memoized per observations object: their ids to their indices. */\nconst indices = new WeakMap<SpatialObservations, Map<string, number> | null>();\n\n/** Each observation's index by its id, or null when the observations carry no ids. */\nexport function observationIndex(obs: SpatialObservations): Map<string, number> | null {\n  const hit = indices.get(obs);\n  if (hit !== undefined) return hit;\n  const ids = obs.ids;\n  const out = ids ? new Map(ids.map((id, i) => [id, i] as [string, number])) : null;\n  indices.set(obs, out);\n  return out;\n}\n\n/** A feature's cell id: its id without the slice a folder region set qualifies it with. */\nexport function cellIdOf(featureId: string): string {\n  const at = featureId.indexOf(':');\n  return at < 0 ? featureId : featureId.slice(at + 1);\n}\n\n/**\n * The rings of `tiles`' features (each once, though a feature is in every tile it meets), owned by\n * their cells, in observation units (the region set's are the image's pixels: back through `ref`).\n * A feature of no observation, and an open one (a polyline), is left out; each ring of a feature\n * (its parts and holes) is a ring of its cell.\n */\nexport function planeCellRings(\n  tiles: readonly { features: readonly TileFeature[] }[],\n  index: ReadonlyMap<string, number>,\n  ref: SpatialImageRef | null | undefined,\n): SpatialPolygonTile {\n  const [sx, sy] = ref?.scale ?? [1, 1];\n  const [tx, ty] = ref?.translate ?? [0, 0];\n  const seen = new Set<string>();\n  const rings: Float32Array[] = [];\n  const owners: number[] = [];\n  let vertices = 0;\n  for (const tile of tiles) {\n    for (const f of tile.features) {\n      if (f.open || seen.has(f.id)) continue;\n      seen.add(f.id);\n      const o = index.get(cellIdOf(f.id));\n      if (o === undefined) continue;\n      for (const ring of f.rings) {\n        if (ring.length < 6) continue;\n        rings.push(ring);\n        owners.push(o);\n        vertices += ring.length / 2;\n      }\n    }\n  }\n  const coords = new Float32Array(vertices * 2);\n  const offsets = new Uint32Array(rings.length + 1);\n  let v = 0;\n  rings.forEach((ring, r) => {\n    offsets[r] = v;\n    for (let i = 0; i < ring.length; i += 2) {\n      coords[v * 2] = (ring[i] - tx) / sx;\n      coords[v * 2 + 1] = (ring[i + 1] - ty) / sy;\n      v++;\n    }\n  });\n  offsets[rings.length] = v;\n  return { count: rings.length, coords, offsets, observation: Uint32Array.from(owners) };\n}\n\n/** One plane's tiles of a region set: the plane's slice index (its place among the set's planes). */\nexport interface PlaneTiles {\n  slice: number;\n  tiles: readonly { features: readonly TileFeature[] }[];\n}\n\n/**\n * Each cell's outlines on every plane it spans, from the planes' tiles (a feature once, though in\n * every tile it meets), for the 3D reconstruction of each cell by itself (`CellOutlines`, slice k\n * at z = k). Only cells of `classes` (all when null), whose outlines' centre over all planes is in\n * `within` (`[x0, y0, x1, y1]`, image px; anywhere when absent): the tiles fetched for an area hold\n * the cells crossing its edge too, which belong to the area their centre is in.\n */\nexport function cellOutlinesFromTiles(\n  planes: readonly PlaneTiles[],\n  index: ReadonlyMap<string, number>,\n  classes: ReadonlySet<string> | null,\n  within?: readonly [number, number, number, number],\n): { cell: number; label: string | null; slices: { z: number; rings: Float32Array[] }[] }[] {\n  const byCell = new Map<\n    number,\n    { label: string | null; slices: { z: number; rings: Float32Array[] }[]; box: [number, number, number, number] }\n  >();\n  for (const plane of planes) {\n    const seen = new Set<string>();\n    for (const tile of plane.tiles) {\n      for (const f of tile.features) {\n        if (f.open || seen.has(f.id) || !f.rings.length) continue;\n        seen.add(f.id);\n        if (classes && !classes.has(f.label ?? '')) continue;\n        const cell = index.get(cellIdOf(f.id));\n        if (cell === undefined) continue;\n        let entry = byCell.get(cell);\n        if (!entry) {\n          entry = { label: f.label, slices: [], box: [Infinity, Infinity, -Infinity, -Infinity] };\n          byCell.set(cell, entry);\n        }\n        entry.slices.push({ z: plane.slice, rings: f.rings });\n        const b = entry.box;\n        b[0] = Math.min(b[0], f.bbox[0]);\n        b[1] = Math.min(b[1], f.bbox[1]);\n        b[2] = Math.max(b[2], f.bbox[2]);\n        b[3] = Math.max(b[3], f.bbox[3]);\n      }\n    }\n  }\n  const out: { cell: number; label: string | null; slices: { z: number; rings: Float32Array[] }[] }[] = [];\n  for (const [cell, e] of byCell) {\n    if (within) {\n      const cx = (e.box[0] + e.box[2]) / 2;\n      const cy = (e.box[1] + e.box[3]) / 2;\n      if (cx < within[0] || cx >= within[2] || cy < within[1] || cy >= within[3]) continue;\n    }\n    out.push({ cell, label: e.label, slices: e.slices });\n  }\n  return out;\n}\n"]}