@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/geometry/reconstruct.mjs

@@ -0,0 +1,315 @@
+/**
+ * The 3D reconstruction of a region from its outlines on a stack of slices: each slice's outlines
+ * filled (each feature even-odd, the features as their union) into a voxel mask, the mask's
+ * boundary meshed by surface nets and smoothed; and its open lines lofted into a sheet.
+ *
+ * Pure: usable from workers.
+ */
+import { pointInRing, ringArea, smoothMesh, surfaceNets } from 'napari-js/geometry';
+import { loftLines } from './loft';
+/**
+ * The mesh of the region outlined by `slices`, in image pixels (x, y) and slice indices (z: slice
+ * k's plane at z = k): the filled outlines' surface, and the sheet through the lines (see
+ * {@link loftLines}). Empty when no slice has an area and no two slices have lines.
+ */
+export function reconstruct(slices, opts = {}) {
+    const filled = fill(slices, opts);
+    const lines = slices.filter((s) => s.lines?.length);
+    if (!lines.length)
+        return filled;
+    const sheet = loftLines(lines.map((s) => ({ z: s.z, lines: s.lines ?? [] })), opts.pixelStep ?? 1);
+    return mergeMeshes(filled, sheet);
+}
+/** The surface of the filled outlines. */
+function fill(slices, opts) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity, z0 = Infinity, z1 = -Infinity;
+    for (const s of slices) {
+        for (const r of s.rings) {
+            for (let i = 0; i + 1 < r.length; i += 2) {
+                if (r[i] < x0)
+                    x0 = r[i];
+                if (r[i] > x1)
+                    x1 = r[i];
+                if (r[i + 1] < y0)
+                    y0 = r[i + 1];
+                if (r[i + 1] > y1)
+                    y1 = r[i + 1];
+            }
+        }
+        if (s.rings.length) {
+            z0 = Math.min(z0, s.z);
+            z1 = Math.max(z1, s.z);
+        }
+    }
+    if (!(x1 > x0) || !(y1 > y0))
+        return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+    const nz = z1 - z0 + 1;
+    const maxVoxels = opts.maxVoxels ?? 32_000_000;
+    let step = Math.max(opts.pixelStep ?? 1, 1e-6);
+    while (Math.ceil((x1 - x0) / step) * Math.ceil((y1 - y0) / step) * nz > maxVoxels)
+        step *= 1.25;
+    const nx = Math.max(1, Math.ceil((x1 - x0) / step));
+    const ny = Math.max(1, Math.ceil((y1 - y0) / step));
+    const mask = new Uint8Array(nx * ny * nz);
+    for (const s of slices) {
+        for (const rings of featureRings(s.rings, s.ringGroups)) {
+            fillSlice(mask, nx, ny, (s.z - z0) * nx * ny, rings, x0, y0, step);
+        }
+    }
+    // Voxel i spanning [i, i + 1) (napari-js centres it on i): the scaling below maps cell edges to px.
+    const mesh = smoothMesh(surfaceNets(mask, [nx, ny, nz], { origin: [0.5, 0.5, 0.5] }), {
+        iterations: opts.smooth ?? 2,
+    });
+    const v = mesh.vertices;
+    for (let i = 0; i < v.length; i += 3) {
+        v[i] = x0 + v[i] * step;
+        v[i + 1] = y0 + v[i + 1] * step;
+        // Voxel k spans [k, k+1) with its centre (the slice) at k + 0.5.
+        v[i + 2] = z0 + v[i + 2] - 0.5;
+    }
+    return mesh;
+}
+/** `a` and `b` as one mesh. */
+function mergeMeshes(a, b) {
+    if (!b.faces.length)
+        return a;
+    if (!a.faces.length)
+        return b;
+    const vertices = new Float32Array(a.vertices.length + b.vertices.length);
+    vertices.set(a.vertices);
+    vertices.set(b.vertices, a.vertices.length);
+    const faces = new Uint32Array(a.faces.length + b.faces.length);
+    faces.set(a.faces);
+    const offset = a.vertices.length / 3;
+    for (let i = 0; i < b.faces.length; i++)
+        faces[a.faces.length + i] = b.faces[i] + offset;
+    return { vertices, faces };
+}
+/**
+ * Fill one feature into one slice of the mask: even-odd over its `rings`, sampled at voxel
+ * centres. Cells already set stay set, so the features of a slice fill as their union.
+ */
+function fillSlice(mask, nx, ny, offset, rings, x0, y0, step) {
+    const crossings = [];
+    // Only the rows the feature spans.
+    let top = Infinity, bottom = -Infinity;
+    for (const r of rings) {
+        for (let i = 1; i < r.length; i += 2) {
+            if (r[i] < top)
+                top = r[i];
+            if (r[i] > bottom)
+                bottom = r[i];
+        }
+    }
+    const j0 = Math.max(0, Math.floor((top - y0) / step - 0.5));
+    const j1 = Math.min(ny - 1, Math.ceil((bottom - y0) / step - 0.5));
+    for (let j = j0; j <= j1; j++) {
+        const y = y0 + (j + 0.5) * step;
+        crossings.length = 0;
+        for (const r of rings) {
+            const n = r.length >> 1;
+            for (let i = 0, k = n - 1; i < n; k = i++) {
+                const ya = r[2 * i + 1], yb = r[2 * k + 1];
+                if (ya > y !== yb > y) {
+                    const xa = r[2 * i], xb = r[2 * k];
+                    crossings.push(xa + ((y - ya) * (xb - xa)) / (yb - ya));
+                }
+            }
+        }
+        if (crossings.length < 2)
+            continue;
+        crossings.sort((a, b) => a - b);
+        const row = offset + j * nx;
+        for (let c = 0; c + 1 < crossings.length; c += 2) {
+            const from = Math.max(0, Math.ceil((crossings[c] - x0) / step - 0.5));
+            const to = Math.min(nx - 1, Math.floor((crossings[c + 1] - x0) / step - 0.5));
+            for (let i = from; i <= to; i++)
+                mask[row + i] = 1;
+        }
+    }
+}
+/**
+ * The area inside `rings` (interleaved `x, y`), even-odd: a ring inside an odd number of others is
+ * a hole. Exact for rings that do not cross (a polygon set's exteriors and holes).
+ */
+export function ringsArea(rings) {
+    const boxes = rings.map(ringBox);
+    let area = 0;
+    for (let i = 0; i < rings.length; i++) {
+        const r = rings[i];
+        if (r.length < 6)
+            continue;
+        const x = r[0], y = r[1];
+        let depth = 0;
+        for (let j = 0; j < rings.length; j++) {
+            if (j === i)
+                continue;
+            const b = boxes[j];
+            if (x < b[0] || x > b[2] || y < b[1] || y > b[3])
+                continue;
+            if (pointInRing(x, y, rings[j]))
+                depth++;
+        }
+        area += (depth % 2 ? -1 : 1) * Math.abs(ringArea(r));
+    }
+    return Math.max(0, area);
+}
+/**
+ * The rings of each feature (see {@link SliceOutlines.ringGroups}), in the order first met; one
+ * feature of every ring without `groups`.
+ */
+export function featureRings(rings, groups) {
+    if (!groups || !rings.length)
+        return rings.length ? [rings.slice()] : [];
+    const byGroup = new Map();
+    rings.forEach((r, i) => {
+        const g = groups[i] ?? 0;
+        const feature = byGroup.get(g);
+        if (feature)
+            feature.push(r);
+        else
+            byGroup.set(g, [r]);
+    });
+    return [...byGroup.values()];
+}
+/**
+ * The area of a slice's outlines (px²): each feature's (even-odd, see {@link ringsArea}), the
+ * features as their union, so a feature inside or over another of the slice adds only what it
+ * covers beyond it. Features whose extents overlap are measured together, by the length of their
+ * union along each row, exact between the rows through their vertices where no outline crosses
+ * another (and refined where one does).
+ */
+export function outlinesArea(rings, groups) {
+    const features = featureRings(rings, groups).map((f) => ({ rings: f, box: featureBox(f) }));
+    if (features.length < 2)
+        return features.length ? ringsArea(features[0].rings) : 0;
+    // Features whose extents overlap, joined (by x, so a feature meets only those it can overlap).
+    features.sort((a, b) => a.box[0] - b.box[0]);
+    const parent = features.map((_, i) => i);
+    const root = (i) => (parent[i] === i ? i : (parent[i] = root(parent[i])));
+    for (let i = 0; i < features.length; i++) {
+        const a = features[i].box;
+        for (let j = i + 1; j < features.length && features[j].box[0] < a[2]; j++) {
+            const b = features[j].box;
+            if (b[1] < a[3] && a[1] < b[3])
+                parent[root(j)] = root(i);
+        }
+    }
+    const clusters = new Map();
+    features.forEach((f, i) => {
+        const r = root(i);
+        const cluster = clusters.get(r);
+        if (cluster)
+            cluster.push(f.rings);
+        else
+            clusters.set(r, [f.rings]);
+    });
+    let area = 0;
+    for (const cluster of clusters.values())
+        area += cluster.length === 1 ? ringsArea(cluster[0]) : unionArea(cluster);
+    return area;
+}
+/**
+ * The volume of the region outlined by `slices`, in px² × slices (one slice thick per outline):
+ * the sum of each slice's area (see {@link outlinesArea}; Cavalieri's estimator). Times µm per px²
+ * and per slice, µm³.
+ */
+export function outlinedVolume(slices) {
+    let v = 0;
+    for (const s of slices)
+        v += outlinesArea(s.rings, s.ringGroups);
+    return v;
+}
+/** The area of the union of `features` (each even-odd over its rings), row band by row band. */
+function unionArea(features) {
+    const ys = [];
+    for (const f of features)
+        for (const r of f)
+            for (let i = 1; i < r.length; i += 2)
+                ys.push(r[i]);
+    ys.sort((a, b) => a - b);
+    let area = 0;
+    for (let k = 0; k + 1 < ys.length; k++)
+        if (ys[k + 1] > ys[k])
+            area += bandArea(features, ys[k], ys[k + 1], 0);
+    return area;
+}
+/**
+ * The union's area between rows `a` and `b`. Between two vertices' rows its width along a row is
+ * linear in y unless outlines cross there: then the band is halved until it is (or thin enough).
+ */
+function bandArea(features, a, b, depth) {
+    const h = b - a;
+    const at = (t) => unionWidth(features, a + t * h);
+    const mid = at(0.5);
+    if (depth >= 10)
+        return h * mid;
+    const e = 1e-6;
+    const tol = 1e-9 * (1 + Math.abs(mid));
+    const linear = Math.abs(at(0.25) + at(0.75) - 2 * mid) <= tol && Math.abs(at(e) + at(1 - e) - 2 * mid) <= tol;
+    if (linear)
+        return h * mid;
+    const m = a + h / 2;
+    return bandArea(features, a, m, depth + 1) + bandArea(features, m, b, depth + 1);
+}
+/** The length of the union of `features` along the row `y`. */
+function unionWidth(features, y) {
+    const spans = [];
+    const xs = [];
+    for (const f of features) {
+        xs.length = 0;
+        for (const r of f) {
+            const n = r.length >> 1;
+            for (let i = 0, k = n - 1; i < n; k = i++) {
+                const ya = r[2 * i + 1], yb = r[2 * k + 1];
+                if (ya > y !== yb > y)
+                    xs.push(r[2 * i] + ((y - ya) * (r[2 * k] - r[2 * i])) / (yb - ya));
+            }
+        }
+        xs.sort((p, q) => p - q);
+        for (let c = 0; c + 1 < xs.length; c += 2)
+            spans.push([xs[c], xs[c + 1]]);
+    }
+    spans.sort((p, q) => p[0] - q[0]);
+    let width = 0, from = -Infinity, to = -Infinity;
+    for (const [s0, s1] of spans) {
+        if (s0 > to) {
+            if (to > from)
+                width += to - from;
+            from = s0;
+            to = s1;
+        }
+        else if (s1 > to)
+            to = s1;
+    }
+    if (to > from)
+        width += to - from;
+    return width;
+}
+/** The extent of a feature's rings. */
+function featureBox(rings) {
+    const box = [Infinity, Infinity, -Infinity, -Infinity];
+    for (const r of rings) {
+        const [x0, y0, x1, y1] = ringBox(r);
+        box[0] = Math.min(box[0], x0);
+        box[1] = Math.min(box[1], y0);
+        box[2] = Math.max(box[2], x1);
+        box[3] = Math.max(box[3], y1);
+    }
+    return box;
+}
+function ringBox(r) {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (let i = 0; i + 1 < r.length; i += 2) {
+        if (r[i] < x0)
+            x0 = r[i];
+        if (r[i] > x1)
+            x1 = r[i];
+        if (r[i + 1] < y0)
+            y0 = r[i + 1];
+        if (r[i + 1] > y1)
+            y1 = r[i + 1];
+    }
+    return [x0, y0, x1, y1];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reconstruct.js","sourceRoot":"","sources":["../../../../src/lib/geometry/reconstruct.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The 3D reconstruction of a region from its outlines on a stack of slices: each slice's outlines\n * filled (each feature even-odd, the features as their union) into a voxel mask, the mask's\n * boundary meshed by surface nets and smoothed; and its open lines lofted into a sheet.\n *\n * Pure: usable from workers.\n */\nimport { pointInRing, ringArea, smoothMesh, surfaceNets } from 'napari-js/geometry';\nimport type { Mesh } from 'napari-js/geometry';\n\nimport { loftLines } from './loft';\n\n/**\n * A region's outlines on one slice: rings as interleaved `x, y` image pixels (holes included), and\n * open polylines (a layer boundary), likewise.\n */\nexport interface SliceOutlines {\n  z: number;\n  rings: ArrayLike<number>[];\n  /**\n   * The feature each ring is part of (equal ids, one feature): a feature's rings fill even-odd (its\n   * holes), the features as their union, so one inside or over another cuts no hole in it. Absent:\n   * the rings are one feature.\n   */\n  ringGroups?: ArrayLike<number>;\n  lines?: ArrayLike<number>[];\n}\n\nexport interface ReconstructOptions {\n  /** In-plane voxel edge, image px (default 1). Raised to keep the mask within `maxVoxels`. */\n  pixelStep?: number;\n  /** At most this many voxels (default 32 M). */\n  maxVoxels?: number;\n  /** Laplacian smoothing passes (default 2). */\n  smooth?: number;\n}\n\n/**\n * The mesh of the region outlined by `slices`, in image pixels (x, y) and slice indices (z: slice\n * k's plane at z = k): the filled outlines' surface, and the sheet through the lines (see\n * {@link loftLines}). Empty when no slice has an area and no two slices have lines.\n */\nexport function reconstruct(slices: readonly SliceOutlines[], opts: ReconstructOptions = {}): Mesh {\n  const filled = fill(slices, opts);\n  const lines = slices.filter((s) => s.lines?.length);\n  if (!lines.length) return filled;\n  const sheet = loftLines(\n    lines.map((s) => ({ z: s.z, lines: s.lines ?? [] })),\n    opts.pixelStep ?? 1,\n  );\n  return mergeMeshes(filled, sheet);\n}\n\n/** The surface of the filled outlines. */\nfunction fill(slices: readonly SliceOutlines[], opts: ReconstructOptions): Mesh {\n  let x0 = Infinity,\n    y0 = Infinity,\n    x1 = -Infinity,\n    y1 = -Infinity,\n    z0 = Infinity,\n    z1 = -Infinity;\n  for (const s of slices) {\n    for (const r of s.rings) {\n      for (let i = 0; i + 1 < r.length; i += 2) {\n        if (r[i] < x0) x0 = r[i];\n        if (r[i] > x1) x1 = r[i];\n        if (r[i + 1] < y0) y0 = r[i + 1];\n        if (r[i + 1] > y1) y1 = r[i + 1];\n      }\n    }\n    if (s.rings.length) {\n      z0 = Math.min(z0, s.z);\n      z1 = Math.max(z1, s.z);\n    }\n  }\n  if (!(x1 > x0) || !(y1 > y0)) return { vertices: new Float32Array(0), faces: new Uint32Array(0) };\n  const nz = z1 - z0 + 1;\n  const maxVoxels = opts.maxVoxels ?? 32_000_000;\n  let step = Math.max(opts.pixelStep ?? 1, 1e-6);\n  while (Math.ceil((x1 - x0) / step) * Math.ceil((y1 - y0) / step) * nz > maxVoxels) step *= 1.25;\n  const nx = Math.max(1, Math.ceil((x1 - x0) / step));\n  const ny = Math.max(1, Math.ceil((y1 - y0) / step));\n  const mask = new Uint8Array(nx * ny * nz);\n  for (const s of slices) {\n    for (const rings of featureRings(s.rings, s.ringGroups)) {\n      fillSlice(mask, nx, ny, (s.z - z0) * nx * ny, rings, x0, y0, step);\n    }\n  }\n\n  // Voxel i spanning [i, i + 1) (napari-js centres it on i): the scaling below maps cell edges to px.\n  const mesh = smoothMesh(surfaceNets(mask, [nx, ny, nz], { origin: [0.5, 0.5, 0.5] }), {\n    iterations: opts.smooth ?? 2,\n  });\n  const v = mesh.vertices;\n  for (let i = 0; i < v.length; i += 3) {\n    v[i] = x0 + v[i] * step;\n    v[i + 1] = y0 + v[i + 1] * step;\n    // Voxel k spans [k, k+1) with its centre (the slice) at k + 0.5.\n    v[i + 2] = z0 + v[i + 2] - 0.5;\n  }\n  return mesh;\n}\n\n/** `a` and `b` as one mesh. */\nfunction mergeMeshes(a: Mesh, b: Mesh): Mesh {\n  if (!b.faces.length) return a;\n  if (!a.faces.length) return b;\n  const vertices = new Float32Array(a.vertices.length + b.vertices.length);\n  vertices.set(a.vertices);\n  vertices.set(b.vertices, a.vertices.length);\n  const faces = new Uint32Array(a.faces.length + b.faces.length);\n  faces.set(a.faces);\n  const offset = a.vertices.length / 3;\n  for (let i = 0; i < b.faces.length; i++) faces[a.faces.length + i] = b.faces[i] + offset;\n  return { vertices, faces };\n}\n\n/**\n * Fill one feature into one slice of the mask: even-odd over its `rings`, sampled at voxel\n * centres. Cells already set stay set, so the features of a slice fill as their union.\n */\nfunction fillSlice(\n  mask: Uint8Array,\n  nx: number,\n  ny: number,\n  offset: number,\n  rings: readonly ArrayLike<number>[],\n  x0: number,\n  y0: number,\n  step: number,\n): void {\n  const crossings: number[] = [];\n  // Only the rows the feature spans.\n  let top = Infinity,\n    bottom = -Infinity;\n  for (const r of rings) {\n    for (let i = 1; i < r.length; i += 2) {\n      if (r[i] < top) top = r[i];\n      if (r[i] > bottom) bottom = r[i];\n    }\n  }\n  const j0 = Math.max(0, Math.floor((top - y0) / step - 0.5));\n  const j1 = Math.min(ny - 1, Math.ceil((bottom - y0) / step - 0.5));\n  for (let j = j0; j <= j1; j++) {\n    const y = y0 + (j + 0.5) * step;\n    crossings.length = 0;\n    for (const r of rings) {\n      const n = r.length >> 1;\n      for (let i = 0, k = n - 1; i < n; k = i++) {\n        const ya = r[2 * i + 1],\n          yb = r[2 * k + 1];\n        if (ya > y !== yb > y) {\n          const xa = r[2 * i],\n            xb = r[2 * k];\n          crossings.push(xa + ((y - ya) * (xb - xa)) / (yb - ya));\n        }\n      }\n    }\n    if (crossings.length < 2) continue;\n    crossings.sort((a, b) => a - b);\n    const row = offset + j * nx;\n    for (let c = 0; c + 1 < crossings.length; c += 2) {\n      const from = Math.max(0, Math.ceil((crossings[c] - x0) / step - 0.5));\n      const to = Math.min(nx - 1, Math.floor((crossings[c + 1] - x0) / step - 0.5));\n      for (let i = from; i <= to; i++) mask[row + i] = 1;\n    }\n  }\n}\n\n/**\n * The area inside `rings` (interleaved `x, y`), even-odd: a ring inside an odd number of others is\n * a hole. Exact for rings that do not cross (a polygon set's exteriors and holes).\n */\nexport function ringsArea(rings: readonly ArrayLike<number>[]): number {\n  const boxes = rings.map(ringBox);\n  let area = 0;\n  for (let i = 0; i < rings.length; i++) {\n    const r = rings[i];\n    if (r.length < 6) continue;\n    const x = r[0],\n      y = r[1];\n    let depth = 0;\n    for (let j = 0; j < rings.length; j++) {\n      if (j === i) continue;\n      const b = boxes[j];\n      if (x < b[0] || x > b[2] || y < b[1] || y > b[3]) continue;\n      if (pointInRing(x, y, rings[j])) depth++;\n    }\n    area += (depth % 2 ? -1 : 1) * Math.abs(ringArea(r));\n  }\n  return Math.max(0, area);\n}\n\n/**\n * The rings of each feature (see {@link SliceOutlines.ringGroups}), in the order first met; one\n * feature of every ring without `groups`.\n */\nexport function featureRings(\n  rings: readonly ArrayLike<number>[],\n  groups?: ArrayLike<number>,\n): ArrayLike<number>[][] {\n  if (!groups || !rings.length) return rings.length ? [rings.slice()] : [];\n  const byGroup = new Map<number, ArrayLike<number>[]>();\n  rings.forEach((r, i) => {\n    const g = groups[i] ?? 0;\n    const feature = byGroup.get(g);\n    if (feature) feature.push(r);\n    else byGroup.set(g, [r]);\n  });\n  return [...byGroup.values()];\n}\n\n/**\n * The area of a slice's outlines (px²): each feature's (even-odd, see {@link ringsArea}), the\n * features as their union, so a feature inside or over another of the slice adds only what it\n * covers beyond it. Features whose extents overlap are measured together, by the length of their\n * union along each row, exact between the rows through their vertices where no outline crosses\n * another (and refined where one does).\n */\nexport function outlinesArea(rings: readonly ArrayLike<number>[], groups?: ArrayLike<number>): number {\n  const features = featureRings(rings, groups).map((f) => ({ rings: f, box: featureBox(f) }));\n  if (features.length < 2) return features.length ? ringsArea(features[0].rings) : 0;\n  // Features whose extents overlap, joined (by x, so a feature meets only those it can overlap).\n  features.sort((a, b) => a.box[0] - b.box[0]);\n  const parent = features.map((_, i) => i);\n  const root = (i: number): number => (parent[i] === i ? i : (parent[i] = root(parent[i])));\n  for (let i = 0; i < features.length; i++) {\n    const a = features[i].box;\n    for (let j = i + 1; j < features.length && features[j].box[0] < a[2]; j++) {\n      const b = features[j].box;\n      if (b[1] < a[3] && a[1] < b[3]) parent[root(j)] = root(i);\n    }\n  }\n  const clusters = new Map<number, ArrayLike<number>[][]>();\n  features.forEach((f, i) => {\n    const r = root(i);\n    const cluster = clusters.get(r);\n    if (cluster) cluster.push(f.rings);\n    else clusters.set(r, [f.rings]);\n  });\n  let area = 0;\n  for (const cluster of clusters.values())\n    area += cluster.length === 1 ? ringsArea(cluster[0]) : unionArea(cluster);\n  return area;\n}\n\n/**\n * The volume of the region outlined by `slices`, in px² × slices (one slice thick per outline):\n * the sum of each slice's area (see {@link outlinesArea}; Cavalieri's estimator). Times µm per px²\n * and per slice, µm³.\n */\nexport function outlinedVolume(slices: readonly SliceOutlines[]): number {\n  let v = 0;\n  for (const s of slices) v += outlinesArea(s.rings, s.ringGroups);\n  return v;\n}\n\n/** The area of the union of `features` (each even-odd over its rings), row band by row band. */\nfunction unionArea(features: readonly ArrayLike<number>[][]): number {\n  const ys: number[] = [];\n  for (const f of features) for (const r of f) for (let i = 1; i < r.length; i += 2) ys.push(r[i]);\n  ys.sort((a, b) => a - b);\n  let area = 0;\n  for (let k = 0; k + 1 < ys.length; k++) if (ys[k + 1] > ys[k]) area += bandArea(features, ys[k], ys[k + 1], 0);\n  return area;\n}\n\n/**\n * The union's area between rows `a` and `b`. Between two vertices' rows its width along a row is\n * linear in y unless outlines cross there: then the band is halved until it is (or thin enough).\n */\nfunction bandArea(features: readonly ArrayLike<number>[][], a: number, b: number, depth: number): number {\n  const h = b - a;\n  const at = (t: number) => unionWidth(features, a + t * h);\n  const mid = at(0.5);\n  if (depth >= 10) return h * mid;\n  const e = 1e-6;\n  const tol = 1e-9 * (1 + Math.abs(mid));\n  const linear = Math.abs(at(0.25) + at(0.75) - 2 * mid) <= tol && Math.abs(at(e) + at(1 - e) - 2 * mid) <= tol;\n  if (linear) return h * mid;\n  const m = a + h / 2;\n  return bandArea(features, a, m, depth + 1) + bandArea(features, m, b, depth + 1);\n}\n\n/** The length of the union of `features` along the row `y`. */\nfunction unionWidth(features: readonly ArrayLike<number>[][], y: number): number {\n  const spans: Array<[number, number]> = [];\n  const xs: number[] = [];\n  for (const f of features) {\n    xs.length = 0;\n    for (const r of f) {\n      const n = r.length >> 1;\n      for (let i = 0, k = n - 1; i < n; k = i++) {\n        const ya = r[2 * i + 1],\n          yb = r[2 * k + 1];\n        if (ya > y !== yb > y) xs.push(r[2 * i] + ((y - ya) * (r[2 * k] - r[2 * i])) / (yb - ya));\n      }\n    }\n    xs.sort((p, q) => p - q);\n    for (let c = 0; c + 1 < xs.length; c += 2) spans.push([xs[c], xs[c + 1]]);\n  }\n  spans.sort((p, q) => p[0] - q[0]);\n  let width = 0,\n    from = -Infinity,\n    to = -Infinity;\n  for (const [s0, s1] of spans) {\n    if (s0 > to) {\n      if (to > from) width += to - from;\n      from = s0;\n      to = s1;\n    } else if (s1 > to) to = s1;\n  }\n  if (to > from) width += to - from;\n  return width;\n}\n\n/** The extent of a feature's rings. */\nfunction featureBox(rings: readonly ArrayLike<number>[]): [number, number, number, number] {\n  const box: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];\n  for (const r of rings) {\n    const [x0, y0, x1, y1] = ringBox(r);\n    box[0] = Math.min(box[0], x0);\n    box[1] = Math.min(box[1], y0);\n    box[2] = Math.max(box[2], x1);\n    box[3] = Math.max(box[3], y1);\n  }\n  return box;\n}\n\nfunction ringBox(r: ArrayLike<number>): [number, number, number, number] {\n  let x0 = Infinity,\n    y0 = Infinity,\n    x1 = -Infinity,\n    y1 = -Infinity;\n  for (let i = 0; i + 1 < r.length; i += 2) {\n    if (r[i] < x0) x0 = r[i];\n    if (r[i] > x1) x1 = r[i];\n    if (r[i + 1] < y0) y0 = r[i + 1];\n    if (r[i + 1] > y1) y1 = r[i + 1];\n  }\n  return [x0, y0, x1, y1];\n}\n"]}

package/esm2022/lib/geometry/reslice-image.mjs

@@ -0,0 +1,57 @@
+/**
+ * An image of a plane through a volume (the X or Y section beside the 3D view), cut from the
+ * volume's voxels and displayed the way napari-js displays the volume: each channel windowed,
+ * inverted and gamma-corrected (napari-js's `windowGamma`) and coloured by its colormap's LUT
+ * (`buildLut`), the channels added (an additive composite, clamped).
+ *
+ * Pure: no DOM, no GPU.
+ */
+import { buildLut, windowGamma } from 'napari-js';
+/**
+ * The image of the plane `axis = index` (a voxel index): through x, slices across and y down;
+ * through y, x across and slices down — the section coordinates of `geometry/section`.
+ */
+export function resliceImage(vol, axis, index) {
+    const { width: w, height: h, depth: d } = vol;
+    const at = Math.min(Math.max(0, Math.round(index)), (axis === 'x' ? w : h) - 1);
+    const outW = axis === 'x' ? d : w;
+    const outH = axis === 'x' ? h : d;
+    const rgb = new Float32Array(outW * outH * 3);
+    for (const ch of vol.channels) {
+        if (!ch.visible)
+            continue;
+        const lut = channelLut(ch, vol.invert);
+        for (let row = 0; row < outH; row++) {
+            for (let col = 0; col < outW; col++) {
+                const voxel = axis === 'x' ? at + w * (row + h * col) : col + w * (at + h * row);
+                const k = (row * outW + col) * 3;
+                const v = ch.data[voxel] * 3;
+                rgb[k] += lut[v];
+                rgb[k + 1] += lut[v + 1];
+                rgb[k + 2] += lut[v + 2];
+            }
+        }
+    }
+    const data = new Uint8ClampedArray(outW * outH * 4);
+    for (let i = 0, j = 0; i < rgb.length; i += 3, j += 4) {
+        data[j] = rgb[i];
+        data[j + 1] = rgb[i + 1];
+        data[j + 2] = rgb[i + 2];
+        data[j + 3] = 255;
+    }
+    return { width: outW, height: outH, data };
+}
+/** Voxel value (0..255) → displayed RGB (0..255 each), as 256 RGB triples. */
+function channelLut(ch, invert) {
+    const colors = buildLut(ch.colormap); // RGBA8 × 256
+    const last = colors.length / 4 - 1;
+    const lut = new Float32Array(256 * 3);
+    for (let v = 0; v < 256; v++) {
+        const i = 4 * Math.round(windowGamma(v, ch.min, ch.max, ch.gamma, invert) * last);
+        lut[3 * v] = colors[i];
+        lut[3 * v + 1] = colors[i + 1];
+        lut[3 * v + 2] = colors[i + 2];
+    }
+    return lut;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reslice-image.js","sourceRoot":"","sources":["../../../../src/lib/geometry/reslice-image.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAkClD;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,GAAiB,EAAE,IAAiB,EAAE,KAAa;IAC9E,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,GAAG,CAAC;IAC9C,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAChF,MAAM,IAAI,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,IAAI,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;IAC9C,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,EAAE,CAAC,OAAO;YAAE,SAAS;QAC1B,MAAM,GAAG,GAAG,UAAU,CAAC,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACvC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;YACpC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;gBACpC,MAAM,KAAK,GAAG,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;gBACjF,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;gBACjC,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC7B,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;gBACjB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBACzB,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC3B,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,iBAAiB,CAAC,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC;IACpD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QACtD,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACjB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC;IACpB,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AAC7C,CAAC;AAED,8EAA8E;AAC9E,SAAS,UAAU,CAAC,EAAuB,EAAE,MAAe;IAC1D,MAAM,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,cAAc;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;IACtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;QAClF,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACvB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/B,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC","sourcesContent":["/**\n * An image of a plane through a volume (the X or Y section beside the 3D view), cut from the\n * volume's voxels and displayed the way napari-js displays the volume: each channel windowed,\n * inverted and gamma-corrected (napari-js's `windowGamma`) and coloured by its colormap's LUT\n * (`buildLut`), the channels added (an additive composite, clamped).\n *\n * Pure: no DOM, no GPU.\n */\nimport { buildLut, windowGamma } from 'napari-js';\nimport type { Colormap } from 'napari-js';\n\nimport type { SectionAxis } from './section';\n\n/** One channel of a volume as it is displayed. */\nexport interface VolumeChannelVoxels {\n  /** uint8 voxels, x fastest, then y, then z. */\n  data: Uint8Array;\n  /** The colormap the 3D view draws the channel with (a tint, or the display colormap). */\n  colormap: Colormap;\n  /** Display window over 0..255. */\n  min: number;\n  max: number;\n  /** napari-js gamma (see `toNapariGamma`): the windowed value t shows as t^γ. */\n  gamma: number;\n  visible: boolean;\n}\n\nexport interface VolumeVoxels {\n  width: number;\n  height: number;\n  depth: number;\n  channels: readonly VolumeChannelVoxels[];\n  invert: boolean;\n}\n\n/** An RGBA image, row by row. */\nexport interface RgbaImage {\n  width: number;\n  height: number;\n  data: Uint8ClampedArray;\n}\n\n/**\n * The image of the plane `axis = index` (a voxel index): through x, slices across and y down;\n * through y, x across and slices down — the section coordinates of `geometry/section`.\n */\nexport function resliceImage(vol: VolumeVoxels, axis: SectionAxis, index: number): RgbaImage {\n  const { width: w, height: h, depth: d } = vol;\n  const at = Math.min(Math.max(0, Math.round(index)), (axis === 'x' ? w : h) - 1);\n  const outW = axis === 'x' ? d : w;\n  const outH = axis === 'x' ? h : d;\n  const rgb = new Float32Array(outW * outH * 3);\n  for (const ch of vol.channels) {\n    if (!ch.visible) continue;\n    const lut = channelLut(ch, vol.invert);\n    for (let row = 0; row < outH; row++) {\n      for (let col = 0; col < outW; col++) {\n        const voxel = axis === 'x' ? at + w * (row + h * col) : col + w * (at + h * row);\n        const k = (row * outW + col) * 3;\n        const v = ch.data[voxel] * 3;\n        rgb[k] += lut[v];\n        rgb[k + 1] += lut[v + 1];\n        rgb[k + 2] += lut[v + 2];\n      }\n    }\n  }\n  const data = new Uint8ClampedArray(outW * outH * 4);\n  for (let i = 0, j = 0; i < rgb.length; i += 3, j += 4) {\n    data[j] = rgb[i];\n    data[j + 1] = rgb[i + 1];\n    data[j + 2] = rgb[i + 2];\n    data[j + 3] = 255;\n  }\n  return { width: outW, height: outH, data };\n}\n\n/** Voxel value (0..255) → displayed RGB (0..255 each), as 256 RGB triples. */\nfunction channelLut(ch: VolumeChannelVoxels, invert: boolean): Float32Array {\n  const colors = buildLut(ch.colormap); // RGBA8 × 256\n  const last = colors.length / 4 - 1;\n  const lut = new Float32Array(256 * 3);\n  for (let v = 0; v < 256; v++) {\n    const i = 4 * Math.round(windowGamma(v, ch.min, ch.max, ch.gamma, invert) * last);\n    lut[3 * v] = colors[i];\n    lut[3 * v + 1] = colors[i + 1];\n    lut[3 * v + 2] = colors[i + 2];\n  }\n  return lut;\n}\n"]}