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

package/esm2022/lib/geometry/contour.mjs

@@ -0,0 +1,63 @@
+import { traceContours } from 'napari-js/geometry';
+import { makePolygon } from '../models/polygon-factory';
+/**
+ * Pure contour tracing: binary mask / label map → polygons with holes, through
+ * napari-js's `traceContours`. No DOM, no Angular.
+ *
+ * Pixel (x, y) of a mask covers `[x, x + 1) × [y, y + 1)` of its frame, and the
+ * outlines run along pixel EDGES (vertices on whole pixel corners, straight runs
+ * merged into one edge), so `rasterizePolygon` (`geometry/raster`, the pixel-centre
+ * rule) gives back exactly the traced pixels: a region the wand or brush adopts
+ * again after a zoom, pan or undo comes back unchanged. Each blob's holes are its
+ * own interior rings, never a gap that blobs enclose only together. Vertices are
+ * translated by the caller's origin and never clamped: a mask may sit partly
+ * outside the readback window it was painted in (jit-ui#102).
+ */
+/** A traced contour as a closed Polygon, holes as `[[x, y], …]` rings. */
+function toPolygon(c) {
+    const ring = (flat) => {
+        const xs = [];
+        const ys = [];
+        for (let i = 0; i < flat.length; i += 2) {
+            xs.push(flat[i]);
+            ys.push(flat[i + 1]);
+        }
+        return { xs, ys };
+    };
+    const outer = ring(c.outer);
+    const holes = c.holes.map((h) => {
+        const r = ring(h);
+        return r.xs.map((x, k) => [x, r.ys[k]]);
+    });
+    return makePolygon(outer.xs, outer.ys, { holes });
+}
+/**
+ * Trace EVERY 4-connected blob in `mask` (sized w*h) whose area is at least
+ * `minSize` pixels, returning one Polygon per blob translated via
+ * (originX, originY), ordered largest-first (ties in raster order). A blob's
+ * interior rings enclosing at least `minHoleSize` pixels become its
+ * {@link Polygon.holes}. An erase that cuts a region in two therefore yields
+ * both pieces, and a donut keeps its hole.
+ *
+ * The mask is labelled once and each blob traced inside its own bounding box
+ * (RT-16), so the cost is O(w·h + Σ bbox areas).
+ */
+export function maskToPolygons(mask, w, h, originX, originY, minSize = 4, minHoleSize = minSize) {
+    return traceContours({ data: mask, width: w, height: h }, { minSize, minHoleSize, origin: [originX, originY] }).map(toPolygon);
+}
+/**
+ * Trace each instance in an integer label map (0 = background) into polygons —
+ * used to turn a cellpose-style segmentation into region outlines. Pieces with
+ * area below `minSize` are skipped (and holes below it dropped); a label made of
+ * several blobs yields one polygon per blob. Ordered by label, then largest
+ * piece first. Coords are translated via originX/originY (not clamped).
+ *
+ * One labelling pass finds every label's pieces; each is traced inside its own
+ * bounding box (RT-16), instead of rescanning the whole map per label.
+ */
+export function labelsToPolygons(labels, w, h, originX, originY, minSize = 10) {
+    return traceContours({ data: labels, width: w, height: h }, { minSize, minHoleSize: minSize, origin: [originX, originY] })
+        .sort((a, b) => a.value - b.value) // stable: largest first within a label
+        .map(toPolygon);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/geometry/loft.mjs

@@ -0,0 +1,128 @@
+/** Points per line at most: the longest line is resampled at about one point per `step` px. */
+const MAX_POINTS = 2048;
+/** Points per line when matching lines across slices. */
+const MATCH_POINTS = 32;
+/**
+ * The sheet through `slices`' lines, in image pixels (x, y) and slice indices (z: slice k's line at
+ * z = k). Every line is resampled at the same number of points, evenly along its length (about one
+ * per `step` px of the longest), so a line shared by the strips above and below it is one row of
+ * vertices. Lines are matched between neighbouring slices closest first, each at most once, and only
+ * when their boxes overlap; a line without a match ends the sheet there. Empty without two slices
+ * with lines.
+ */
+export function loftLines(slices, step = 1) {
+    const stack = slices
+        .map((s) => ({ z: s.z, lines: s.lines.filter((l) => l.length >= 4) }))
+        .filter((s) => s.lines.length)
+        .sort((a, b) => a.z - b.z);
+    if (stack.length < 2)
+        return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+    let longest = 0;
+    for (const s of stack)
+        for (const l of s.lines)
+            longest = Math.max(longest, lineLength(l));
+    const n = Math.min(MAX_POINTS, Math.max(2, Math.ceil(longest / Math.max(step, 1e-6)) + 1));
+    // Each line's resampled points, once: rows of n vertices.
+    const rows = [];
+    const verts = [];
+    for (const s of stack) {
+        rows.push(s.lines.map((l) => {
+            const first = verts.length / 3;
+            const pts = resample(l, n);
+            for (let i = 0; i < n; i++)
+                verts.push(pts[2 * i], pts[2 * i + 1], s.z);
+            return { first, probe: resample(l, MATCH_POINTS), box: lineBox(l) };
+        }));
+    }
+    const faces = [];
+    for (let k = 0; k + 1 < rows.length; k++) {
+        for (const { a, b, reversed } of matchLines(rows[k], rows[k + 1])) {
+            const at = (i) => b.first + (reversed ? n - 1 - i : i);
+            for (let i = 0; i + 1 < n; i++) {
+                const a0 = a.first + i, a1 = a0 + 1, b0 = at(i), b1 = at(i + 1);
+                faces.push(a0, b0, a1, a1, b0, b1);
+            }
+        }
+    }
+    if (!faces.length)
+        return { vertices: new Float32Array(0), faces: new Uint32Array(0) };
+    return { vertices: Float32Array.from(verts), faces: Uint32Array.from(faces) };
+}
+/** Pairs of lines of two neighbouring slices: closest first (mean distance, either direction), each once. */
+function matchLines(as, bs) {
+    const pairs = [];
+    as.forEach((a, i) => bs.forEach((b, j) => {
+        if (!boxesOverlap(a.box, b.box))
+            return;
+        const forward = meanDistance(a.probe, b.probe, false);
+        const backward = meanDistance(a.probe, b.probe, true);
+        pairs.push({ a: i, b: j, cost: Math.min(forward, backward), reversed: backward < forward });
+    }));
+    pairs.sort((p, q) => p.cost - q.cost);
+    const usedA = new Set();
+    const usedB = new Set();
+    const out = [];
+    for (const p of pairs) {
+        if (usedA.has(p.a) || usedB.has(p.b))
+            continue;
+        usedA.add(p.a);
+        usedB.add(p.b);
+        out.push({ a: as[p.a], b: bs[p.b], reversed: p.reversed });
+    }
+    return out;
+}
+function meanDistance(a, b, reversed) {
+    const n = a.length >> 1;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+        const j = reversed ? n - 1 - i : i;
+        sum += Math.hypot(a[2 * i] - b[2 * j], a[2 * i + 1] - b[2 * j + 1]);
+    }
+    return sum / n;
+}
+/** `n` points evenly spaced along the polyline, both ends kept. */
+function resample(line, n) {
+    const m = line.length >> 1;
+    const cumulative = new Float64Array(m);
+    for (let i = 1; i < m; i++) {
+        cumulative[i] =
+            cumulative[i - 1] + Math.hypot(line[2 * i] - line[2 * i - 2], line[2 * i + 1] - line[2 * i - 1]);
+    }
+    const total = cumulative[m - 1];
+    const out = new Float64Array(2 * n);
+    let seg = 1;
+    for (let i = 0; i < n; i++) {
+        const d = n === 1 ? 0 : (total * i) / (n - 1);
+        while (seg < m - 1 && cumulative[seg] < d)
+            seg++;
+        const span = cumulative[seg] - cumulative[seg - 1];
+        const t = span > 0 ? Math.min(1, Math.max(0, (d - cumulative[seg - 1]) / span)) : 0;
+        out[2 * i] = line[2 * seg - 2] + t * (line[2 * seg] - line[2 * seg - 2]);
+        out[2 * i + 1] = line[2 * seg - 1] + t * (line[2 * seg + 1] - line[2 * seg - 1]);
+    }
+    return out;
+}
+function lineLength(line) {
+    let len = 0;
+    for (let i = 2; i + 1 < line.length; i += 2)
+        len += Math.hypot(line[i] - line[i - 2], line[i + 1] - line[i - 1]);
+    return len;
+}
+function lineBox(line) {
+    const box = [Infinity, Infinity, -Infinity, -Infinity];
+    for (let i = 0; i + 1 < line.length; i += 2) {
+        box[0] = Math.min(box[0], line[i]);
+        box[1] = Math.min(box[1], line[i + 1]);
+        box[2] = Math.max(box[2], line[i]);
+        box[3] = Math.max(box[3], line[i + 1]);
+    }
+    return box;
+}
+/** Whether the boxes overlap, each grown by a tenth of its larger side (a flat line has a thin box). */
+function boxesOverlap(a, b) {
+    const ga = 0.1 * Math.max(a[2] - a[0], a[3] - a[1]);
+    const gb = 0.1 * Math.max(b[2] - b[0], b[3] - b[1]);
+    const g = ga + gb;
+    return a[0] - g <= b[2] && b[0] - g <= a[2] && a[1] - g <= b[3] && b[1] - g <= a[3];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loft.js","sourceRoot":"","sources":["../../../../src/lib/geometry/loft.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The sheet through open polylines traced on a stack of slices (a retinal layer boundary on each\n * B-scan, say): each line joined to its counterpart on the next slice that has lines by a strip of\n * triangles. Slices without lines in between are bridged straight across.\n *\n * Pure: usable from workers.\n */\nimport type { Mesh } from 'napari-js/geometry';\n\n/** A class's open polylines on one slice: interleaved `x, y` image pixels. */\nexport interface SliceLines {\n  z: number;\n  lines: readonly ArrayLike<number>[];\n}\n\n/** Points per line at most: the longest line is resampled at about one point per `step` px. */\nconst MAX_POINTS = 2048;\n/** Points per line when matching lines across slices. */\nconst MATCH_POINTS = 32;\n\n/**\n * The sheet through `slices`' lines, in image pixels (x, y) and slice indices (z: slice k's line at\n * z = k). Every line is resampled at the same number of points, evenly along its length (about one\n * per `step` px of the longest), so a line shared by the strips above and below it is one row of\n * vertices. Lines are matched between neighbouring slices closest first, each at most once, and only\n * when their boxes overlap; a line without a match ends the sheet there. Empty without two slices\n * with lines.\n */\nexport function loftLines(slices: readonly SliceLines[], step = 1): Mesh {\n  const stack = slices\n    .map((s) => ({ z: s.z, lines: s.lines.filter((l) => l.length >= 4) }))\n    .filter((s) => s.lines.length)\n    .sort((a, b) => a.z - b.z);\n  if (stack.length < 2) return { vertices: new Float32Array(0), faces: new Uint32Array(0) };\n\n  let longest = 0;\n  for (const s of stack) for (const l of s.lines) longest = Math.max(longest, lineLength(l));\n  const n = Math.min(MAX_POINTS, Math.max(2, Math.ceil(longest / Math.max(step, 1e-6)) + 1));\n\n  // Each line's resampled points, once: rows of n vertices.\n  const rows: Line[][] = [];\n  const verts: number[] = [];\n  for (const s of stack) {\n    rows.push(\n      s.lines.map((l) => {\n        const first = verts.length / 3;\n        const pts = resample(l, n);\n        for (let i = 0; i < n; i++) verts.push(pts[2 * i], pts[2 * i + 1], s.z);\n        return { first, probe: resample(l, MATCH_POINTS), box: lineBox(l) };\n      }),\n    );\n  }\n\n  const faces: number[] = [];\n  for (let k = 0; k + 1 < rows.length; k++) {\n    for (const { a, b, reversed } of matchLines(rows[k], rows[k + 1])) {\n      const at = (i: number) => b.first + (reversed ? n - 1 - i : i);\n      for (let i = 0; i + 1 < n; i++) {\n        const a0 = a.first + i,\n          a1 = a0 + 1,\n          b0 = at(i),\n          b1 = at(i + 1);\n        faces.push(a0, b0, a1, a1, b0, b1);\n      }\n    }\n  }\n  if (!faces.length) return { vertices: new Float32Array(0), faces: new Uint32Array(0) };\n  return { vertices: Float32Array.from(verts), faces: Uint32Array.from(faces) };\n}\n\ntype Box = [number, number, number, number];\ninterface Line {\n  first: number;\n  probe: Float64Array;\n  box: Box;\n}\n\n/** Pairs of lines of two neighbouring slices: closest first (mean distance, either direction), each once. */\nfunction matchLines(as: readonly Line[], bs: readonly Line[]): Array<{ a: Line; b: Line; reversed: boolean }> {\n  const pairs: Array<{ a: number; b: number; cost: number; reversed: boolean }> = [];\n  as.forEach((a, i) =>\n    bs.forEach((b, j) => {\n      if (!boxesOverlap(a.box, b.box)) return;\n      const forward = meanDistance(a.probe, b.probe, false);\n      const backward = meanDistance(a.probe, b.probe, true);\n      pairs.push({ a: i, b: j, cost: Math.min(forward, backward), reversed: backward < forward });\n    }),\n  );\n  pairs.sort((p, q) => p.cost - q.cost);\n  const usedA = new Set<number>();\n  const usedB = new Set<number>();\n  const out: Array<{ a: Line; b: Line; reversed: boolean }> = [];\n  for (const p of pairs) {\n    if (usedA.has(p.a) || usedB.has(p.b)) continue;\n    usedA.add(p.a);\n    usedB.add(p.b);\n    out.push({ a: as[p.a], b: bs[p.b], reversed: p.reversed });\n  }\n  return out;\n}\n\nfunction meanDistance(a: Float64Array, b: Float64Array, reversed: boolean): number {\n  const n = a.length >> 1;\n  let sum = 0;\n  for (let i = 0; i < n; i++) {\n    const j = reversed ? n - 1 - i : i;\n    sum += Math.hypot(a[2 * i] - b[2 * j], a[2 * i + 1] - b[2 * j + 1]);\n  }\n  return sum / n;\n}\n\n/** `n` points evenly spaced along the polyline, both ends kept. */\nfunction resample(line: ArrayLike<number>, n: number): Float64Array {\n  const m = line.length >> 1;\n  const cumulative = new Float64Array(m);\n  for (let i = 1; i < m; i++) {\n    cumulative[i] =\n      cumulative[i - 1] + Math.hypot(line[2 * i] - line[2 * i - 2], line[2 * i + 1] - line[2 * i - 1]);\n  }\n  const total = cumulative[m - 1];\n  const out = new Float64Array(2 * n);\n  let seg = 1;\n  for (let i = 0; i < n; i++) {\n    const d = n === 1 ? 0 : (total * i) / (n - 1);\n    while (seg < m - 1 && cumulative[seg] < d) seg++;\n    const span = cumulative[seg] - cumulative[seg - 1];\n    const t = span > 0 ? Math.min(1, Math.max(0, (d - cumulative[seg - 1]) / span)) : 0;\n    out[2 * i] = line[2 * seg - 2] + t * (line[2 * seg] - line[2 * seg - 2]);\n    out[2 * i + 1] = line[2 * seg - 1] + t * (line[2 * seg + 1] - line[2 * seg - 1]);\n  }\n  return out;\n}\n\nfunction lineLength(line: ArrayLike<number>): number {\n  let len = 0;\n  for (let i = 2; i + 1 < line.length; i += 2) len += Math.hypot(line[i] - line[i - 2], line[i + 1] - line[i - 1]);\n  return len;\n}\n\nfunction lineBox(line: ArrayLike<number>): Box {\n  const box: Box = [Infinity, Infinity, -Infinity, -Infinity];\n  for (let i = 0; i + 1 < line.length; i += 2) {\n    box[0] = Math.min(box[0], line[i]);\n    box[1] = Math.min(box[1], line[i + 1]);\n    box[2] = Math.max(box[2], line[i]);\n    box[3] = Math.max(box[3], line[i + 1]);\n  }\n  return box;\n}\n\n/** Whether the boxes overlap, each grown by a tenth of its larger side (a flat line has a thin box). */\nfunction boxesOverlap(a: Box, b: Box): boolean {\n  const ga = 0.1 * Math.max(a[2] - a[0], a[3] - a[1]);\n  const gb = 0.1 * Math.max(b[2] - b[0], b[3] - b[1]);\n  const g = ga + gb;\n  return a[0] - g <= b[2] && b[0] - g <= a[2] && a[1] - g <= b[3] && b[1] - g <= a[3];\n}\n"]}

package/esm2022/lib/geometry/polylabel.mjs

@@ -0,0 +1,156 @@
+/**
+ * Where to put a label inside a polygon: its pole of inaccessibility, the inside point farthest
+ * from every edge (Garcia-Castellanos & Lombardo's grid search, as in Mapbox's polylabel). Unlike
+ * the centroid it is always inside, also for a U-shaped or ring-shaped region.
+ *
+ * Pure: usable from workers.
+ */
+/**
+ * The pole of inaccessibility of `rings`, to within `precision` (default: 1/100 of the shorter
+ * side of the exterior's box, at least 0.5). Null for an exterior with fewer than three vertices.
+ */
+export function polylabel(rings, precision) {
+    const outer = rings[0];
+    if (!outer || outer.length < 6)
+        return null;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (let i = 0; i + 1 < outer.length; i += 2) {
+        if (outer[i] < minX)
+            minX = outer[i];
+        if (outer[i] > maxX)
+            maxX = outer[i];
+        if (outer[i + 1] < minY)
+            minY = outer[i + 1];
+        if (outer[i + 1] > maxY)
+            maxY = outer[i + 1];
+    }
+    const width = maxX - minX;
+    const height = maxY - minY;
+    const cellSize = Math.min(width, height);
+    const eps = precision ?? Math.max(0.5, cellSize / 100);
+    if (cellSize <= 0)
+        return { x: minX, y: minY, distance: 0 };
+    const cell = (x, y, h) => {
+        const d = signedDistance(x, y, rings);
+        return { x, y, h, d, max: d + h * Math.SQRT2 };
+    };
+    const queue = new MaxHeap();
+    const h = cellSize / 2;
+    for (let x = minX; x < maxX; x += cellSize) {
+        for (let y = minY; y < maxY; y += cellSize)
+            queue.push(cell(x + h, y + h, h));
+    }
+    // The centroid of the box is a good first guess, the area centroid often a better one.
+    let best = cell(minX + width / 2, minY + height / 2, 0);
+    const centroid = areaCentroid(outer);
+    if (centroid) {
+        const c = cell(centroid[0], centroid[1], 0);
+        if (c.d > best.d)
+            best = c;
+    }
+    let guard = 0;
+    while (queue.size && guard++ < 10_000) {
+        const c = queue.pop();
+        if (c.d > best.d)
+            best = c;
+        if (c.max - best.d <= eps)
+            continue;
+        const q = c.h / 2;
+        queue.push(cell(c.x - q, c.y - q, q));
+        queue.push(cell(c.x + q, c.y - q, q));
+        queue.push(cell(c.x - q, c.y + q, q));
+        queue.push(cell(c.x + q, c.y + q, q));
+    }
+    return { x: best.x, y: best.y, distance: Math.max(0, best.d) };
+}
+/** Distance from (x, y) to the nearest edge of `rings`, positive inside (even-odd), negative outside. */
+export function signedDistance(x, y, rings) {
+    let inside = false;
+    let min = Infinity;
+    for (const r of rings) {
+        const n = r.length >> 1;
+        for (let i = 0, j = n - 1; i < n; j = i++) {
+            const ax = r[2 * i], ay = r[2 * i + 1], bx = r[2 * j], by = r[2 * j + 1];
+            if (ay > y !== by > y && x < ((bx - ax) * (y - ay)) / (by - ay) + ax)
+                inside = !inside;
+            const d = segmentDistanceSq(x, y, ax, ay, bx, by);
+            if (d < min)
+                min = d;
+        }
+    }
+    return (inside ? 1 : -1) * Math.sqrt(min);
+}
+function segmentDistanceSq(px, py, ax, ay, bx, by) {
+    let x = ax, y = ay;
+    let dx = bx - x, dy = by - y;
+    if (dx !== 0 || dy !== 0) {
+        const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
+        if (t > 1) {
+            x = bx;
+            y = by;
+        }
+        else if (t > 0) {
+            x += dx * t;
+            y += dy * t;
+        }
+    }
+    dx = px - x;
+    dy = py - y;
+    return dx * dx + dy * dy;
+}
+/** The area centroid of one ring, or null for a degenerate one. */
+function areaCentroid(r) {
+    const n = r.length >> 1;
+    let area = 0, cx = 0, cy = 0;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const f = r[2 * i] * r[2 * j + 1] - r[2 * j] * r[2 * i + 1];
+        cx += (r[2 * i] + r[2 * j]) * f;
+        cy += (r[2 * i + 1] + r[2 * j + 1]) * f;
+        area += f * 3;
+    }
+    return area === 0 ? null : [cx / area, cy / area];
+}
+/** A binary max-heap of cells by `max`. */
+class MaxHeap {
+    constructor() {
+        this.items = [];
+    }
+    get size() {
+        return this.items.length;
+    }
+    push(c) {
+        const a = this.items;
+        a.push(c);
+        let i = a.length - 1;
+        while (i > 0) {
+            const p = (i - 1) >> 1;
+            if (a[p].max >= a[i].max)
+                break;
+            [a[p], a[i]] = [a[i], a[p]];
+            i = p;
+        }
+    }
+    pop() {
+        const a = this.items;
+        const top = a[0];
+        const last = a.pop();
+        if (a.length && last) {
+            a[0] = last;
+            let i = 0;
+            for (;;) {
+                const l = 2 * i + 1, r = l + 1;
+                let m = i;
+                if (l < a.length && a[l].max > a[m].max)
+                    m = l;
+                if (r < a.length && a[r].max > a[m].max)
+                    m = r;
+                if (m === i)
+                    break;
+                [a[m], a[i]] = [a[i], a[m]];
+                i = m;
+            }
+        }
+        return top;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polylabel.js","sourceRoot":"","sources":["../../../../src/lib/geometry/polylabel.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Where to put a label inside a polygon: its pole of inaccessibility, the inside point farthest\n * from every edge (Garcia-Castellanos & Lombardo's grid search, as in Mapbox's polylabel). Unlike\n * the centroid it is always inside, also for a U-shaped or ring-shaped region.\n *\n * Pure: usable from workers.\n */\n\n/** A polygon as interleaved `x, y` rings: the exterior first, then its holes. */\nexport type FlatRings = readonly ArrayLike<number>[];\n\n/** The pole of inaccessibility `[x, y]` and its distance to the nearest edge. */\nexport interface LabelPoint {\n  x: number;\n  y: number;\n  /** Distance from the point to the nearest edge: how much room a label has around it. */\n  distance: number;\n}\n\ninterface Cell {\n  x: number;\n  y: number;\n  /** Half the cell's edge. */\n  h: number;\n  /** Signed distance from the centre to the polygon (positive inside). */\n  d: number;\n  /** The best distance any point of the cell can reach. */\n  max: number;\n}\n\n/**\n * The pole of inaccessibility of `rings`, to within `precision` (default: 1/100 of the shorter\n * side of the exterior's box, at least 0.5). Null for an exterior with fewer than three vertices.\n */\nexport function polylabel(rings: FlatRings, precision?: number): LabelPoint | null {\n  const outer = rings[0];\n  if (!outer || outer.length < 6) return null;\n  let minX = Infinity,\n    minY = Infinity,\n    maxX = -Infinity,\n    maxY = -Infinity;\n  for (let i = 0; i + 1 < outer.length; i += 2) {\n    if (outer[i] < minX) minX = outer[i];\n    if (outer[i] > maxX) maxX = outer[i];\n    if (outer[i + 1] < minY) minY = outer[i + 1];\n    if (outer[i + 1] > maxY) maxY = outer[i + 1];\n  }\n  const width = maxX - minX;\n  const height = maxY - minY;\n  const cellSize = Math.min(width, height);\n  const eps = precision ?? Math.max(0.5, cellSize / 100);\n  if (cellSize <= 0) return { x: minX, y: minY, distance: 0 };\n\n  const cell = (x: number, y: number, h: number): Cell => {\n    const d = signedDistance(x, y, rings);\n    return { x, y, h, d, max: d + h * Math.SQRT2 };\n  };\n  const queue = new MaxHeap();\n  const h = cellSize / 2;\n  for (let x = minX; x < maxX; x += cellSize) {\n    for (let y = minY; y < maxY; y += cellSize) queue.push(cell(x + h, y + h, h));\n  }\n  // The centroid of the box is a good first guess, the area centroid often a better one.\n  let best = cell(minX + width / 2, minY + height / 2, 0);\n  const centroid = areaCentroid(outer);\n  if (centroid) {\n    const c = cell(centroid[0], centroid[1], 0);\n    if (c.d > best.d) best = c;\n  }\n  let guard = 0;\n  while (queue.size && guard++ < 10_000) {\n    const c = queue.pop() as Cell;\n    if (c.d > best.d) best = c;\n    if (c.max - best.d <= eps) continue;\n    const q = c.h / 2;\n    queue.push(cell(c.x - q, c.y - q, q));\n    queue.push(cell(c.x + q, c.y - q, q));\n    queue.push(cell(c.x - q, c.y + q, q));\n    queue.push(cell(c.x + q, c.y + q, q));\n  }\n  return { x: best.x, y: best.y, distance: Math.max(0, best.d) };\n}\n\n/** Distance from (x, y) to the nearest edge of `rings`, positive inside (even-odd), negative outside. */\nexport function signedDistance(x: number, y: number, rings: FlatRings): number {\n  let inside = false;\n  let min = Infinity;\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 ax = r[2 * i],\n        ay = r[2 * i + 1],\n        bx = r[2 * j],\n        by = r[2 * j + 1];\n      if (ay > y !== by > y && x < ((bx - ax) * (y - ay)) / (by - ay) + ax) inside = !inside;\n      const d = segmentDistanceSq(x, y, ax, ay, bx, by);\n      if (d < min) min = d;\n    }\n  }\n  return (inside ? 1 : -1) * Math.sqrt(min);\n}\n\nfunction segmentDistanceSq(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  let x = ax,\n    y = ay;\n  let dx = bx - x,\n    dy = by - y;\n  if (dx !== 0 || dy !== 0) {\n    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);\n    if (t > 1) {\n      x = bx;\n      y = by;\n    } else if (t > 0) {\n      x += dx * t;\n      y += dy * t;\n    }\n  }\n  dx = px - x;\n  dy = py - y;\n  return dx * dx + dy * dy;\n}\n\n/** The area centroid of one ring, or null for a degenerate one. */\nfunction areaCentroid(r: ArrayLike<number>): [number, number] | null {\n  const n = r.length >> 1;\n  let area = 0,\n    cx = 0,\n    cy = 0;\n  for (let i = 0, j = n - 1; i < n; j = i++) {\n    const f = r[2 * i] * r[2 * j + 1] - r[2 * j] * r[2 * i + 1];\n    cx += (r[2 * i] + r[2 * j]) * f;\n    cy += (r[2 * i + 1] + r[2 * j + 1]) * f;\n    area += f * 3;\n  }\n  return area === 0 ? null : [cx / area, cy / area];\n}\n\n/** A binary max-heap of cells by `max`. */\nclass MaxHeap {\n  private readonly items: Cell[] = [];\n\n  get size(): number {\n    return this.items.length;\n  }\n\n  push(c: Cell): void {\n    const a = this.items;\n    a.push(c);\n    let i = a.length - 1;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (a[p].max >= a[i].max) break;\n      [a[p], a[i]] = [a[i], a[p]];\n      i = p;\n    }\n  }\n\n  pop(): Cell | undefined {\n    const a = this.items;\n    const top = a[0];\n    const last = a.pop();\n    if (a.length && last) {\n      a[0] = last;\n      let i = 0;\n      for (;;) {\n        const l = 2 * i + 1,\n          r = l + 1;\n        let m = i;\n        if (l < a.length && a[l].max > a[m].max) m = l;\n        if (r < a.length && a[r].max > a[m].max) m = r;\n        if (m === i) break;\n        [a[m], a[i]] = [a[i], a[m]];\n        i = m;\n      }\n    }\n    return top;\n  }\n}\n"]}

package/esm2022/lib/geometry/raster.mjs

@@ -0,0 +1,98 @@
+import { rasterizePolygon as rasterizeRing } from 'napari-js/geometry';
+/**
+ * The largest bbox (in pixels) {@link rasterizePolygon} allocates before it
+ * falls back to clipping at the window. Also the cap the wand/brush use to
+ * decide whether a region can be edited at the current zoom.
+ */
+export const MAX_RASTER_PIXELS = 4096 * 4096;
+/** `[x0, y0, x1, y1, …]` from parallel arrays, the ring layout napari-js takes. */
+function flatRing(xs, ys) {
+    const out = new Array(xs.length * 2);
+    for (let i = 0; i < xs.length; i++) {
+        out[i * 2] = xs[i];
+        out[i * 2 + 1] = ys[i];
+    }
+    return out;
+}
+/**
+ * Rasterize a closed polygon (minus its holes) into a bbox-relative mask, e.g.
+ * as the starting point for a wand/brush stroke accumulator.
+ *
+ * Pixel (px, py) covers `[px, px + 1) × [py, py + 1)` and is set when its centre
+ * is inside — the rule under which the pixel-edge outlines `geometry/contour`
+ * traces come back as exactly the pixels they were traced from.
+ *
+ * Returns the bbox origin plus the filled mask, or null if the polygon is
+ * degenerate (covers no pixel centre). The polygon's full extent is kept even
+ * where it is negative or exceeds `imageWidth`×`imageHeight` (jit-ui#102); only
+ * a bbox larger than {@link MAX_RASTER_PIXELS} is clipped to that window (rare:
+ * a region enormous at the current zoom; accepts the clip).
+ */
+export function rasterizePolygon(xpoints, ypoints, imageWidth, imageHeight, holes) {
+    if (xpoints.length < 3)
+        return null;
+    const outer = flatRing(xpoints, ypoints);
+    const inner = holes?.map((ring) => flatRing(ring.map((p) => p[0]), ring.map((p) => p[1])));
+    const bounds = { x: 0, y: 0, width: imageWidth, height: imageHeight };
+    let m;
+    try {
+        m = rasterizeRing(outer, inner, { bounds, maxPixels: MAX_RASTER_PIXELS });
+    }
+    catch (err) {
+        // Still over the cap once clipped to the window (a large export mask): allocate the clip.
+        if (!(err instanceof RangeError))
+            throw err;
+        m = rasterizeRing(outer, inner, { bounds, clip: true, maxPixels: Infinity });
+    }
+    return m && { bx: m.x, by: m.y, bw: m.width, bh: m.height, mask: m.data };
+}
+/** Returns true if the two bbox-relative masks share at least one set pixel. */
+export function masksOverlap(a, b) {
+    const ix0 = Math.max(a.bx, b.bx);
+    const iy0 = Math.max(a.by, b.by);
+    const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);
+    const iy1 = Math.min(a.by + a.bh, b.by + b.bh);
+    if (ix0 >= ix1 || iy0 >= iy1)
+        return false;
+    for (let y = iy0; y < iy1; y++) {
+        const ar = (y - a.by) * a.bw;
+        const br = (y - b.by) * b.bw;
+        for (let x = ix0; x < ix1; x++) {
+            if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)])
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Allocate a fresh accumulator covering both masks and OR them in. The
+ * resulting mask's bbox is the smallest rectangle containing both inputs.
+ */
+export function unionMasks(a, b) {
+    const ux0 = Math.min(a.bx, b.bx);
+    const uy0 = Math.min(a.by, b.by);
+    const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);
+    const uy1 = Math.max(a.by + a.bh, b.by + b.bh);
+    const ubw = ux1 - ux0;
+    const ubh = uy1 - uy0;
+    const umask = new Uint8Array(ubw * ubh);
+    const dax = a.bx - ux0;
+    const day = a.by - uy0;
+    for (let row = 0; row < a.bh; row++) {
+        const src = row * a.bw;
+        const dst = (row + day) * ubw + dax;
+        umask.set(a.mask.subarray(src, src + a.bw), dst);
+    }
+    const dbx = b.bx - ux0;
+    const dby = b.by - uy0;
+    for (let row = 0; row < b.bh; row++) {
+        const srcRow = row * b.bw;
+        const dstRow = (row + dby) * ubw;
+        for (let col = 0; col < b.bw; col++) {
+            if (b.mask[srcRow + col])
+                umask[dstRow + (dbx + col)] = 1;
+        }
+    }
+    return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"raster.js","sourceRoot":"","sources":["../../../../src/lib/geometry/raster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAkBvE;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAAC;AAE7C,mFAAmF;AACnF,SAAS,QAAQ,CAAC,EAAqB,EAAE,EAAqB;IAC5D,MAAM,GAAG,GAAG,IAAI,KAAK,CAAS,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACnB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAiB,EACjB,OAAiB,EACjB,UAAkB,EAClB,WAAmB,EACnB,KAAoB;IAEpB,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IACpC,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,KAAK,GAAG,KAAK,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAChC,QAAQ,CACN,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EACrB,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACtB,CACF,CAAC;IACF,MAAM,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IACtE,IAAI,CAAmC,CAAC;IACxC,IAAI,CAAC;QACH,CAAC,GAAG,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC5E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,0FAA0F;QAC1F,IAAI,CAAC,CAAC,GAAG,YAAY,UAAU,CAAC;YAAE,MAAM,GAAG,CAAC;QAC5C,CAAC,GAAG,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC/E,CAAC;IACD,OAAO,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;AAC5E,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,YAAY,CAAC,CAAW,EAAE,CAAW;IACnD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG;QAAE,OAAO,KAAK,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QAC7B,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/B,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;QACtE,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,CAAW,EAAE,CAAW;IACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACtB,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IACtB,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;IAExC,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC;IACvB,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC;IACvB,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QACpC,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;QACvB,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,CAAC;QACpC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IACnD,CAAC;IACD,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC;IACvB,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,CAAC;IACvB,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;QACpC,MAAM,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;QACjC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC;YACpC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC;gBAAE,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QAC5D,CAAC;IACH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AAC7D,CAAC","sourcesContent":["import { rasterizePolygon as rasterizeRing } from 'napari-js/geometry';\n\n/**\n * Pure binary-mask helpers: polygon rasterization (napari-js's `rasterizePolygon`)\n * and bbox-relative mask set operations. No DOM, no Angular — the mask-export\n * worker imports this.\n */\n\n/** A bbox-relative binary mask (1 = filled, 0 = empty) whose pixel (0,0) sits\n *  at (bx, by) in the frame it was rasterized in. */\nexport interface BBoxMask {\n  bx: number;\n  by: number;\n  bw: number;\n  bh: number;\n  mask: Uint8Array;\n}\n\n/**\n * The largest bbox (in pixels) {@link rasterizePolygon} allocates before it\n * falls back to clipping at the window. Also the cap the wand/brush use to\n * decide whether a region can be edited at the current zoom.\n */\nexport const MAX_RASTER_PIXELS = 4096 * 4096;\n\n/** `[x0, y0, x1, y1, …]` from parallel arrays, the ring layout napari-js takes. */\nfunction flatRing(xs: ArrayLike<number>, ys: ArrayLike<number>): number[] {\n  const out = new Array<number>(xs.length * 2);\n  for (let i = 0; i < xs.length; i++) {\n    out[i * 2] = xs[i];\n    out[i * 2 + 1] = ys[i];\n  }\n  return out;\n}\n\n/**\n * Rasterize a closed polygon (minus its holes) into a bbox-relative mask, e.g.\n * as the starting point for a wand/brush stroke accumulator.\n *\n * Pixel (px, py) covers `[px, px + 1) × [py, py + 1)` and is set when its centre\n * is inside — the rule under which the pixel-edge outlines `geometry/contour`\n * traces come back as exactly the pixels they were traced from.\n *\n * Returns the bbox origin plus the filled mask, or null if the polygon is\n * degenerate (covers no pixel centre). The polygon's full extent is kept even\n * where it is negative or exceeds `imageWidth`×`imageHeight` (jit-ui#102); only\n * a bbox larger than {@link MAX_RASTER_PIXELS} is clipped to that window (rare:\n * a region enormous at the current zoom; accepts the clip).\n */\nexport function rasterizePolygon(\n  xpoints: number[],\n  ypoints: number[],\n  imageWidth: number,\n  imageHeight: number,\n  holes?: number[][][],\n): BBoxMask | null {\n  if (xpoints.length < 3) return null;\n  const outer = flatRing(xpoints, ypoints);\n  const inner = holes?.map((ring) =>\n    flatRing(\n      ring.map((p) => p[0]),\n      ring.map((p) => p[1]),\n    ),\n  );\n  const bounds = { x: 0, y: 0, width: imageWidth, height: imageHeight };\n  let m: ReturnType<typeof rasterizeRing>;\n  try {\n    m = rasterizeRing(outer, inner, { bounds, maxPixels: MAX_RASTER_PIXELS });\n  } catch (err) {\n    // Still over the cap once clipped to the window (a large export mask): allocate the clip.\n    if (!(err instanceof RangeError)) throw err;\n    m = rasterizeRing(outer, inner, { bounds, clip: true, maxPixels: Infinity });\n  }\n  return m && { bx: m.x, by: m.y, bw: m.width, bh: m.height, mask: m.data };\n}\n\n/** Returns true if the two bbox-relative masks share at least one set pixel. */\nexport function masksOverlap(a: BBoxMask, b: BBoxMask): boolean {\n  const ix0 = Math.max(a.bx, b.bx);\n  const iy0 = Math.max(a.by, b.by);\n  const ix1 = Math.min(a.bx + a.bw, b.bx + b.bw);\n  const iy1 = Math.min(a.by + a.bh, b.by + b.bh);\n  if (ix0 >= ix1 || iy0 >= iy1) return false;\n  for (let y = iy0; y < iy1; y++) {\n    const ar = (y - a.by) * a.bw;\n    const br = (y - b.by) * b.bw;\n    for (let x = ix0; x < ix1; x++) {\n      if (a.mask[ar + (x - a.bx)] && b.mask[br + (x - b.bx)]) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Allocate a fresh accumulator covering both masks and OR them in. The\n * resulting mask's bbox is the smallest rectangle containing both inputs.\n */\nexport function unionMasks(a: BBoxMask, b: BBoxMask): BBoxMask {\n  const ux0 = Math.min(a.bx, b.bx);\n  const uy0 = Math.min(a.by, b.by);\n  const ux1 = Math.max(a.bx + a.bw, b.bx + b.bw);\n  const uy1 = Math.max(a.by + a.bh, b.by + b.bh);\n  const ubw = ux1 - ux0;\n  const ubh = uy1 - uy0;\n  const umask = new Uint8Array(ubw * ubh);\n\n  const dax = a.bx - ux0;\n  const day = a.by - uy0;\n  for (let row = 0; row < a.bh; row++) {\n    const src = row * a.bw;\n    const dst = (row + day) * ubw + dax;\n    umask.set(a.mask.subarray(src, src + a.bw), dst);\n  }\n  const dbx = b.bx - ux0;\n  const dby = b.by - uy0;\n  for (let row = 0; row < b.bh; row++) {\n    const srcRow = row * b.bw;\n    const dstRow = (row + dby) * ubw;\n    for (let col = 0; col < b.bw; col++) {\n      if (b.mask[srcRow + col]) umask[dstRow + (dbx + col)] = 1;\n    }\n  }\n  return { bx: ux0, by: uy0, bw: ubw, bh: ubh, mask: umask };\n}\n"]}