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

package/esm2022/lib/geometry/ring.mjs

@@ -0,0 +1,201 @@
+/**
+ * Pure ring (closed polyline) helpers: bounds, containment, vertex dropping and
+ * simplification. No DOM, no Angular, no `this` — usable from workers.
+ *
+ * A ring is a pair of parallel `xs`/`ys` arrays without a repeated closing
+ * vertex; hole rings use the `[[x, y], …]` convention of {@link Polygon.holes}.
+ */
+/** The axis-aligned bounds of a ring's vertices. */
+export function ringBounds(xs, ys) {
+    let minX = Infinity, maxX = -Infinity, minY = 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 };
+}
+/**
+ * Standard ray-cast (even-odd) point-in-ring test. (px, py) and the ring
+ * vertices must be in the same coordinate system. Rings with fewer than three
+ * vertices contain nothing.
+ */
+export function pointInRing(px, py, xs, ys) {
+    const n = xs.length;
+    if (n < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const yi = ys[i], yj = ys[j];
+        const xi = xs[i], xj = xs[j];
+        const intersect = yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+/**
+ * Point-in-region test that honours interior rings (holes): inside the
+ * exterior AND outside every hole. Coordinates must share the polygon's frame.
+ * With no holes this is exactly {@link pointInRing}.
+ */
+export function pointInPolygonWithHoles(px, py, xs, ys, holes) {
+    if (!pointInRing(px, py, xs, ys))
+        return false;
+    if (holes) {
+        for (const ring of holes) {
+            if (pointInPairRing(px, py, ring))
+                return false;
+        }
+    }
+    return true;
+}
+/** {@link pointInRing} over a `[[x, y], …]` ring (the hole convention), without splitting it. */
+export function pointInPairRing(px, py, ring) {
+    const n = ring.length;
+    if (n < 3)
+        return false;
+    let inside = false;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = ring[i][0], yi = ring[i][1];
+        const xj = ring[j][0], yj = ring[j][1];
+        const intersect = yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+/**
+ * Drop every vertex whose Euclidean distance to (cx, cy) is less than
+ * `radius`. Returns trimmed parallel arrays plus how many vertices were
+ * removed (so the caller can detect a no-op tick and skip the relayout).
+ */
+export function dropVerticesWithinRadius(xpoints, ypoints, cx, cy, radius) {
+    const r2 = radius * radius;
+    const xs = [];
+    const ys = [];
+    let removed = 0;
+    for (let i = 0; i < xpoints.length; i++) {
+        const dx = xpoints[i] - cx;
+        const dy = ypoints[i] - cy;
+        if (dx * dx + dy * dy < r2) {
+            removed++;
+            continue;
+        }
+        xs.push(xpoints[i]);
+        ys.push(ypoints[i]);
+    }
+    return { xpoints: xs, ypoints: ys, removed };
+}
+/**
+ * Erase the part of a ring that lies within `radius` of (cx, cy): every vertex
+ * inside the disc goes (as {@link dropVerticesWithinRadius}), and the outline is
+ * rejoined where it crosses the disc's edge rather than at the next vertex left
+ * standing. On a densely sampled outline the two agree; on a sparse one (a
+ * traced box is four corners) dropping a corner would otherwise cut straight to
+ * the neighbouring corners. A `closed` ring wraps; an open one (a polyline) has
+ * no edge from its last vertex back to its first. Returns the trimmed parallel
+ * arrays plus how many of the ring's own vertices were removed (0: unchanged).
+ */
+export function eraseRingWithinRadius(xpoints, ypoints, cx, cy, radius, closed = true) {
+    const n = xpoints.length;
+    // A vertex placed on the disc's edge by an earlier tick stays outside (no churn).
+    const r2 = radius * radius * (1 - 1e-9);
+    const inside = new Array(n);
+    let removed = 0;
+    for (let i = 0; i < n; i++) {
+        const dx = xpoints[i] - cx;
+        const dy = ypoints[i] - cy;
+        inside[i] = dx * dx + dy * dy < r2;
+        if (inside[i])
+            removed++;
+    }
+    if (removed === 0)
+        return { xpoints: xpoints.slice(), ypoints: ypoints.slice(), removed };
+    const xs = [];
+    const ys = [];
+    for (let i = 0; i < n; i++) {
+        if (!inside[i]) {
+            xs.push(xpoints[i]);
+            ys.push(ypoints[i]);
+        }
+        const j = i + 1 < n ? i + 1 : closed ? 0 : -1;
+        if (j < 0 || inside[i] === inside[j])
+            continue;
+        // The edge i→j crosses the disc's edge once: leaving it when i is inside.
+        const ax = xpoints[i] - cx, ay = ypoints[i] - cy;
+        const ex = xpoints[j] - xpoints[i], ey = ypoints[j] - ypoints[i];
+        const a = ex * ex + ey * ey;
+        const b = ax * ex + ay * ey;
+        const c = ax * ax + ay * ay - radius * radius;
+        const root = Math.sqrt(Math.max(0, b * b - a * c));
+        const t = (inside[i] ? -b + root : -b - root) / a;
+        // A crossing at the vertex left standing (one on the disc's edge) is that vertex.
+        if (inside[i] ? t >= 1 - 1e-12 : t <= 1e-12)
+            continue;
+        xs.push(xpoints[i] + t * ex);
+        ys.push(ypoints[i] + t * ey);
+    }
+    return { xpoints: xs, ypoints: ys, removed };
+}
+/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */
+function perpDistance(px, py, ax, ay, bx, by) {
+    const dx = bx - ax, dy = by - ay;
+    const len2 = dx * dx + dy * dy;
+    if (len2 === 0)
+        return Math.hypot(px - ax, py - ay);
+    let t = ((px - ax) * dx + (py - ay) * dy) / len2;
+    t = Math.max(0, Math.min(1, t));
+    return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));
+}
+/**
+ * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):
+ * drop every vertex that lies within `epsilon` pixels (the "altitude
+ * threshold") of the line between its kept neighbours. Anchored at vertex 0
+ * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a
+ * non-positive epsilon, are returned unchanged. Output keeps the closed-ring
+ * convention (no repeated closing point).
+ */
+export function simplifyRing(xs, ys, epsilon) {
+    const n = xs.length;
+    if (n <= 3 || !(epsilon > 0))
+        return { xs: xs.slice(), ys: ys.slice() };
+    // Close the ring so both endpoints of the DP run are vertex 0.
+    const px = [...xs, xs[0]];
+    const py = [...ys, ys[0]];
+    const m = px.length;
+    const keep = new Array(m).fill(false);
+    keep[0] = true;
+    keep[m - 1] = true;
+    const stack = [[0, m - 1]];
+    while (stack.length) {
+        const [a, b] = stack.pop();
+        let maxD = -1, idx = -1;
+        for (let i = a + 1; i < b; i++) {
+            const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);
+            if (d > maxD) {
+                maxD = d;
+                idx = i;
+            }
+        }
+        if (maxD > epsilon && idx > a) {
+            keep[idx] = true;
+            stack.push([a, idx], [idx, b]);
+        }
+    }
+    const outX = [], outY = [];
+    for (let i = 0; i < m - 1; i++) {
+        // drop the duplicated closing vertex
+        if (keep[i]) {
+            outX.push(px[i]);
+            outY.push(py[i]);
+        }
+    }
+    return { xs: outX, ys: outY };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ring.js","sourceRoot":"","sources":["../../../../src/lib/geometry/ring.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Pure ring (closed polyline) helpers: bounds, containment, vertex dropping and\n * simplification. No DOM, no Angular, no `this` — usable from workers.\n *\n * A ring is a pair of parallel `xs`/`ys` arrays without a repeated closing\n * vertex; hole rings use the `[[x, y], …]` convention of {@link Polygon.holes}.\n */\n\n/** Axis-aligned bounds of a ring. Infinite (min > max) for an empty ring. */\nexport interface RingBounds {\n  minX: number;\n  minY: number;\n  maxX: number;\n  maxY: number;\n}\n\n/** The axis-aligned bounds of a ring's vertices. */\nexport function ringBounds(xs: ArrayLike<number>, ys: ArrayLike<number>): RingBounds {\n  let minX = Infinity,\n    maxX = -Infinity,\n    minY = Infinity,\n    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\n/**\n * Standard ray-cast (even-odd) point-in-ring test. (px, py) and the ring\n * vertices must be in the same coordinate system. Rings with fewer than three\n * vertices contain nothing.\n */\nexport function pointInRing(px: number, py: number, xs: ArrayLike<number>, ys: ArrayLike<number>): boolean {\n  const n = xs.length;\n  if (n < 3) return false;\n  let inside = false;\n  for (let i = 0, j = n - 1; i < n; j = i++) {\n    const yi = ys[i],\n      yj = ys[j];\n    const xi = xs[i],\n      xj = xs[j];\n    const intersect = yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;\n    if (intersect) inside = !inside;\n  }\n  return inside;\n}\n\n/**\n * Point-in-region test that honours interior rings (holes): inside the\n * exterior AND outside every hole. Coordinates must share the polygon's frame.\n * With no holes this is exactly {@link pointInRing}.\n */\nexport function pointInPolygonWithHoles(\n  px: number,\n  py: number,\n  xs: ArrayLike<number>,\n  ys: ArrayLike<number>,\n  holes?: number[][][],\n): boolean {\n  if (!pointInRing(px, py, xs, ys)) return false;\n  if (holes) {\n    for (const ring of holes) {\n      if (pointInPairRing(px, py, ring)) return false;\n    }\n  }\n  return true;\n}\n\n/** {@link pointInRing} over a `[[x, y], …]` ring (the hole convention), without splitting it. */\nexport function pointInPairRing(px: number, py: number, ring: ReadonlyArray<ArrayLike<number>>): boolean {\n  const n = ring.length;\n  if (n < 3) return false;\n  let inside = false;\n  for (let i = 0, j = n - 1; i < n; j = i++) {\n    const xi = ring[i][0],\n      yi = ring[i][1];\n    const xj = ring[j][0],\n      yj = ring[j][1];\n    const intersect = yi > py !== yj > py && px < ((xj - xi) * (py - yi)) / (yj - yi) + xi;\n    if (intersect) inside = !inside;\n  }\n  return inside;\n}\n\n/**\n * Drop every vertex whose Euclidean distance to (cx, cy) is less than\n * `radius`. Returns trimmed parallel arrays plus how many vertices were\n * removed (so the caller can detect a no-op tick and skip the relayout).\n */\nexport function dropVerticesWithinRadius(\n  xpoints: number[],\n  ypoints: number[],\n  cx: number,\n  cy: number,\n  radius: number,\n): { xpoints: number[]; ypoints: number[]; removed: number } {\n  const r2 = radius * radius;\n  const xs: number[] = [];\n  const ys: number[] = [];\n  let removed = 0;\n  for (let i = 0; i < xpoints.length; i++) {\n    const dx = xpoints[i] - cx;\n    const dy = ypoints[i] - cy;\n    if (dx * dx + dy * dy < r2) {\n      removed++;\n      continue;\n    }\n    xs.push(xpoints[i]);\n    ys.push(ypoints[i]);\n  }\n  return { xpoints: xs, ypoints: ys, removed };\n}\n\n/**\n * Erase the part of a ring that lies within `radius` of (cx, cy): every vertex\n * inside the disc goes (as {@link dropVerticesWithinRadius}), and the outline is\n * rejoined where it crosses the disc's edge rather than at the next vertex left\n * standing. On a densely sampled outline the two agree; on a sparse one (a\n * traced box is four corners) dropping a corner would otherwise cut straight to\n * the neighbouring corners. A `closed` ring wraps; an open one (a polyline) has\n * no edge from its last vertex back to its first. Returns the trimmed parallel\n * arrays plus how many of the ring's own vertices were removed (0: unchanged).\n */\nexport function eraseRingWithinRadius(\n  xpoints: number[],\n  ypoints: number[],\n  cx: number,\n  cy: number,\n  radius: number,\n  closed = true,\n): { xpoints: number[]; ypoints: number[]; removed: number } {\n  const n = xpoints.length;\n  // A vertex placed on the disc's edge by an earlier tick stays outside (no churn).\n  const r2 = radius * radius * (1 - 1e-9);\n  const inside = new Array<boolean>(n);\n  let removed = 0;\n  for (let i = 0; i < n; i++) {\n    const dx = xpoints[i] - cx;\n    const dy = ypoints[i] - cy;\n    inside[i] = dx * dx + dy * dy < r2;\n    if (inside[i]) removed++;\n  }\n  if (removed === 0) return { xpoints: xpoints.slice(), ypoints: ypoints.slice(), removed };\n  const xs: number[] = [];\n  const ys: number[] = [];\n  for (let i = 0; i < n; i++) {\n    if (!inside[i]) {\n      xs.push(xpoints[i]);\n      ys.push(ypoints[i]);\n    }\n    const j = i + 1 < n ? i + 1 : closed ? 0 : -1;\n    if (j < 0 || inside[i] === inside[j]) continue;\n    // The edge i→j crosses the disc's edge once: leaving it when i is inside.\n    const ax = xpoints[i] - cx,\n      ay = ypoints[i] - cy;\n    const ex = xpoints[j] - xpoints[i],\n      ey = ypoints[j] - ypoints[i];\n    const a = ex * ex + ey * ey;\n    const b = ax * ex + ay * ey;\n    const c = ax * ax + ay * ay - radius * radius;\n    const root = Math.sqrt(Math.max(0, b * b - a * c));\n    const t = (inside[i] ? -b + root : -b - root) / a;\n    // A crossing at the vertex left standing (one on the disc's edge) is that vertex.\n    if (inside[i] ? t >= 1 - 1e-12 : t <= 1e-12) continue;\n    xs.push(xpoints[i] + t * ex);\n    ys.push(ypoints[i] + t * ey);\n  }\n  return { xpoints: xs, ypoints: ys, removed };\n}\n\n/** Perpendicular distance from (px,py) to the segment (ax,ay)–(bx,by). */\nfunction perpDistance(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax,\n    dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) return Math.hypot(px - ax, py - ay);\n  let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n  t = Math.max(0, Math.min(1, t));\n  return Math.hypot(px - (ax + t * dx), py - (ay + t * dy));\n}\n\n/**\n * Simplify a closed ring with the Douglas–Peucker algorithm (jit-ui#85):\n * drop every vertex that lies within `epsilon` pixels (the \"altitude\n * threshold\") of the line between its kept neighbours. Anchored at vertex 0\n * (the ring is closed by appending it). Rings of ≤ 3 vertices, or a\n * non-positive epsilon, are returned unchanged. Output keeps the closed-ring\n * convention (no repeated closing point).\n */\nexport function simplifyRing(xs: number[], ys: number[], epsilon: number): { xs: number[]; ys: number[] } {\n  const n = xs.length;\n  if (n <= 3 || !(epsilon > 0)) return { xs: xs.slice(), ys: ys.slice() };\n\n  // Close the ring so both endpoints of the DP run are vertex 0.\n  const px = [...xs, xs[0]];\n  const py = [...ys, ys[0]];\n  const m = px.length;\n  const keep = new Array<boolean>(m).fill(false);\n  keep[0] = true;\n  keep[m - 1] = true;\n\n  const stack: Array<[number, number]> = [[0, m - 1]];\n  while (stack.length) {\n    const [a, b] = stack.pop() as [number, number];\n    let maxD = -1,\n      idx = -1;\n    for (let i = a + 1; i < b; i++) {\n      const d = perpDistance(px[i], py[i], px[a], py[a], px[b], py[b]);\n      if (d > maxD) {\n        maxD = d;\n        idx = i;\n      }\n    }\n    if (maxD > epsilon && idx > a) {\n      keep[idx] = true;\n      stack.push([a, idx], [idx, b]);\n    }\n  }\n\n  const outX: number[] = [],\n    outY: number[] = [];\n  for (let i = 0; i < m - 1; i++) {\n    // drop the duplicated closing vertex\n    if (keep[i]) {\n      outX.push(px[i]);\n      outY.push(py[i]);\n    }\n  }\n  return { xs: outX, ys: outY };\n}\n"]}

package/esm2022/lib/geometry/section.mjs

@@ -0,0 +1,215 @@
+/**
+ * A section through a stack of slices' outlines: where a plane across the slices (x = const or
+ * y = const) cuts each class's regions. A class's closed shapes cut into intervals on each slice
+ * they cross (each feature even-odd, the features as their union); stacked one slice thick, the
+ * intervals are traced into outlines. Its open lines
+ * (a layer boundary on each B-scan, say) cut into one point per slice they cross, joined slice to
+ * slice into the line the boundary draws across the stack (a slice without it breaks the line).
+ *
+ * Section coordinates `(u, v)`: through `x = at`, u is the slice (slice k spans [k, k + 1)) and
+ * v the image y; through `y = at`, u is the image x and v the slice.
+ *
+ * Pure: usable from workers.
+ */
+import { maskToPolygons } from './contour';
+import { featureRings } from './reconstruct';
+/** Index every class's outlines for cutting (see {@link SectionIndex}). */
+export function indexOutlines(byClass) {
+    const classes = new Map();
+    for (const [label, slices] of byClass) {
+        const box = [Infinity, Infinity, -Infinity, -Infinity];
+        const indexed = slices.map((s) => ({
+            z: s.z,
+            rings: s.rings.map((points) => withBox(points, box)),
+            ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),
+            lines: (s.lines ?? []).map((points) => withBox(points, box)),
+        }));
+        if (box[0] <= box[2])
+            classes.set(label, { box, slices: indexed });
+    }
+    return { classes };
+}
+function withBox(points, total) {
+    const box = [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0; i + 1 < points.length; i += 2) {
+        if (points[i] < box[0])
+            box[0] = points[i];
+        if (points[i] > box[2])
+            box[2] = points[i];
+        if (points[i + 1] < box[1])
+            box[1] = points[i + 1];
+        if (points[i + 1] > box[3])
+            box[3] = points[i + 1];
+    }
+    total[0] = Math.min(total[0], box[0]);
+    total[1] = Math.min(total[1], box[1]);
+    total[2] = Math.max(total[2], box[2]);
+    total[3] = Math.max(total[3], box[3]);
+    return { points, box };
+}
+/** Whether a box spans the plane `axis = at`. */
+function spans(box, axis, at) {
+    return axis === 'x' ? box[0] <= at && at <= box[2] : box[1] <= at && at <= box[3];
+}
+/**
+ * Each class's cut by the plane `axis = at`; classes the plane misses are left out. Pass an
+ * {@link indexOutlines} index to cut many sections of the same outlines.
+ */
+export function sectionOutlines(outlines, axis, at, opts) {
+    const index = outlines instanceof Map ? indexOutlines(outlines) : outlines;
+    const out = new Map();
+    for (const [label, { box, slices }] of index.classes) {
+        if (!spans(box, axis, at))
+            continue;
+        const rings = cutShapes(slices, axis, at, opts);
+        const lines = cutLines(slices, axis, at, opts);
+        if (rings.length || lines.length)
+            out.set(label, { rings, lines });
+    }
+    return out;
+}
+/** The closed shapes' cut: intervals per slice, rasterised one slice thick and traced. */
+function cutShapes(slices, axis, at, opts) {
+    const step = Math.max(opts.step ?? 1, 1e-6);
+    const depth = Math.max(1, Math.ceil(opts.depth));
+    const cells = Math.max(1, Math.ceil(opts.extent / step));
+    // Through x: columns are slices, rows in-plane cells. Through y: the other way round.
+    const w = axis === 'x' ? depth : cells;
+    const h = axis === 'x' ? cells : depth;
+    let mask = null;
+    for (const s of slices) {
+        if (!s.rings.length || s.z < 0 || s.z >= depth)
+            continue;
+        const crossed = [];
+        const groups = [];
+        s.rings.forEach((r, i) => {
+            if (!spans(r.box, axis, at))
+                return;
+            crossed.push(r.points);
+            groups.push(s.ringGroups?.[i] ?? 0);
+        });
+        if (!crossed.length)
+            continue;
+        // Each feature's intervals, set into the mask: the features as their union.
+        for (const feature of featureRings(crossed, s.ringGroups ? groups : undefined)) {
+            const crossings = ringCrossings(feature, axis, at);
+            for (let c = 0; c + 1 < crossings.length; c += 2) {
+                // Cells whose centre lies in the interval (the pixel-centre rule).
+                const from = Math.max(0, Math.ceil(crossings[c] / step - 0.5));
+                const to = Math.min(cells - 1, Math.floor(crossings[c + 1] / step - 0.5));
+                if (to < from)
+                    continue;
+                mask ??= new Uint8Array(w * h);
+                for (let k = from; k <= to; k++)
+                    mask[axis === 'x' ? k * w + s.z : s.z * w + k] = 1;
+            }
+        }
+    }
+    if (!mask)
+        return [];
+    const toSection = (cx, cy) => axis === 'x' ? [cx, cy * step] : [cx * step, cy];
+    const rings = [];
+    for (const p of maskToPolygons(mask, w, h, 0, 0, 1, 1)) {
+        rings.push(flat(p.xpoints.map((x, i) => toSection(x, p.ypoints[i]))));
+        for (const hole of p.holes ?? [])
+            rings.push(flat(hole.map(([x, y]) => toSection(x, y))));
+    }
+    return rings;
+}
+/** Where `rings` cross the plane, along the in-plane axis, sorted (even-odd: pairs are inside). */
+function ringCrossings(rings, axis, at) {
+    // Through x = at the crossings are y values; through y = at, x values.
+    const a = axis === 'x' ? 0 : 1;
+    const out = [];
+    for (const r of rings) {
+        const n = r.length >> 1;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const pi = r[2 * i + a], pj = r[2 * j + a];
+            if (pi > at !== pj > at) {
+                const qi = r[2 * i + 1 - a], qj = r[2 * j + 1 - a];
+                out.push(qi + ((at - pi) * (qj - qi)) / (pj - pi));
+            }
+        }
+    }
+    return out.sort((p, q) => p - q);
+}
+/** The open lines' cut: a point per crossing, joined slice to slice (nearest first, each once). */
+function cutLines(slices, axis, at, opts) {
+    const maxJump = opts.maxJump ?? opts.extent / 10;
+    const stack = slices
+        .map((s) => ({
+        z: s.z,
+        hits: lineCrossings(s.lines.filter((l) => spans(l.box, axis, at)).map((l) => l.points), axis, at),
+    }))
+        .filter((s) => s.hits.length)
+        .sort((p, q) => p.z - q.z);
+    const done = [];
+    let open = [];
+    let prevZ = -Infinity;
+    for (const { z, hits } of stack) {
+        // A slice without the line between: the chains end there, not bridged across it.
+        if (z !== prevZ + 1) {
+            for (const c of open)
+                done.push(c.points);
+            open = [];
+        }
+        prevZ = z;
+        const pairs = [];
+        open.forEach((c, ci) => hits.forEach((q, hi) => pairs.push({ chain: ci, hit: hi, d: Math.abs(q - c.last) })));
+        pairs.sort((p, q) => p.d - q.d);
+        const nextOpen = [];
+        const usedChain = new Set();
+        const usedHit = new Set();
+        for (const p of pairs) {
+            if (p.d > maxJump || usedChain.has(p.chain) || usedHit.has(p.hit))
+                continue;
+            usedChain.add(p.chain);
+            usedHit.add(p.hit);
+            const chain = open[p.chain];
+            chain.points.push(...point(axis, z, hits[p.hit]));
+            chain.last = hits[p.hit];
+            nextOpen.push(chain);
+        }
+        open.forEach((c, ci) => {
+            if (!usedChain.has(ci))
+                done.push(c.points);
+        });
+        hits.forEach((q, hi) => {
+            if (!usedHit.has(hi))
+                nextOpen.push({ points: point(axis, z, q), last: q });
+        });
+        open = nextOpen;
+    }
+    for (const c of open)
+        done.push(c.points);
+    return done.map((p) => Float64Array.from(p));
+}
+/** A line's crossing on slice `z` in section coordinates, at the slice's middle. */
+function point(axis, z, q) {
+    return axis === 'x' ? [z + 0.5, q] : [q, z + 0.5];
+}
+/** Where open `lines` cross the plane, along the in-plane axis. */
+function lineCrossings(lines, axis, at) {
+    const a = axis === 'x' ? 0 : 1;
+    const out = [];
+    for (const l of lines) {
+        for (let i = 2; i + 1 < l.length; i += 2) {
+            const p0 = l[i - 2 + a], p1 = l[i + a];
+            // Half-open, so a vertex on the plane counts once.
+            if (p0 > at !== p1 > at) {
+                const q0 = l[i - 1 - a], q1 = l[i + 1 - a];
+                out.push(q0 + ((at - p0) * (q1 - q0)) / (p1 - p0));
+            }
+        }
+    }
+    return out.sort((p, q) => p - q);
+}
+function flat(points) {
+    const out = new Float64Array(points.length * 2);
+    points.forEach(([u, v], i) => {
+        out[2 * i] = u;
+        out[2 * i + 1] = v;
+    });
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"section.js","sourceRoot":"","sources":["../../../../src/lib/geometry/section.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * A section through a stack of slices' outlines: where a plane across the slices (x = const or\n * y = const) cuts each class's regions. A class's closed shapes cut into intervals on each slice\n * they cross (each feature even-odd, the features as their union); stacked one slice thick, the\n * intervals are traced into outlines. Its open lines\n * (a layer boundary on each B-scan, say) cut into one point per slice they cross, joined slice to\n * slice into the line the boundary draws across the stack (a slice without it breaks the line).\n *\n * Section coordinates `(u, v)`: through `x = at`, u is the slice (slice k spans [k, k + 1)) and\n * v the image y; through `y = at`, u is the image x and v the slice.\n *\n * Pure: usable from workers.\n */\nimport { maskToPolygons } from './contour';\nimport { SliceOutlines, featureRings } from './reconstruct';\n\n/** The plane: x = const (a section along y and the slices) or y = const (along x and the slices). */\nexport type SectionAxis = 'x' | 'y';\n\n/** A class's outlines in a section, as interleaved `u, v`. */\nexport interface ClassSection {\n  /** Closed outlines, holes included (even-odd). */\n  rings: Float64Array[];\n  /** Open lines; a line of one point is where the class crosses on one slice only. */\n  lines: Float64Array[];\n}\n\nexport interface SectionOptions {\n  /** Slices in the stack. */\n  depth: number;\n  /** Image px across the section's in-plane axis: the image height through x, its width through y. */\n  extent: number;\n  /** In-plane cell size of the closed shapes' cut, image px (default 1). */\n  step?: number;\n  /** Farthest a line moves between neighbouring slices and is still joined, image px (default extent / 10). */\n  maxJump?: number;\n}\n\n/** `[x0, y0, x1, y1]`, image px. */\ntype Box = [number, number, number, number];\n\n/** A ring or line with its extent. */\ninterface Indexed {\n  points: ArrayLike<number>;\n  box: Box;\n}\n\ninterface IndexedSlice {\n  z: number;\n  rings: Indexed[];\n  /** Each ring's feature (see SliceOutlines.ringGroups); absent: one feature. */\n  ringGroups?: ArrayLike<number>;\n  lines: Indexed[];\n}\n\n/**\n * Every class's outlines with each ring's and line's extent (and the class's): made once, it cuts\n * any number of sections visiting only the outlines a plane crosses.\n */\nexport interface SectionIndex {\n  readonly classes: ReadonlyMap<string, { box: Box; slices: readonly IndexedSlice[] }>;\n}\n\n/** Index every class's outlines for cutting (see {@link SectionIndex}). */\nexport function indexOutlines(byClass: ReadonlyMap<string, readonly SliceOutlines[]>): SectionIndex {\n  const classes = new Map<string, { box: Box; slices: IndexedSlice[] }>();\n  for (const [label, slices] of byClass) {\n    const box: Box = [Infinity, Infinity, -Infinity, -Infinity];\n    const indexed = slices.map((s) => ({\n      z: s.z,\n      rings: s.rings.map((points) => withBox(points, box)),\n      ...(s.ringGroups ? { ringGroups: s.ringGroups } : {}),\n      lines: (s.lines ?? []).map((points) => withBox(points, box)),\n    }));\n    if (box[0] <= box[2]) classes.set(label, { box, slices: indexed });\n  }\n  return { classes };\n}\n\nfunction withBox(points: ArrayLike<number>, total: Box): Indexed {\n  const box: Box = [Infinity, Infinity, -Infinity, -Infinity];\n  for (let i = 0; i + 1 < points.length; i += 2) {\n    if (points[i] < box[0]) box[0] = points[i];\n    if (points[i] > box[2]) box[2] = points[i];\n    if (points[i + 1] < box[1]) box[1] = points[i + 1];\n    if (points[i + 1] > box[3]) box[3] = points[i + 1];\n  }\n  total[0] = Math.min(total[0], box[0]);\n  total[1] = Math.min(total[1], box[1]);\n  total[2] = Math.max(total[2], box[2]);\n  total[3] = Math.max(total[3], box[3]);\n  return { points, box };\n}\n\n/** Whether a box spans the plane `axis = at`. */\nfunction spans(box: Box, axis: SectionAxis, at: number): boolean {\n  return axis === 'x' ? box[0] <= at && at <= box[2] : box[1] <= at && at <= box[3];\n}\n\n/**\n * Each class's cut by the plane `axis = at`; classes the plane misses are left out. Pass an\n * {@link indexOutlines} index to cut many sections of the same outlines.\n */\nexport function sectionOutlines(\n  outlines: SectionIndex | ReadonlyMap<string, readonly SliceOutlines[]>,\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Map<string, ClassSection> {\n  const index = outlines instanceof Map ? indexOutlines(outlines) : (outlines as SectionIndex);\n  const out = new Map<string, ClassSection>();\n  for (const [label, { box, slices }] of index.classes) {\n    if (!spans(box, axis, at)) continue;\n    const rings = cutShapes(slices, axis, at, opts);\n    const lines = cutLines(slices, axis, at, opts);\n    if (rings.length || lines.length) out.set(label, { rings, lines });\n  }\n  return out;\n}\n\n/** The closed shapes' cut: intervals per slice, rasterised one slice thick and traced. */\nfunction cutShapes(\n  slices: readonly IndexedSlice[],\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Float64Array[] {\n  const step = Math.max(opts.step ?? 1, 1e-6);\n  const depth = Math.max(1, Math.ceil(opts.depth));\n  const cells = Math.max(1, Math.ceil(opts.extent / step));\n  // Through x: columns are slices, rows in-plane cells. Through y: the other way round.\n  const w = axis === 'x' ? depth : cells;\n  const h = axis === 'x' ? cells : depth;\n  let mask: Uint8Array | null = null;\n  for (const s of slices) {\n    if (!s.rings.length || s.z < 0 || s.z >= depth) continue;\n    const crossed: ArrayLike<number>[] = [];\n    const groups: number[] = [];\n    s.rings.forEach((r, i) => {\n      if (!spans(r.box, axis, at)) return;\n      crossed.push(r.points);\n      groups.push(s.ringGroups?.[i] ?? 0);\n    });\n    if (!crossed.length) continue;\n    // Each feature's intervals, set into the mask: the features as their union.\n    for (const feature of featureRings(crossed, s.ringGroups ? groups : undefined)) {\n      const crossings = ringCrossings(feature, axis, at);\n      for (let c = 0; c + 1 < crossings.length; c += 2) {\n        // Cells whose centre lies in the interval (the pixel-centre rule).\n        const from = Math.max(0, Math.ceil(crossings[c] / step - 0.5));\n        const to = Math.min(cells - 1, Math.floor(crossings[c + 1] / step - 0.5));\n        if (to < from) continue;\n        mask ??= new Uint8Array(w * h);\n        for (let k = from; k <= to; k++) mask[axis === 'x' ? k * w + s.z : s.z * w + k] = 1;\n      }\n    }\n  }\n  if (!mask) return [];\n  const toSection = (cx: number, cy: number): [number, number] =>\n    axis === 'x' ? [cx, cy * step] : [cx * step, cy];\n  const rings: Float64Array[] = [];\n  for (const p of maskToPolygons(mask, w, h, 0, 0, 1, 1)) {\n    rings.push(flat(p.xpoints.map((x, i) => toSection(x, p.ypoints[i]))));\n    for (const hole of p.holes ?? []) rings.push(flat(hole.map(([x, y]) => toSection(x, y))));\n  }\n  return rings;\n}\n\n/** Where `rings` cross the plane, along the in-plane axis, sorted (even-odd: pairs are inside). */\nfunction ringCrossings(rings: readonly ArrayLike<number>[], axis: SectionAxis, at: number): number[] {\n  // Through x = at the crossings are y values; through y = at, x values.\n  const a = axis === 'x' ? 0 : 1;\n  const out: number[] = [];\n  for (const r of rings) {\n    const n = r.length >> 1;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n      const pi = r[2 * i + a],\n        pj = r[2 * j + a];\n      if (pi > at !== pj > at) {\n        const qi = r[2 * i + 1 - a],\n          qj = r[2 * j + 1 - a];\n        out.push(qi + ((at - pi) * (qj - qi)) / (pj - pi));\n      }\n    }\n  }\n  return out.sort((p, q) => p - q);\n}\n\n/** The open lines' cut: a point per crossing, joined slice to slice (nearest first, each once). */\nfunction cutLines(\n  slices: readonly IndexedSlice[],\n  axis: SectionAxis,\n  at: number,\n  opts: SectionOptions,\n): Float64Array[] {\n  const maxJump = opts.maxJump ?? opts.extent / 10;\n  const stack = slices\n    .map((s) => ({\n      z: s.z,\n      hits: lineCrossings(\n        s.lines.filter((l) => spans(l.box, axis, at)).map((l) => l.points),\n        axis,\n        at,\n      ),\n    }))\n    .filter((s) => s.hits.length)\n    .sort((p, q) => p.z - q.z);\n  const done: number[][] = [];\n  let open: Array<{ points: number[]; last: number }> = [];\n  let prevZ = -Infinity;\n  for (const { z, hits } of stack) {\n    // A slice without the line between: the chains end there, not bridged across it.\n    if (z !== prevZ + 1) {\n      for (const c of open) done.push(c.points);\n      open = [];\n    }\n    prevZ = z;\n    const pairs: Array<{ chain: number; hit: number; d: number }> = [];\n    open.forEach((c, ci) => hits.forEach((q, hi) => pairs.push({ chain: ci, hit: hi, d: Math.abs(q - c.last) })));\n    pairs.sort((p, q) => p.d - q.d);\n    const nextOpen: typeof open = [];\n    const usedChain = new Set<number>();\n    const usedHit = new Set<number>();\n    for (const p of pairs) {\n      if (p.d > maxJump || usedChain.has(p.chain) || usedHit.has(p.hit)) continue;\n      usedChain.add(p.chain);\n      usedHit.add(p.hit);\n      const chain = open[p.chain];\n      chain.points.push(...point(axis, z, hits[p.hit]));\n      chain.last = hits[p.hit];\n      nextOpen.push(chain);\n    }\n    open.forEach((c, ci) => {\n      if (!usedChain.has(ci)) done.push(c.points);\n    });\n    hits.forEach((q, hi) => {\n      if (!usedHit.has(hi)) nextOpen.push({ points: point(axis, z, q), last: q });\n    });\n    open = nextOpen;\n  }\n  for (const c of open) done.push(c.points);\n  return done.map((p) => Float64Array.from(p));\n}\n\n/** A line's crossing on slice `z` in section coordinates, at the slice's middle. */\nfunction point(axis: SectionAxis, z: number, q: number): [number, number] {\n  return axis === 'x' ? [z + 0.5, q] : [q, z + 0.5];\n}\n\n/** Where open `lines` cross the plane, along the in-plane axis. */\nfunction lineCrossings(lines: readonly ArrayLike<number>[], axis: SectionAxis, at: number): number[] {\n  const a = axis === 'x' ? 0 : 1;\n  const out: number[] = [];\n  for (const l of lines) {\n    for (let i = 2; i + 1 < l.length; i += 2) {\n      const p0 = l[i - 2 + a],\n        p1 = l[i + a];\n      // Half-open, so a vertex on the plane counts once.\n      if (p0 > at !== p1 > at) {\n        const q0 = l[i - 1 - a],\n          q1 = l[i + 1 - a];\n        out.push(q0 + ((at - p0) * (q1 - q0)) / (p1 - p0));\n      }\n    }\n  }\n  return out.sort((p, q) => p - q);\n}\n\nfunction flat(points: ReadonlyArray<readonly [number, number]>): Float64Array {\n  const out = new Float64Array(points.length * 2);\n  points.forEach(([u, v], i) => {\n    out[2 * i] = u;\n    out[2 * i + 1] = v;\n  });\n  return out;\n}\n"]}