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

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

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":"AAAA;;;;;;GAMG;AAUH,oDAAoD;AACpD,MAAM,UAAU,UAAU,CAAC,EAAqB,EAAE,EAAqB;IACrE,IAAI,IAAI,GAAG,QAAQ,EACjB,IAAI,GAAG,CAAC,QAAQ,EAChB,IAAI,GAAG,QAAQ,EACf,IAAI,GAAG,CAAC,QAAQ,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI;YAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;AACpC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,EAAU,EAAE,EAAU,EAAE,EAAqB,EAAE,EAAqB;IAC9F,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;IACpB,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EACd,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACb,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,EACd,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACb,MAAM,SAAS,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;QACvF,IAAI,SAAS;YAAE,MAAM,GAAG,CAAC,MAAM,CAAC;IAClC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,uBAAuB,CACrC,EAAU,EACV,EAAU,EACV,EAAqB,EACrB,EAAqB,EACrB,KAAoB;IAEpB,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/C,IAAI,KAAK,EAAE,CAAC;QACV,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;QAClD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,iGAAiG;AACjG,MAAM,UAAU,eAAe,CAAC,EAAU,EAAE,EAAU,EAAE,IAAsC;IAC5F,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;IACtB,IAAI,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IACxB,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EACnB,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClB,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EACnB,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClB,MAAM,SAAS,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;QACvF,IAAI,SAAS;YAAE,MAAM,GAAG,CAAC,MAAM,CAAC;IAClC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,wBAAwB,CACtC,OAAiB,EACjB,OAAiB,EACjB,EAAU,EACV,EAAU,EACV,MAAc;IAEd,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3B,MAAM,EAAE,GAAa,EAAE,CAAC;IACxB,MAAM,EAAE,GAAa,EAAE,CAAC;IACxB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAC3B,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,CAAC;YAC3B,OAAO,EAAE,CAAC;YACV,SAAS;QACX,CAAC;QACD,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACpB,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;AAC/C,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,OAAiB,EACjB,OAAiB,EACjB,EAAU,EACV,EAAU,EACV,MAAc,EACd,MAAM,GAAG,IAAI;IAEb,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IACzB,kFAAkF;IAClF,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACxC,MAAM,MAAM,GAAG,IAAI,KAAK,CAAU,CAAC,CAAC,CAAC;IACrC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAC3B,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QAC3B,MAAM,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QACnC,IAAI,MAAM,CAAC,CAAC,CAAC;YAAE,OAAO,EAAE,CAAC;IAC3B,CAAC;IACD,IAAI,OAAO,KAAK,CAAC;QAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,CAAC;IAC1F,MAAM,EAAE,GAAa,EAAE,CAAC;IACxB,MAAM,EAAE,GAAa,EAAE,CAAC;IACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACf,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YACpB,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC;YAAE,SAAS;QAC/C,0EAA0E;QAC1E,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,EACxB,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;QACvB,MAAM,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAChC,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,MAAM,GAAG,MAAM,CAAC;QAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QACnD,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QAClD,kFAAkF;QAClF,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK;YAAE,SAAS;QACtD,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;QAC7B,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC;AAC/C,CAAC;AAED,0EAA0E;AAC1E,SAAS,YAAY,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU;IAC1F,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,EAChB,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IACf,MAAM,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAC/B,IAAI,IAAI,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACpD,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;IACjD,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAChC,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,EAAY,EAAE,EAAY,EAAE,OAAe;IACtE,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;IACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,CAAC,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;IAExE,+DAA+D;IAC/D,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;IACpB,MAAM,IAAI,GAAG,IAAI,KAAK,CAAU,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/C,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACf,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC;IAEnB,MAAM,KAAK,GAA4B,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACpD,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;QACpB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,EAAsB,CAAC;QAC/C,IAAI,IAAI,GAAG,CAAC,CAAC,EACX,GAAG,GAAG,CAAC,CAAC,CAAC;QACX,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/B,MAAM,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACjE,IAAI,CAAC,GAAG,IAAI,EAAE,CAAC;gBACb,IAAI,GAAG,CAAC,CAAC;gBACT,GAAG,GAAG,CAAC,CAAC;YACV,CAAC;QACH,CAAC;QACD,IAAI,IAAI,GAAG,OAAO,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;YAC9B,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;YACjB,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,MAAM,IAAI,GAAa,EAAE,EACvB,IAAI,GAAa,EAAE,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,qCAAqC;QACrC,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YACZ,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACjB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AAChC,CAAC","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"]}