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

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"]}