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

package/esm2022/lib/region-overlay/region-geometry.mjs

@@ -0,0 +1,360 @@
+/**
+ * Region-overlay geometry shared by the OpenSeadragon and napari overlays
+ * (review NAPARI-BOUNDARY-13, OSD-PLOTLY-16).
+ *
+ * Both overlays used to carry their own copy of this code, and the copies had
+ * drifted: napari's hit test ignored holes, multi-part regions and open
+ * polylines, its bézier path drew straight edges without stored handles, and it
+ * rendered nothing for a MultiPolygon. Everything here is pure — no DOM, no
+ * viewer — so the overlays are left with gestures and DOM.
+ *
+ * Coordinates: regions are in WORLD (image-pixel) space. Functions that need a
+ * screen-space tolerance (an open polyline's hit width, a handle's grab
+ * radius) take a {@link ToScreen} projection and measure in its pixels, so they
+ * stay usable at any zoom. Point-in-ring and ring bounds come from
+ * `geometry/ring`.
+ */
+import { MultiPolygon, Polygon, Rectangle } from '../models/region';
+import { resolveHandles } from '../models/bezier';
+import { pointInPolygonWithHoles } from '../geometry/ring';
+/** The identity projection: path data stays in world coordinates. */
+export const WORLD = (x, y) => [x, y];
+/** Screen-px distance from an open polyline within which a point is on it. */
+export const OPEN_PATH_TOL_PX = 6;
+/**
+ * Discriminate a region's bounds. Class instances first; plain objects with the
+ * right fields too, so a region that skipped the store's hydration (JSON from a
+ * host) still draws and hit-tests (jit-ui#124).
+ */
+export function boundsKind(b) {
+    if (!b)
+        return null;
+    if (b instanceof Rectangle)
+        return 'rect';
+    if (b instanceof Polygon)
+        return 'poly';
+    if (b instanceof MultiPolygon)
+        return 'multi';
+    if (Array.isArray(b.polygons))
+        return 'multi';
+    if ('xpoints' in b || 'npoints' in b)
+        return 'poly';
+    if ('width' in b && 'x' in b)
+        return 'rect';
+    return null;
+}
+/** A polygon's ring as parallel arrays: the exterior for `ring` -1, else hole `ring`. */
+export function ringOf(p, ring) {
+    if (ring < 0)
+        return { xs: p.xpoints, ys: p.ypoints };
+    const pts = p.holes?.[ring] ?? [];
+    return { xs: pts.map((q) => q[0]), ys: pts.map((q) => q[1]) };
+}
+/**
+ * A polygon ring's bézier handles (absolute, world space): the stored offsets
+ * when present, else the Catmull-Rom default the curve is drawn with. Holes are
+ * always closed.
+ */
+export function ringHandles(p, ring) {
+    const { xs, ys } = ringOf(p, ring);
+    return ring < 0
+        ? resolveHandles(xs, ys, p.closed !== false, p.handlesIn, p.handlesOut)
+        : resolveHandles(xs, ys, true, p.holeHandlesIn?.[ring], p.holeHandlesOut?.[ring]);
+}
+/** The rings of a polygon, exterior first: -1, then each hole index. */
+function ringIndices(p) {
+    return [-1, ...(p.holes ?? []).map((_, i) => i)];
+}
+// ── bounds and containment ───────────────────────────────────────────────
+/**
+ * A region's axis-aligned bounding box in world coordinates (every part of a
+ * multi-polygon), or null for empty geometry. Loops rather than
+ * `Math.min(...spread)`, which throws on a large imported annotation.
+ */
+export function regionBBox(region) {
+    const b = region.bounds;
+    const kind = boundsKind(b);
+    if (kind === 'rect') {
+        const r = b;
+        return { x0: r.x, y0: r.y, x1: r.x + r.width, y1: r.y + r.height };
+    }
+    if (!kind)
+        return null;
+    const parts = kind === 'poly' ? [b] : b.polygons;
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of parts) {
+        const xs = p.xpoints ?? [], ys = p.ypoints ?? [];
+        for (let i = 0; i < xs.length; i++) {
+            if (xs[i] < x0)
+                x0 = xs[i];
+            if (xs[i] > x1)
+                x1 = xs[i];
+            if (ys[i] < y0)
+                y0 = ys[i];
+            if (ys[i] > y1)
+                y1 = ys[i];
+        }
+    }
+    return x1 >= x0 ? { x0, y0, x1, y1 } : null;
+}
+/** Shortest distance from (px,py) to the segment (ax,ay)–(bx,by), in the units given. */
+export function segmentDistance(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));
+}
+/**
+ * Whether world point (x, y) lands on `region`: a rectangle by its (inclusive)
+ * box; a closed polygon by its exterior minus its holes; a multi-polygon by any
+ * part (minus that part's holes); an open polyline — which has no interior —
+ * within `tolPx` screen pixels of its line.
+ */
+export function regionContains(region, x, y, opts = {}) {
+    const b = region.bounds;
+    switch (boundsKind(b)) {
+        case 'rect': {
+            const r = b;
+            return x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height;
+        }
+        case 'multi':
+            return b.polygons.some((p) => closedContains(p, x, y));
+        case 'poly': {
+            const p = b;
+            if (p.closed !== false)
+                return closedContains(p, x, y);
+            return nearPolyline(p.xpoints, p.ypoints, x, y, opts.toScreen ?? WORLD, opts.tolPx ?? OPEN_PATH_TOL_PX);
+        }
+        default:
+            return false;
+    }
+}
+function closedContains(p, x, y) {
+    return pointInPolygonWithHoles(x, y, p.xpoints ?? [], p.ypoints ?? [], p.holes);
+}
+function nearPolyline(xs, ys, x, y, toScreen, tol) {
+    if (xs.length < 2)
+        return false;
+    const [px, py] = toScreen(x, y);
+    let [ax, ay] = toScreen(xs[0], ys[0]);
+    for (let i = 1; i < xs.length; i++) {
+        const [bx, by] = toScreen(xs[i], ys[i]);
+        if (segmentDistance(px, py, ax, ay, bx, by) <= tol)
+            return true;
+        ax = bx;
+        ay = by;
+    }
+    return false;
+}
+/** Index of the topmost (last) region containing (x, y), or -1. */
+export function topmostRegionAt(regions, x, y, opts = {}) {
+    for (let i = regions.length - 1; i >= 0; i--) {
+        if (opts.skip?.(regions[i]))
+            continue;
+        if (regionContains(regions[i], x, y, opts))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Indices of every region whose bounding box intersects the world box
+ * [x0,y0]–[x1,y1] (rubber-band selection). `skipProfiles` leaves out
+ * intensity-profile lines, `skip` any other region.
+ */
+export function regionsInRect(regions, x0, y0, x1, y1, opts = {}) {
+    const out = [];
+    regions.forEach((r, i) => {
+        if ((opts.skipProfiles && r.isProfile?.()) || opts.skip?.(r))
+            return;
+        const bb = regionBBox(r);
+        if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0)
+            out.push(i);
+    });
+    return out;
+}
+/**
+ * SVG path `d` for one ring or polyline, projected through `toScreen`.
+ * Straight edges without `handles`; with `handles`, cubic segments through the
+ * stored offsets, or the Catmull-Rom default when they are missing or do not
+ * match the ring (via `resolveHandles`). Closed rings end in `Z`. '' for fewer
+ * than two vertices.
+ */
+export function ringPathD(xs, ys, closed, toScreen, handles) {
+    const n = Math.min(xs.length, ys.length);
+    if (n < 2)
+        return '';
+    const pt = (x, y) => {
+        const q = toScreen(x, y);
+        return `${q[0]},${q[1]}`;
+    };
+    let d = `M ${pt(xs[0], ys[0])}`;
+    if (handles) {
+        const h = resolveHandles(xs, ys, closed, handles.in, handles.out);
+        const segs = closed ? n : n - 1;
+        for (let i = 0; i < segs; i++) {
+            const j = (i + 1) % n;
+            d += ` C ${pt(h[i].out[0], h[i].out[1])} ${pt(h[j].in[0], h[j].in[1])} ${pt(xs[j], ys[j])}`;
+        }
+    }
+    else {
+        for (let i = 1; i < n; i++)
+            d += ` L ${pt(xs[i], ys[i])}`;
+    }
+    return closed ? d + ' Z' : d;
+}
+/**
+ * SVG path `d` for a whole region: a rectangle's four corners; a polygon's
+ * exterior (curved for a bézier region) followed by one subpath per hole
+ * (curved too for a bézier donut); a multi-polygon's parts with their holes.
+ * Holes need `fill-rule: evenodd` (see {@link regionHasHoles}).
+ */
+export function regionPathD(region, toScreen = WORLD) {
+    const b = region.bounds;
+    switch (boundsKind(b)) {
+        case 'rect': {
+            const r = b;
+            return ringPathD([r.x, r.x + r.width, r.x + r.width, r.x], [r.y, r.y, r.y + r.height, r.y + r.height], true, toScreen);
+        }
+        case 'poly':
+            return polygonPathD(b, toScreen, true);
+        case 'multi':
+            return b.polygons
+                .filter((p) => (p.xpoints?.length ?? 0) >= 3)
+                .map((p) => polygonPathD(p, toScreen, false))
+                .join(' ');
+        default:
+            return '';
+    }
+}
+function polygonPathD(p, toScreen, allowBezier) {
+    const closed = p.closed !== false;
+    const bezier = allowBezier && !!p.bezier && (p.xpoints?.length ?? 0) >= 2;
+    let d = ringPathD(p.xpoints ?? [], p.ypoints ?? [], closed, toScreen, bezier ? { in: p.handlesIn, out: p.handlesOut } : undefined);
+    if (!closed)
+        return d;
+    (p.holes ?? []).forEach((ring, hi) => {
+        if (ring.length < 3)
+            return;
+        const { xs, ys } = ringOf(p, hi);
+        d +=
+            ' ' +
+                ringPathD(xs, ys, true, toScreen, bezier ? { in: p.holeHandlesIn?.[hi], out: p.holeHandlesOut?.[hi] } : undefined);
+    });
+    return d;
+}
+/** True when the region draws as several subpaths that need `fill-rule: evenodd`. */
+export function regionHasHoles(region) {
+    const b = region.bounds;
+    const kind = boundsKind(b);
+    if (kind === 'multi')
+        return true;
+    if (kind !== 'poly')
+        return false;
+    const p = b;
+    return p.closed !== false && !!p.holes?.length;
+}
+/**
+ * The handle of `region` under screen point (sx, sy) within `radius` screen
+ * pixels, or null. Rectangles have four corners. Polygons: every bézier
+ * control point first (exterior, then each hole; they sit off the anchors, so
+ * they must win), then the vertices (exterior, then each hole). Pass
+ * `{ bezier: false }` to test vertices only.
+ */
+export function hitHandle(region, sx, sy, toScreen, radius, opts = {}) {
+    const b = region.bounds;
+    const near = (x, y) => {
+        const q = toScreen(x, y);
+        return Math.hypot(sx - q[0], sy - q[1]) <= radius;
+    };
+    const kind = boundsKind(b);
+    if (kind === 'rect') {
+        const r = b;
+        const x0 = r.x, y0 = r.y, x1 = r.x + r.width, y1 = r.y + r.height;
+        const corners = [
+            [x0, y0, [x1, y1]],
+            [x1, y0, [x0, y1]],
+            [x0, y1, [x1, y0]],
+            [x1, y1, [x0, y0]],
+        ];
+        for (let i = 0; i < corners.length; i++) {
+            if (near(corners[i][0], corners[i][1]))
+                return { kind: 'corner', index: i, anchor: corners[i][2] };
+        }
+        return null;
+    }
+    if (kind !== 'poly')
+        return null;
+    const p = b;
+    const rings = ringIndices(p);
+    if (opts.bezier !== false && p.bezier) {
+        for (const ring of rings) {
+            const handles = ringHandles(p, ring);
+            for (let i = 0; i < handles.length; i++) {
+                const h = handles[i];
+                if (h.hasOut && near(h.out[0], h.out[1]))
+                    return { kind: 'bezier', ring, index: i, side: 'out' };
+                if (h.hasIn && near(h.in[0], h.in[1]))
+                    return { kind: 'bezier', ring, index: i, side: 'in' };
+            }
+        }
+    }
+    for (const ring of rings) {
+        const { xs, ys } = ringOf(p, ring);
+        for (let i = 0; i < xs.length; i++) {
+            if (near(xs[i], ys[i]))
+                return { kind: 'vertex', ring, index: i };
+        }
+    }
+    return null;
+}
+/**
+ * The polygon edge nearest screen point (sx, sy), across the exterior and every
+ * hole: its ring (-1 = exterior), the index of its start vertex, and the
+ * distance in screen pixels. Null when the region is not a polygon.
+ */
+export function nearestEdge(region, sx, sy, toScreen) {
+    const b = region.bounds;
+    if (boundsKind(b) !== 'poly')
+        return null;
+    const p = b;
+    let best = null;
+    for (const ring of ringIndices(p)) {
+        const { xs, ys } = ringOf(p, ring);
+        const n = xs.length;
+        const segs = ring >= 0 || p.closed !== false ? n : n - 1;
+        for (let i = 0; i < segs; i++) {
+            const j = (i + 1) % n;
+            const a = toScreen(xs[i], ys[i]);
+            const c = toScreen(xs[j], ys[j]);
+            const dist = segmentDistance(sx, sy, a[0], a[1], c[0], c[1]);
+            if (!best || dist < best.dist)
+                best = { ring, segIndex: i, dist };
+        }
+    }
+    return best;
+}
+/**
+ * The polygon vertex nearest world point (x, y), across the exterior and every
+ * hole, with its distance in world units. Null when the region is not a
+ * polygon or has no vertices.
+ */
+export function nearestVertex(region, x, y) {
+    const b = region.bounds;
+    if (boundsKind(b) !== 'poly')
+        return null;
+    const p = b;
+    let best = null;
+    for (const ring of ringIndices(p)) {
+        const { xs, ys } = ringOf(p, ring);
+        for (let i = 0; i < xs.length; i++) {
+            const dist = Math.hypot(xs[i] - x, ys[i] - y);
+            if (!best || dist < best.dist)
+                best = { ring, index: i, dist };
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-geometry.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/region-geometry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Region-overlay geometry shared by the OpenSeadragon and napari overlays\n * (review NAPARI-BOUNDARY-13, OSD-PLOTLY-16).\n *\n * Both overlays used to carry their own copy of this code, and the copies had\n * drifted: napari's hit test ignored holes, multi-part regions and open\n * polylines, its bézier path drew straight edges without stored handles, and it\n * rendered nothing for a MultiPolygon. Everything here is pure — no DOM, no\n * viewer — so the overlays are left with gestures and DOM.\n *\n * Coordinates: regions are in WORLD (image-pixel) space. Functions that need a\n * screen-space tolerance (an open polyline's hit width, a handle's grab\n * radius) take a {@link ToScreen} projection and measure in its pixels, so they\n * stay usable at any zoom. Point-in-ring and ring bounds come from\n * `geometry/ring`.\n */\nimport { MultiPolygon, Polygon, Rectangle, Region } from '../models/region';\nimport { AnchorHandle, resolveHandles } from '../models/bezier';\nimport { pointInPolygonWithHoles } from '../geometry/ring';\n\n/** World → screen projection, e.g. image → element pixels. */\nexport type ToScreen = (x: number, y: number) => readonly [number, number];\n\n/** The identity projection: path data stays in world coordinates. */\nexport const WORLD: ToScreen = (x, y) => [x, y];\n\n/** An axis-aligned box (inclusive corners). */\nexport interface BBox {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/** Screen-px distance from an open polyline within which a point is on it. */\nexport const OPEN_PATH_TOL_PX = 6;\n\ntype AnyBounds = Region['bounds'] | Record<string, unknown>;\n\n/**\n * Discriminate a region's bounds. Class instances first; plain objects with the\n * right fields too, so a region that skipped the store's hydration (JSON from a\n * host) still draws and hit-tests (jit-ui#124).\n */\nexport function boundsKind(b: AnyBounds | null | undefined): 'rect' | 'poly' | 'multi' | null {\n  if (!b) return null;\n  if (b instanceof Rectangle) return 'rect';\n  if (b instanceof Polygon) return 'poly';\n  if (b instanceof MultiPolygon) return 'multi';\n  if (Array.isArray((b as { polygons?: unknown }).polygons)) return 'multi';\n  if ('xpoints' in b || 'npoints' in b) return 'poly';\n  if ('width' in b && 'x' in b) return 'rect';\n  return null;\n}\n\n/** A polygon's ring as parallel arrays: the exterior for `ring` -1, else hole `ring`. */\nexport function ringOf(p: Polygon, ring: number): { xs: number[]; ys: number[] } {\n  if (ring < 0) return { xs: p.xpoints, ys: p.ypoints };\n  const pts = p.holes?.[ring] ?? [];\n  return { xs: pts.map((q) => q[0]), ys: pts.map((q) => q[1]) };\n}\n\n/**\n * A polygon ring's bézier handles (absolute, world space): the stored offsets\n * when present, else the Catmull-Rom default the curve is drawn with. Holes are\n * always closed.\n */\nexport function ringHandles(p: Polygon, ring: number): AnchorHandle[] {\n  const { xs, ys } = ringOf(p, ring);\n  return ring < 0\n    ? resolveHandles(xs, ys, p.closed !== false, p.handlesIn, p.handlesOut)\n    : resolveHandles(xs, ys, true, p.holeHandlesIn?.[ring], p.holeHandlesOut?.[ring]);\n}\n\n/** The rings of a polygon, exterior first: -1, then each hole index. */\nfunction ringIndices(p: Polygon): number[] {\n  return [-1, ...(p.holes ?? []).map((_, i) => i)];\n}\n\n// ── bounds and containment ───────────────────────────────────────────────\n\n/**\n * A region's axis-aligned bounding box in world coordinates (every part of a\n * multi-polygon), or null for empty geometry. Loops rather than\n * `Math.min(...spread)`, which throws on a large imported annotation.\n */\nexport function regionBBox(region: Pick<Region, 'bounds'>): BBox | null {\n  const b = region.bounds;\n  const kind = boundsKind(b);\n  if (kind === 'rect') {\n    const r = b as Rectangle;\n    return { x0: r.x, y0: r.y, x1: r.x + r.width, y1: r.y + r.height };\n  }\n  if (!kind) return null;\n  const parts = kind === 'poly' ? [b as Polygon] : (b as MultiPolygon).polygons;\n  let x0 = Infinity,\n    y0 = Infinity,\n    x1 = -Infinity,\n    y1 = -Infinity;\n  for (const p of parts) {\n    const xs = p.xpoints ?? [],\n      ys = p.ypoints ?? [];\n    for (let i = 0; i < xs.length; i++) {\n      if (xs[i] < x0) x0 = xs[i];\n      if (xs[i] > x1) x1 = xs[i];\n      if (ys[i] < y0) y0 = ys[i];\n      if (ys[i] > y1) y1 = ys[i];\n    }\n  }\n  return x1 >= x0 ? { x0, y0, x1, y1 } : null;\n}\n\n/** Shortest distance from (px,py) to the segment (ax,ay)–(bx,by), in the units given. */\nexport function segmentDistance(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/** Options for {@link regionContains}. */\nexport interface ContainsOptions {\n  /** Projection the open-polyline tolerance is measured in. Default: world units. */\n  toScreen?: ToScreen;\n  /** Open-polyline hit width, in `toScreen` pixels. Default {@link OPEN_PATH_TOL_PX}. */\n  tolPx?: number;\n}\n\n/**\n * Whether world point (x, y) lands on `region`: a rectangle by its (inclusive)\n * box; a closed polygon by its exterior minus its holes; a multi-polygon by any\n * part (minus that part's holes); an open polyline — which has no interior —\n * within `tolPx` screen pixels of its line.\n */\nexport function regionContains(\n  region: Pick<Region, 'bounds'>,\n  x: number,\n  y: number,\n  opts: ContainsOptions = {},\n): boolean {\n  const b = region.bounds;\n  switch (boundsKind(b)) {\n    case 'rect': {\n      const r = b as Rectangle;\n      return x >= r.x && x <= r.x + r.width && y >= r.y && y <= r.y + r.height;\n    }\n    case 'multi':\n      return (b as MultiPolygon).polygons.some((p) => closedContains(p, x, y));\n    case 'poly': {\n      const p = b as Polygon;\n      if (p.closed !== false) return closedContains(p, x, y);\n      return nearPolyline(p.xpoints, p.ypoints, x, y, opts.toScreen ?? WORLD, opts.tolPx ?? OPEN_PATH_TOL_PX);\n    }\n    default:\n      return false;\n  }\n}\n\nfunction closedContains(p: Polygon, x: number, y: number): boolean {\n  return pointInPolygonWithHoles(x, y, p.xpoints ?? [], p.ypoints ?? [], p.holes);\n}\n\nfunction nearPolyline(xs: number[], ys: number[], x: number, y: number, toScreen: ToScreen, tol: number): boolean {\n  if (xs.length < 2) return false;\n  const [px, py] = toScreen(x, y);\n  let [ax, ay] = toScreen(xs[0], ys[0]);\n  for (let i = 1; i < xs.length; i++) {\n    const [bx, by] = toScreen(xs[i], ys[i]);\n    if (segmentDistance(px, py, ax, ay, bx, by) <= tol) return true;\n    ax = bx;\n    ay = by;\n  }\n  return false;\n}\n\n/** Index of the topmost (last) region containing (x, y), or -1. */\nexport function topmostRegionAt<R extends Pick<Region, 'bounds'>>(\n  regions: ReadonlyArray<R>,\n  x: number,\n  y: number,\n  opts: ContainsOptions & { skip?: (r: R) => boolean } = {},\n): number {\n  for (let i = regions.length - 1; i >= 0; i--) {\n    if (opts.skip?.(regions[i])) continue;\n    if (regionContains(regions[i], x, y, opts)) return i;\n  }\n  return -1;\n}\n\n/**\n * Indices of every region whose bounding box intersects the world box\n * [x0,y0]–[x1,y1] (rubber-band selection). `skipProfiles` leaves out\n * intensity-profile lines, `skip` any other region.\n */\nexport function regionsInRect(\n  regions: ReadonlyArray<Region>,\n  x0: number,\n  y0: number,\n  x1: number,\n  y1: number,\n  opts: { skipProfiles?: boolean; skip?: (r: Region) => boolean } = {},\n): number[] {\n  const out: number[] = [];\n  regions.forEach((r, i) => {\n    if ((opts.skipProfiles && r.isProfile?.()) || opts.skip?.(r)) return;\n    const bb = regionBBox(r);\n    if (bb && bb.x0 <= x1 && bb.x1 >= x0 && bb.y0 <= y1 && bb.y1 >= y0) out.push(i);\n  });\n  return out;\n}\n\n// ── SVG path data ────────────────────────────────────────────────────────\n\n/** The handle offsets a bézier ring is drawn with; absent arrays fall back to the default. */\nexport interface RingHandleOffsets {\n  in?: number[][];\n  out?: number[][];\n}\n\n/**\n * SVG path `d` for one ring or polyline, projected through `toScreen`.\n * Straight edges without `handles`; with `handles`, cubic segments through the\n * stored offsets, or the Catmull-Rom default when they are missing or do not\n * match the ring (via `resolveHandles`). Closed rings end in `Z`. '' for fewer\n * than two vertices.\n */\nexport function ringPathD(\n  xs: number[],\n  ys: number[],\n  closed: boolean,\n  toScreen: ToScreen,\n  handles?: RingHandleOffsets,\n): string {\n  const n = Math.min(xs.length, ys.length);\n  if (n < 2) return '';\n  const pt = (x: number, y: number) => {\n    const q = toScreen(x, y);\n    return `${q[0]},${q[1]}`;\n  };\n  let d = `M ${pt(xs[0], ys[0])}`;\n  if (handles) {\n    const h = resolveHandles(xs, ys, closed, handles.in, handles.out);\n    const segs = closed ? n : n - 1;\n    for (let i = 0; i < segs; i++) {\n      const j = (i + 1) % n;\n      d += ` C ${pt(h[i].out[0], h[i].out[1])} ${pt(h[j].in[0], h[j].in[1])} ${pt(xs[j], ys[j])}`;\n    }\n  } else {\n    for (let i = 1; i < n; i++) d += ` L ${pt(xs[i], ys[i])}`;\n  }\n  return closed ? d + ' Z' : d;\n}\n\n/**\n * SVG path `d` for a whole region: a rectangle's four corners; a polygon's\n * exterior (curved for a bézier region) followed by one subpath per hole\n * (curved too for a bézier donut); a multi-polygon's parts with their holes.\n * Holes need `fill-rule: evenodd` (see {@link regionHasHoles}).\n */\nexport function regionPathD(region: Pick<Region, 'bounds'>, toScreen: ToScreen = WORLD): string {\n  const b = region.bounds;\n  switch (boundsKind(b)) {\n    case 'rect': {\n      const r = b as Rectangle;\n      return ringPathD(\n        [r.x, r.x + r.width, r.x + r.width, r.x],\n        [r.y, r.y, r.y + r.height, r.y + r.height],\n        true,\n        toScreen,\n      );\n    }\n    case 'poly':\n      return polygonPathD(b as Polygon, toScreen, true);\n    case 'multi':\n      return (b as MultiPolygon).polygons\n        .filter((p) => (p.xpoints?.length ?? 0) >= 3)\n        .map((p) => polygonPathD(p, toScreen, false))\n        .join(' ');\n    default:\n      return '';\n  }\n}\n\nfunction polygonPathD(p: Polygon, toScreen: ToScreen, allowBezier: boolean): string {\n  const closed = p.closed !== false;\n  const bezier = allowBezier && !!p.bezier && (p.xpoints?.length ?? 0) >= 2;\n  let d = ringPathD(\n    p.xpoints ?? [],\n    p.ypoints ?? [],\n    closed,\n    toScreen,\n    bezier ? { in: p.handlesIn, out: p.handlesOut } : undefined,\n  );\n  if (!closed) return d;\n  (p.holes ?? []).forEach((ring, hi) => {\n    if (ring.length < 3) return;\n    const { xs, ys } = ringOf(p, hi);\n    d +=\n      ' ' +\n      ringPathD(\n        xs,\n        ys,\n        true,\n        toScreen,\n        bezier ? { in: p.holeHandlesIn?.[hi], out: p.holeHandlesOut?.[hi] } : undefined,\n      );\n  });\n  return d;\n}\n\n/** True when the region draws as several subpaths that need `fill-rule: evenodd`. */\nexport function regionHasHoles(region: Pick<Region, 'bounds'>): boolean {\n  const b = region.bounds;\n  const kind = boundsKind(b);\n  if (kind === 'multi') return true;\n  if (kind !== 'poly') return false;\n  const p = b as Polygon;\n  return p.closed !== false && !!p.holes?.length;\n}\n\n// ── handle hit testing (screen space) ────────────────────────────────────\n\n/** What a pointer grabbed on the selected region (see {@link hitHandle}). */\nexport type HandleHit =\n  /** A rectangle corner; `anchor` is the opposite (fixed) corner for a resize. */\n  | { kind: 'corner'; index: number; anchor: [number, number] }\n  /** A polygon vertex: `ring` -1 for the exterior, else the hole index. */\n  | { kind: 'vertex'; ring: number; index: number }\n  /** A bézier control point of vertex `index` on `ring`. */\n  | { kind: 'bezier'; ring: number; index: number; side: 'in' | 'out' };\n\n/**\n * The handle of `region` under screen point (sx, sy) within `radius` screen\n * pixels, or null. Rectangles have four corners. Polygons: every bézier\n * control point first (exterior, then each hole; they sit off the anchors, so\n * they must win), then the vertices (exterior, then each hole). Pass\n * `{ bezier: false }` to test vertices only.\n */\nexport function hitHandle(\n  region: Pick<Region, 'bounds'>,\n  sx: number,\n  sy: number,\n  toScreen: ToScreen,\n  radius: number,\n  opts: { bezier?: boolean } = {},\n): HandleHit | null {\n  const b = region.bounds;\n  const near = (x: number, y: number) => {\n    const q = toScreen(x, y);\n    return Math.hypot(sx - q[0], sy - q[1]) <= radius;\n  };\n  const kind = boundsKind(b);\n  if (kind === 'rect') {\n    const r = b as Rectangle;\n    const x0 = r.x,\n      y0 = r.y,\n      x1 = r.x + r.width,\n      y1 = r.y + r.height;\n    const corners: Array<[number, number, [number, number]]> = [\n      [x0, y0, [x1, y1]],\n      [x1, y0, [x0, y1]],\n      [x0, y1, [x1, y0]],\n      [x1, y1, [x0, y0]],\n    ];\n    for (let i = 0; i < corners.length; i++) {\n      if (near(corners[i][0], corners[i][1])) return { kind: 'corner', index: i, anchor: corners[i][2] };\n    }\n    return null;\n  }\n  if (kind !== 'poly') return null;\n  const p = b as Polygon;\n  const rings = ringIndices(p);\n  if (opts.bezier !== false && p.bezier) {\n    for (const ring of rings) {\n      const handles = ringHandles(p, ring);\n      for (let i = 0; i < handles.length; i++) {\n        const h = handles[i];\n        if (h.hasOut && near(h.out[0], h.out[1])) return { kind: 'bezier', ring, index: i, side: 'out' };\n        if (h.hasIn && near(h.in[0], h.in[1])) return { kind: 'bezier', ring, index: i, side: 'in' };\n      }\n    }\n  }\n  for (const ring of rings) {\n    const { xs, ys } = ringOf(p, ring);\n    for (let i = 0; i < xs.length; i++) {\n      if (near(xs[i], ys[i])) return { kind: 'vertex', ring, index: i };\n    }\n  }\n  return null;\n}\n\n/**\n * The polygon edge nearest screen point (sx, sy), across the exterior and every\n * hole: its ring (-1 = exterior), the index of its start vertex, and the\n * distance in screen pixels. Null when the region is not a polygon.\n */\nexport function nearestEdge(\n  region: Pick<Region, 'bounds'>,\n  sx: number,\n  sy: number,\n  toScreen: ToScreen,\n): { ring: number; segIndex: number; dist: number } | null {\n  const b = region.bounds;\n  if (boundsKind(b) !== 'poly') return null;\n  const p = b as Polygon;\n  let best: { ring: number; segIndex: number; dist: number } | null = null;\n  for (const ring of ringIndices(p)) {\n    const { xs, ys } = ringOf(p, ring);\n    const n = xs.length;\n    const segs = ring >= 0 || p.closed !== false ? n : n - 1;\n    for (let i = 0; i < segs; i++) {\n      const j = (i + 1) % n;\n      const a = toScreen(xs[i], ys[i]);\n      const c = toScreen(xs[j], ys[j]);\n      const dist = segmentDistance(sx, sy, a[0], a[1], c[0], c[1]);\n      if (!best || dist < best.dist) best = { ring, segIndex: i, dist };\n    }\n  }\n  return best;\n}\n\n/**\n * The polygon vertex nearest world point (x, y), across the exterior and every\n * hole, with its distance in world units. Null when the region is not a\n * polygon or has no vertices.\n */\nexport function nearestVertex(\n  region: Pick<Region, 'bounds'>,\n  x: number,\n  y: number,\n): { ring: number; index: number; dist: number } | null {\n  const b = region.bounds;\n  if (boundsKind(b) !== 'poly') return null;\n  const p = b as Polygon;\n  let best: { ring: number; index: number; dist: number } | null = null;\n  for (const ring of ringIndices(p)) {\n    const { xs, ys } = ringOf(p, ring);\n    for (let i = 0; i < xs.length; i++) {\n      const dist = Math.hypot(xs[i] - x, ys[i] - y);\n      if (!best || dist < best.dist) best = { ring, index: i, dist };\n    }\n  }\n  return best;\n}\n"]}

package/esm2022/lib/region-overlay/region-hit-test.mjs

@@ -0,0 +1,103 @@
+/**
+ * Screen-space hit testing for a selected rectangle's move/resize zones, and the
+ * resize those zones drive. Pure; shared by the SVG region overlays. (Vertex,
+ * bezier-handle and edge hits on polygons live in `region-geometry.ts`:
+ * `hitHandle` and `nearestEdge`.)
+ */
+/** The cursor that advertises each zone. */
+export const ZONE_CURSOR = {
+    move: 'move',
+    n: 'ns-resize',
+    s: 'ns-resize',
+    e: 'ew-resize',
+    w: 'ew-resize',
+    ne: 'nesw-resize',
+    sw: 'nesw-resize',
+    nw: 'nwse-resize',
+    se: 'nwse-resize',
+};
+/** Screen-pixel tolerance for grabbing an edge, corner or vertex handle. */
+export const EDIT_TOL_PX = 8;
+/**
+ * Classify a screen point against a screen-space rectangle: a corner, an edge
+ * (within `tolPx`), the body, or null when outside (beyond the tolerance).
+ */
+export function rectZone(px, py, box, tolPx = EDIT_TOL_PX) {
+    const { x0, y0, x1, y1 } = box;
+    const t = tolPx;
+    if (px < x0 - t || px > x1 + t || py < y0 - t || py > y1 + t)
+        return null;
+    const left = Math.abs(px - x0) <= t, right = Math.abs(px - x1) <= t;
+    const top = Math.abs(py - y0) <= t, bottom = Math.abs(py - y1) <= t;
+    if (top && left)
+        return 'nw';
+    if (top && right)
+        return 'ne';
+    if (bottom && left)
+        return 'sw';
+    if (bottom && right)
+        return 'se';
+    if (left)
+        return 'w';
+    if (right)
+        return 'e';
+    if (top)
+        return 'n';
+    if (bottom)
+        return 's';
+    if (px > x0 && px < x1 && py > y0 && py < y1)
+        return 'move';
+    return null;
+}
+/**
+ * The rectangle `orig` moved or resized through `zone` by the total drag
+ * (`dx`, `dy`), normalised (a drag past the opposite edge flips it) and rounded
+ * to whole pixels. Absolute from the gesture-start box, so applying it on every
+ * frame is idempotent.
+ */
+export function resizeRect(orig, zone, dx, dy) {
+    let x0 = orig.x, y0 = orig.y, x1 = orig.x + orig.width, y1 = orig.y + orig.height;
+    switch (zone) {
+        case 'move':
+            x0 += dx;
+            x1 += dx;
+            y0 += dy;
+            y1 += dy;
+            break;
+        case 'w':
+            x0 += dx;
+            break;
+        case 'e':
+            x1 += dx;
+            break;
+        case 'n':
+            y0 += dy;
+            break;
+        case 's':
+            y1 += dy;
+            break;
+        case 'nw':
+            x0 += dx;
+            y0 += dy;
+            break;
+        case 'ne':
+            x1 += dx;
+            y0 += dy;
+            break;
+        case 'sw':
+            x0 += dx;
+            y1 += dy;
+            break;
+        case 'se':
+            x1 += dx;
+            y1 += dy;
+            break;
+    }
+    return {
+        x: Math.round(Math.min(x0, x1)),
+        y: Math.round(Math.min(y0, y1)),
+        width: Math.round(Math.abs(x1 - x0)),
+        height: Math.round(Math.abs(y1 - y0)),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-hit-test.js","sourceRoot":"","sources":["../../../../src/lib/region-overlay/region-hit-test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,4CAA4C;AAC5C,MAAM,CAAC,MAAM,WAAW,GAAuC;IAC7D,IAAI,EAAE,MAAM;IACZ,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,WAAW;IACd,CAAC,EAAE,WAAW;IACd,EAAE,EAAE,aAAa;IACjB,EAAE,EAAE,aAAa;IACjB,EAAE,EAAE,aAAa;IACjB,EAAE,EAAE,aAAa;CAClB,CAAC;AAEF,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC;AAU7B;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAU,EAAE,EAAU,EAAE,GAAc,EAAE,KAAK,GAAG,WAAW;IAClF,MAAM,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,GAAG,CAAC;IAC/B,MAAM,CAAC,GAAG,KAAK,CAAC;IAChB,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC1E,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EACjC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAChC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,GAAG,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IAC7B,IAAI,GAAG,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IAC9B,IAAI,MAAM,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,IAAI,IAAI;QAAE,OAAO,GAAG,CAAC;IACrB,IAAI,KAAK;QAAE,OAAO,GAAG,CAAC;IACtB,IAAI,GAAG;QAAE,OAAO,GAAG,CAAC;IACpB,IAAI,MAAM;QAAE,OAAO,GAAG,CAAC;IACvB,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE;QAAE,OAAO,MAAM,CAAC;IAC5D,OAAO,IAAI,CAAC;AACd,CAAC;AAUD;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,IAAa,EAAE,IAAc,EAAE,EAAU,EAAE,EAAU;IAC9E,IAAI,EAAE,GAAG,IAAI,CAAC,CAAC,EACb,EAAE,GAAG,IAAI,CAAC,CAAC,EACX,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,EACxB,EAAE,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;IAC5B,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,MAAM;YACT,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,GAAG;YACN,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,GAAG;YACN,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,GAAG;YACN,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,GAAG;YACN,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,IAAI;YACP,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,IAAI;YACP,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,IAAI;YACP,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;QACR,KAAK,IAAI;YACP,EAAE,IAAI,EAAE,CAAC;YACT,EAAE,IAAI,EAAE,CAAC;YACT,MAAM;IACV,CAAC;IACD,OAAO;QACL,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC/B,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QAC/B,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;QACpC,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;KACtC,CAAC;AACJ,CAAC","sourcesContent":["/**\n * Screen-space hit testing for a selected rectangle's move/resize zones, and the\n * resize those zones drive. Pure; shared by the SVG region overlays. (Vertex,\n * bezier-handle and edge hits on polygons live in `region-geometry.ts`:\n * `hitHandle` and `nearestEdge`.)\n */\n\n/** Move/resize zones on the selected rectangle. */\nexport type EditZone = 'move' | 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';\n\n/** The cursor that advertises each zone. */\nexport const ZONE_CURSOR: Readonly<Record<EditZone, string>> = {\n  move: 'move',\n  n: 'ns-resize',\n  s: 'ns-resize',\n  e: 'ew-resize',\n  w: 'ew-resize',\n  ne: 'nesw-resize',\n  sw: 'nesw-resize',\n  nw: 'nwse-resize',\n  se: 'nwse-resize',\n};\n\n/** Screen-pixel tolerance for grabbing an edge, corner or vertex handle. */\nexport const EDIT_TOL_PX = 8;\n\n/** A screen-space box: left, top, right, bottom. */\nexport interface ScreenBox {\n  x0: number;\n  y0: number;\n  x1: number;\n  y1: number;\n}\n\n/**\n * Classify a screen point against a screen-space rectangle: a corner, an edge\n * (within `tolPx`), the body, or null when outside (beyond the tolerance).\n */\nexport function rectZone(px: number, py: number, box: ScreenBox, tolPx = EDIT_TOL_PX): EditZone | null {\n  const { x0, y0, x1, y1 } = box;\n  const t = tolPx;\n  if (px < x0 - t || px > x1 + t || py < y0 - t || py > y1 + t) return null;\n  const left = Math.abs(px - x0) <= t,\n    right = Math.abs(px - x1) <= t;\n  const top = Math.abs(py - y0) <= t,\n    bottom = Math.abs(py - y1) <= t;\n  if (top && left) return 'nw';\n  if (top && right) return 'ne';\n  if (bottom && left) return 'sw';\n  if (bottom && right) return 'se';\n  if (left) return 'w';\n  if (right) return 'e';\n  if (top) return 'n';\n  if (bottom) return 's';\n  if (px > x0 && px < x1 && py > y0 && py < y1) return 'move';\n  return null;\n}\n\n/** An image-space rectangle. */\nexport interface RectBox {\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/**\n * The rectangle `orig` moved or resized through `zone` by the total drag\n * (`dx`, `dy`), normalised (a drag past the opposite edge flips it) and rounded\n * to whole pixels. Absolute from the gesture-start box, so applying it on every\n * frame is idempotent.\n */\nexport function resizeRect(orig: RectBox, zone: EditZone, dx: number, dy: number): RectBox {\n  let x0 = orig.x,\n    y0 = orig.y,\n    x1 = orig.x + orig.width,\n    y1 = orig.y + orig.height;\n  switch (zone) {\n    case 'move':\n      x0 += dx;\n      x1 += dx;\n      y0 += dy;\n      y1 += dy;\n      break;\n    case 'w':\n      x0 += dx;\n      break;\n    case 'e':\n      x1 += dx;\n      break;\n    case 'n':\n      y0 += dy;\n      break;\n    case 's':\n      y1 += dy;\n      break;\n    case 'nw':\n      x0 += dx;\n      y0 += dy;\n      break;\n    case 'ne':\n      x1 += dx;\n      y0 += dy;\n      break;\n    case 'sw':\n      x0 += dx;\n      y1 += dy;\n      break;\n    case 'se':\n      x1 += dx;\n      y1 += dy;\n      break;\n  }\n  return {\n    x: Math.round(Math.min(x0, x1)),\n    y: Math.round(Math.min(y0, y1)),\n    width: Math.round(Math.abs(x1 - x0)),\n    height: Math.round(Math.abs(y1 - y0)),\n  };\n}\n"]}