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

package/esm2022/lib/models/polygon-edit.mjs

@@ -0,0 +1,254 @@
+/**
+ * Copy-on-write polygon edits (review RT-13, RegionStore split "polygon-edit").
+ *
+ * Every function takes a polygon and returns a NEW {@link Polygon} with the
+ * edit applied — or null when the edit does not apply (an index out of range,
+ * a vertex delete that would degenerate the ring, …), so a caller can skip its
+ * undo step. The input is never mutated: arrays the edit does not touch are
+ * shared with it (structural sharing), arrays it does touch are copied. That
+ * is what lets `RegionStore` keep shallow undo snapshots instead of deep
+ * clones: an instance in a snapshot is never changed after the fact.
+ *
+ * Pure: no DOM, no store. Coordinates are image pixels; bézier handle offsets
+ * are relative to their anchor, as on {@link Polygon}.
+ */
+import { MultiPolygon, Polygon, Rectangle } from './region';
+import { defaultHandleOffsets } from './bezier';
+/** A shallow copy of `p` with `patch` applied (untouched arrays are shared). */
+function withPolygon(p, patch) {
+    return Object.assign(new Polygon(), p, patch);
+}
+/** `xs` with `value` inserted at `at`. */
+function inserted(xs, at, value) {
+    return [...xs.slice(0, at), value, ...xs.slice(at)];
+}
+/** `xs` without the element at `at`. */
+function removed(xs, at) {
+    return [...xs.slice(0, at), ...xs.slice(at + 1)];
+}
+/** `xs` with the element at `at` replaced. */
+function replaced(xs, at, value) {
+    const out = xs.slice();
+    out[at] = value;
+    return out;
+}
+function coordinatesOf(xs, ys) {
+    return xs.map((x, i) => [x, ys[i]]);
+}
+// ── exterior vertices ───────────────────────────────────────────────────
+/** Move exterior vertex `index` to (x, y). Null when `index` is out of range. */
+export function moveVertex(p, index, x, y) {
+    if (index < 0 || index >= p.xpoints.length)
+        return null;
+    return withPolygon(p, {
+        xpoints: replaced(p.xpoints, index, x),
+        ypoints: replaced(p.ypoints, index, y),
+        coordinates: replaced(p.coordinates, index, [x, y]),
+    });
+}
+/**
+ * Insert a vertex at (x, y) after `segIndex` (the start vertex of the edge),
+ * clamped to the ring. A bézier polygon with stored handles gives the new
+ * vertex smooth handles from its neighbours and keeps the others' (possibly
+ * hand-edited) handles.
+ */
+export function addVertex(p, segIndex, x, y) {
+    const at = Math.max(0, Math.min(segIndex + 1, p.xpoints.length));
+    const xpoints = inserted(p.xpoints, at, x);
+    const ypoints = inserted(p.ypoints, at, y);
+    const patch = {
+        xpoints,
+        ypoints,
+        coordinates: coordinatesOf(xpoints, ypoints),
+        npoints: xpoints.length,
+    };
+    if (p.bezier && p.handlesIn && p.handlesOut) {
+        const n = xpoints.length;
+        const closed = p.closed !== false;
+        const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);
+        const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);
+        const tx = (xpoints[next] - xpoints[prev]) / 6;
+        const ty = (ypoints[next] - ypoints[prev]) / 6;
+        patch.handlesIn = inserted(p.handlesIn, at, [-tx, -ty]);
+        patch.handlesOut = inserted(p.handlesOut, at, [tx, ty]);
+    }
+    return withPolygon(p, patch);
+}
+/**
+ * Delete exterior vertex `index`. Null when out of range, or when it would
+ * leave fewer than 3 vertices (2 for an open polyline).
+ */
+export function deleteVertex(p, index) {
+    if (index < 0 || index >= p.xpoints.length)
+        return null;
+    const min = p.closed === false ? 2 : 3;
+    if (p.xpoints.length <= min)
+        return null;
+    const xpoints = removed(p.xpoints, index);
+    const ypoints = removed(p.ypoints, index);
+    const patch = {
+        xpoints,
+        ypoints,
+        coordinates: coordinatesOf(xpoints, ypoints),
+        npoints: xpoints.length,
+    };
+    if (p.bezier && p.handlesIn && p.handlesOut) {
+        patch.handlesIn = removed(p.handlesIn, index);
+        patch.handlesOut = removed(p.handlesOut, index);
+    }
+    return withPolygon(p, patch);
+}
+// ── hole (interior ring) vertices — jit-ui#85 ───────────────────────────
+function hasHole(p, holeIndex) {
+    return !!p.holes && holeIndex >= 0 && holeIndex < p.holes.length;
+}
+/** Move vertex `index` of hole `holeIndex` to (x, y). Null when either is out of range. */
+export function moveHoleVertex(p, holeIndex, index, x, y) {
+    if (!hasHole(p, holeIndex))
+        return null;
+    const ring = p.holes[holeIndex];
+    if (index < 0 || index >= ring.length)
+        return null;
+    return withPolygon(p, { holes: replaced(p.holes, holeIndex, replaced(ring, index, [x, y])) });
+}
+/**
+ * Insert a vertex at (x, y) on hole `holeIndex`, after `segIndex`. A bézier
+ * polygon re-seeds its hole handles so they stay parallel to the rings. Null
+ * for an out-of-range hole.
+ */
+export function addHoleVertex(p, holeIndex, segIndex, x, y) {
+    if (!hasHole(p, holeIndex))
+        return null;
+    const ring = p.holes[holeIndex];
+    const at = Math.max(0, Math.min(segIndex + 1, ring.length));
+    const holes = replaced(p.holes, holeIndex, inserted(ring, at, [x, y]));
+    return withPolygon(p, { holes, ...(p.bezier ? seededHoleHandles(holes) : {}) });
+}
+/**
+ * Delete vertex `index` of hole `holeIndex`. Taking a ring below 3 vertices
+ * drops the whole hole (it would bound no area). Null when out of range.
+ */
+export function deleteHoleVertex(p, holeIndex, index) {
+    if (!hasHole(p, holeIndex))
+        return null;
+    const ring = p.holes[holeIndex];
+    if (index < 0 || index >= ring.length)
+        return null;
+    let holes = ring.length <= 3 ? removed(p.holes, holeIndex) : replaced(p.holes, holeIndex, removed(ring, index));
+    if (holes.length === 0)
+        holes = undefined;
+    return withPolygon(p, { holes, ...(p.bezier ? seededHoleHandles(holes) : {}) });
+}
+// ── bézier ──────────────────────────────────────────────────────────────
+/**
+ * Per-hole bézier handles seeded from the Catmull-Rom default, parallel to
+ * `holes` (both undefined without holes).
+ */
+export function seededHoleHandles(holes) {
+    if (!holes || !holes.length)
+        return { holeHandlesIn: undefined, holeHandlesOut: undefined };
+    const ins = [];
+    const outs = [];
+    for (const ring of holes) {
+        const off = defaultHandleOffsets(ring.map((q) => q[0]), ring.map((q) => q[1]), true);
+        ins.push(off.in);
+        outs.push(off.out);
+    }
+    return { holeHandlesIn: ins, holeHandlesOut: outs };
+}
+/**
+ * Turn bézier on — seeding editable handles (holes included) from the smooth
+ * default — or off, dropping every handle. The anchors never move. Null when
+ * the polygon is already in that state.
+ */
+export function setBezier(p, bezier) {
+    if (p.bezier === bezier)
+        return null;
+    if (!bezier) {
+        return withPolygon(p, {
+            bezier: false,
+            handlesIn: undefined,
+            handlesOut: undefined,
+            holeHandlesIn: undefined,
+            holeHandlesOut: undefined,
+        });
+    }
+    const off = defaultHandleOffsets(p.xpoints, p.ypoints, p.closed !== false);
+    return withPolygon(p, { bezier: true, handlesIn: off.in, handlesOut: off.out, ...seededHoleHandles(p.holes) });
+}
+/**
+ * Move the `side` control point of exterior vertex `index` to the absolute
+ * point (x, y). Handles missing from a bézier polygon are seeded from the
+ * default first. Null for a non-bézier polygon or an out-of-range index.
+ */
+export function moveBezierHandle(p, index, side, x, y) {
+    if (!p.bezier || index < 0 || index >= p.xpoints.length)
+        return null;
+    let handlesIn = p.handlesIn, handlesOut = p.handlesOut;
+    if (!handlesIn || !handlesOut) {
+        const off = defaultHandleOffsets(p.xpoints, p.ypoints, p.closed !== false);
+        handlesIn = off.in;
+        handlesOut = off.out;
+    }
+    const offset = [x - p.xpoints[index], y - p.ypoints[index]];
+    return side === 'in'
+        ? withPolygon(p, { handlesIn: replaced(handlesIn, index, offset), handlesOut })
+        : withPolygon(p, { handlesIn, handlesOut: replaced(handlesOut, index, offset) });
+}
+/**
+ * Move the `side` control point of vertex `index` on hole `holeIndex` to the
+ * absolute point (x, y), seeding the hole handles first when missing. Null for
+ * a non-bézier polygon or an out-of-range hole/index.
+ */
+export function moveHoleBezierHandle(p, holeIndex, index, side, x, y) {
+    if (!p.bezier || !hasHole(p, holeIndex))
+        return null;
+    const ring = p.holes[holeIndex];
+    if (index < 0 || index >= ring.length)
+        return null;
+    let ins = p.holeHandlesIn, outs = p.holeHandlesOut;
+    if (!ins || !outs) {
+        const seeded = seededHoleHandles(p.holes);
+        ins = seeded.holeHandlesIn;
+        outs = seeded.holeHandlesOut;
+    }
+    const offset = [x - ring[index][0], y - ring[index][1]];
+    return side === 'in'
+        ? withPolygon(p, {
+            holeHandlesIn: replaced(ins, holeIndex, replaced(ins[holeIndex], index, offset)),
+            holeHandlesOut: outs,
+        })
+        : withPolygon(p, {
+            holeHandlesIn: ins,
+            holeHandlesOut: replaced(outs, holeIndex, replaced(outs[holeIndex], index, offset)),
+        });
+}
+// ── translation ─────────────────────────────────────────────────────────
+/**
+ * A polygon moved by (dx, dy): its vertices and holes (bézier offsets are
+ * relative, so they carry over). `round` snaps the moved coordinates.
+ */
+export function translatePolygon(p, dx, dy, round) {
+    const f = round ?? ((v) => v);
+    const xpoints = p.xpoints.map((x) => f(x + dx));
+    const ypoints = p.ypoints.map((y) => f(y + dy));
+    return withPolygon(p, {
+        xpoints,
+        ypoints,
+        coordinates: coordinatesOf(xpoints, ypoints),
+        holes: p.holes?.map((ring) => ring.map(([x, y]) => [f(x + dx), f(y + dy)])),
+    });
+}
+/** Any region geometry moved by (dx, dy) (see {@link translatePolygon}). */
+export function translateBounds(b, dx, dy, round) {
+    const f = round ?? ((v) => v);
+    if (b instanceof Rectangle) {
+        return Object.assign(new Rectangle(), b, { x: f(b.x + dx), y: f(b.y + dy) });
+    }
+    if (b instanceof MultiPolygon) {
+        const polygons = b.polygons.map((p) => translatePolygon(p, dx, dy, round));
+        return Object.assign(new MultiPolygon(), { polygons });
+    }
+    return translatePolygon(b, dx, dy, round);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polygon-edit.js","sourceRoot":"","sources":["../../../../src/lib/models/polygon-edit.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copy-on-write polygon edits (review RT-13, RegionStore split \"polygon-edit\").\n *\n * Every function takes a polygon and returns a NEW {@link Polygon} with the\n * edit applied — or null when the edit does not apply (an index out of range,\n * a vertex delete that would degenerate the ring, …), so a caller can skip its\n * undo step. The input is never mutated: arrays the edit does not touch are\n * shared with it (structural sharing), arrays it does touch are copied. That\n * is what lets `RegionStore` keep shallow undo snapshots instead of deep\n * clones: an instance in a snapshot is never changed after the fact.\n *\n * Pure: no DOM, no store. Coordinates are image pixels; bézier handle offsets\n * are relative to their anchor, as on {@link Polygon}.\n */\nimport { MultiPolygon, Polygon, Rectangle } from './region';\nimport { defaultHandleOffsets } from './bezier';\n\n/** A shallow copy of `p` with `patch` applied (untouched arrays are shared). */\nfunction withPolygon(p: Polygon, patch: Partial<Polygon>): Polygon {\n  return Object.assign(new Polygon(), p, patch);\n}\n\n/** `xs` with `value` inserted at `at`. */\nfunction inserted<T>(xs: readonly T[], at: number, value: T): T[] {\n  return [...xs.slice(0, at), value, ...xs.slice(at)];\n}\n\n/** `xs` without the element at `at`. */\nfunction removed<T>(xs: readonly T[], at: number): T[] {\n  return [...xs.slice(0, at), ...xs.slice(at + 1)];\n}\n\n/** `xs` with the element at `at` replaced. */\nfunction replaced<T>(xs: readonly T[], at: number, value: T): T[] {\n  const out = xs.slice();\n  out[at] = value;\n  return out;\n}\n\nfunction coordinatesOf(xs: number[], ys: number[]): number[][] {\n  return xs.map((x, i) => [x, ys[i]]);\n}\n\n// ── exterior vertices ───────────────────────────────────────────────────\n\n/** Move exterior vertex `index` to (x, y). Null when `index` is out of range. */\nexport function moveVertex(p: Polygon, index: number, x: number, y: number): Polygon | null {\n  if (index < 0 || index >= p.xpoints.length) return null;\n  return withPolygon(p, {\n    xpoints: replaced(p.xpoints, index, x),\n    ypoints: replaced(p.ypoints, index, y),\n    coordinates: replaced(p.coordinates, index, [x, y]),\n  });\n}\n\n/**\n * Insert a vertex at (x, y) after `segIndex` (the start vertex of the edge),\n * clamped to the ring. A bézier polygon with stored handles gives the new\n * vertex smooth handles from its neighbours and keeps the others' (possibly\n * hand-edited) handles.\n */\nexport function addVertex(p: Polygon, segIndex: number, x: number, y: number): Polygon {\n  const at = Math.max(0, Math.min(segIndex + 1, p.xpoints.length));\n  const xpoints = inserted(p.xpoints, at, x);\n  const ypoints = inserted(p.ypoints, at, y);\n  const patch: Partial<Polygon> = {\n    xpoints,\n    ypoints,\n    coordinates: coordinatesOf(xpoints, ypoints),\n    npoints: xpoints.length,\n  };\n  if (p.bezier && p.handlesIn && p.handlesOut) {\n    const n = xpoints.length;\n    const closed = p.closed !== false;\n    const prev = closed ? (at - 1 + n) % n : Math.max(0, at - 1);\n    const next = closed ? (at + 1) % n : Math.min(n - 1, at + 1);\n    const tx = (xpoints[next] - xpoints[prev]) / 6;\n    const ty = (ypoints[next] - ypoints[prev]) / 6;\n    patch.handlesIn = inserted(p.handlesIn, at, [-tx, -ty]);\n    patch.handlesOut = inserted(p.handlesOut, at, [tx, ty]);\n  }\n  return withPolygon(p, patch);\n}\n\n/**\n * Delete exterior vertex `index`. Null when out of range, or when it would\n * leave fewer than 3 vertices (2 for an open polyline).\n */\nexport function deleteVertex(p: Polygon, index: number): Polygon | null {\n  if (index < 0 || index >= p.xpoints.length) return null;\n  const min = p.closed === false ? 2 : 3;\n  if (p.xpoints.length <= min) return null;\n  const xpoints = removed(p.xpoints, index);\n  const ypoints = removed(p.ypoints, index);\n  const patch: Partial<Polygon> = {\n    xpoints,\n    ypoints,\n    coordinates: coordinatesOf(xpoints, ypoints),\n    npoints: xpoints.length,\n  };\n  if (p.bezier && p.handlesIn && p.handlesOut) {\n    patch.handlesIn = removed(p.handlesIn, index);\n    patch.handlesOut = removed(p.handlesOut, index);\n  }\n  return withPolygon(p, patch);\n}\n\n// ── hole (interior ring) vertices — jit-ui#85 ───────────────────────────\n\nfunction hasHole(p: Polygon, holeIndex: number): boolean {\n  return !!p.holes && holeIndex >= 0 && holeIndex < p.holes.length;\n}\n\n/** Move vertex `index` of hole `holeIndex` to (x, y). Null when either is out of range. */\nexport function moveHoleVertex(\n  p: Polygon,\n  holeIndex: number,\n  index: number,\n  x: number,\n  y: number,\n): Polygon | null {\n  if (!hasHole(p, holeIndex)) return null;\n  const ring = p.holes![holeIndex];\n  if (index < 0 || index >= ring.length) return null;\n  return withPolygon(p, { holes: replaced(p.holes!, holeIndex, replaced(ring, index, [x, y])) });\n}\n\n/**\n * Insert a vertex at (x, y) on hole `holeIndex`, after `segIndex`. A bézier\n * polygon re-seeds its hole handles so they stay parallel to the rings. Null\n * for an out-of-range hole.\n */\nexport function addHoleVertex(\n  p: Polygon,\n  holeIndex: number,\n  segIndex: number,\n  x: number,\n  y: number,\n): Polygon | null {\n  if (!hasHole(p, holeIndex)) return null;\n  const ring = p.holes![holeIndex];\n  const at = Math.max(0, Math.min(segIndex + 1, ring.length));\n  const holes = replaced(p.holes!, holeIndex, inserted(ring, at, [x, y]));\n  return withPolygon(p, { holes, ...(p.bezier ? seededHoleHandles(holes) : {}) });\n}\n\n/**\n * Delete vertex `index` of hole `holeIndex`. Taking a ring below 3 vertices\n * drops the whole hole (it would bound no area). Null when out of range.\n */\nexport function deleteHoleVertex(p: Polygon, holeIndex: number, index: number): Polygon | null {\n  if (!hasHole(p, holeIndex)) return null;\n  const ring = p.holes![holeIndex];\n  if (index < 0 || index >= ring.length) return null;\n  let holes: number[][][] | undefined =\n    ring.length <= 3 ? removed(p.holes!, holeIndex) : replaced(p.holes!, holeIndex, removed(ring, index));\n  if (holes.length === 0) holes = undefined;\n  return withPolygon(p, { holes, ...(p.bezier ? seededHoleHandles(holes) : {}) });\n}\n\n// ── bézier ──────────────────────────────────────────────────────────────\n\n/**\n * Per-hole bézier handles seeded from the Catmull-Rom default, parallel to\n * `holes` (both undefined without holes).\n */\nexport function seededHoleHandles(\n  holes: number[][][] | undefined,\n): Pick<Polygon, 'holeHandlesIn' | 'holeHandlesOut'> {\n  if (!holes || !holes.length) return { holeHandlesIn: undefined, holeHandlesOut: undefined };\n  const ins: number[][][] = [];\n  const outs: number[][][] = [];\n  for (const ring of holes) {\n    const off = defaultHandleOffsets(\n      ring.map((q) => q[0]),\n      ring.map((q) => q[1]),\n      true,\n    );\n    ins.push(off.in);\n    outs.push(off.out);\n  }\n  return { holeHandlesIn: ins, holeHandlesOut: outs };\n}\n\n/**\n * Turn bézier on — seeding editable handles (holes included) from the smooth\n * default — or off, dropping every handle. The anchors never move. Null when\n * the polygon is already in that state.\n */\nexport function setBezier(p: Polygon, bezier: boolean): Polygon | null {\n  if (p.bezier === bezier) return null;\n  if (!bezier) {\n    return withPolygon(p, {\n      bezier: false,\n      handlesIn: undefined,\n      handlesOut: undefined,\n      holeHandlesIn: undefined,\n      holeHandlesOut: undefined,\n    });\n  }\n  const off = defaultHandleOffsets(p.xpoints, p.ypoints, p.closed !== false);\n  return withPolygon(p, { bezier: true, handlesIn: off.in, handlesOut: off.out, ...seededHoleHandles(p.holes) });\n}\n\n/**\n * Move the `side` control point of exterior vertex `index` to the absolute\n * point (x, y). Handles missing from a bézier polygon are seeded from the\n * default first. Null for a non-bézier polygon or an out-of-range index.\n */\nexport function moveBezierHandle(\n  p: Polygon,\n  index: number,\n  side: 'in' | 'out',\n  x: number,\n  y: number,\n): Polygon | null {\n  if (!p.bezier || index < 0 || index >= p.xpoints.length) return null;\n  let handlesIn = p.handlesIn,\n    handlesOut = p.handlesOut;\n  if (!handlesIn || !handlesOut) {\n    const off = defaultHandleOffsets(p.xpoints, p.ypoints, p.closed !== false);\n    handlesIn = off.in;\n    handlesOut = off.out;\n  }\n  const offset = [x - p.xpoints[index], y - p.ypoints[index]];\n  return side === 'in'\n    ? withPolygon(p, { handlesIn: replaced(handlesIn, index, offset), handlesOut })\n    : withPolygon(p, { handlesIn, handlesOut: replaced(handlesOut, index, offset) });\n}\n\n/**\n * Move the `side` control point of vertex `index` on hole `holeIndex` to the\n * absolute point (x, y), seeding the hole handles first when missing. Null for\n * a non-bézier polygon or an out-of-range hole/index.\n */\nexport function moveHoleBezierHandle(\n  p: Polygon,\n  holeIndex: number,\n  index: number,\n  side: 'in' | 'out',\n  x: number,\n  y: number,\n): Polygon | null {\n  if (!p.bezier || !hasHole(p, holeIndex)) return null;\n  const ring = p.holes![holeIndex];\n  if (index < 0 || index >= ring.length) return null;\n  let ins = p.holeHandlesIn,\n    outs = p.holeHandlesOut;\n  if (!ins || !outs) {\n    const seeded = seededHoleHandles(p.holes);\n    ins = seeded.holeHandlesIn!;\n    outs = seeded.holeHandlesOut!;\n  }\n  const offset = [x - ring[index][0], y - ring[index][1]];\n  return side === 'in'\n    ? withPolygon(p, {\n        holeHandlesIn: replaced(ins, holeIndex, replaced(ins[holeIndex], index, offset)),\n        holeHandlesOut: outs,\n      })\n    : withPolygon(p, {\n        holeHandlesIn: ins,\n        holeHandlesOut: replaced(outs, holeIndex, replaced(outs[holeIndex], index, offset)),\n      });\n}\n\n// ── translation ─────────────────────────────────────────────────────────\n\n/**\n * A polygon moved by (dx, dy): its vertices and holes (bézier offsets are\n * relative, so they carry over). `round` snaps the moved coordinates.\n */\nexport function translatePolygon(p: Polygon, dx: number, dy: number, round?: (v: number) => number): Polygon {\n  const f = round ?? ((v: number) => v);\n  const xpoints = p.xpoints.map((x) => f(x + dx));\n  const ypoints = p.ypoints.map((y) => f(y + dy));\n  return withPolygon(p, {\n    xpoints,\n    ypoints,\n    coordinates: coordinatesOf(xpoints, ypoints),\n    holes: p.holes?.map((ring) => ring.map(([x, y]) => [f(x + dx), f(y + dy)])),\n  });\n}\n\n/** Any region geometry moved by (dx, dy) (see {@link translatePolygon}). */\nexport function translateBounds(\n  b: Rectangle | Polygon | MultiPolygon,\n  dx: number,\n  dy: number,\n  round?: (v: number) => number,\n): Rectangle | Polygon | MultiPolygon {\n  const f = round ?? ((v: number) => v);\n  if (b instanceof Rectangle) {\n    return Object.assign(new Rectangle(), b, { x: f(b.x + dx), y: f(b.y + dy) });\n  }\n  if (b instanceof MultiPolygon) {\n    const polygons = b.polygons.map((p) => translatePolygon(p, dx, dy, round));\n    return Object.assign(new MultiPolygon(), { polygons });\n  }\n  return translatePolygon(b, dx, dy, round);\n}\n"]}

package/esm2022/lib/models/polygon-factory.mjs

@@ -0,0 +1,134 @@
+import { MultiPolygon, Polygon, Rectangle, Region } from './region';
+import { bezierCurveFromHandles, resolveHandles } from './bezier';
+/** A Polygon over the given vertex arrays (taken by reference). */
+export function makePolygon(xs, ys, opts = {}) {
+    const poly = new Polygon();
+    poly.npoints = xs.length;
+    poly.xpoints = xs;
+    poly.ypoints = ys;
+    poly.coordinates = xs.map((x, i) => [x, ys[i]]);
+    poly.closed = opts.closed ?? true;
+    if (opts.bezier)
+        poly.bezier = true;
+    if (opts.holes && opts.holes.length)
+        poly.holes = opts.holes;
+    return poly;
+}
+/** The four corners of a rectangle as a closed ring (clockwise from top-left). */
+export function rectToRing(r) {
+    return {
+        xs: [r.x, r.x + r.width, r.x + r.width, r.x],
+        ys: [r.y, r.y, r.y + r.height, r.y + r.height],
+    };
+}
+/** A deep copy of a polygon: vertices, holes and every bézier handle. */
+export function clonePolygon(p) {
+    const poly = new Polygon();
+    poly.npoints = p.npoints;
+    poly.xpoints = p.xpoints.slice();
+    poly.ypoints = p.ypoints.slice();
+    poly.coordinates = p.coordinates.map((c) => c.slice());
+    poly.closed = p.closed;
+    poly.bezier = p.bezier;
+    if (p.handlesIn)
+        poly.handlesIn = p.handlesIn.map((o) => o.slice());
+    if (p.handlesOut)
+        poly.handlesOut = p.handlesOut.map((o) => o.slice());
+    if (p.holes)
+        poly.holes = p.holes.map((ring) => ring.map((pt) => pt.slice()));
+    if (p.holeHandlesIn)
+        poly.holeHandlesIn = p.holeHandlesIn.map((r) => r.map((o) => o.slice()));
+    if (p.holeHandlesOut)
+        poly.holeHandlesOut = p.holeHandlesOut.map((r) => r.map((o) => o.slice()));
+    return poly;
+}
+/** A deep copy of any region geometry. */
+export function cloneBounds(bounds) {
+    if (bounds instanceof Rectangle) {
+        const rect = new Rectangle();
+        rect.x = bounds.x;
+        rect.y = bounds.y;
+        rect.width = bounds.width;
+        rect.height = bounds.height;
+        return rect;
+    }
+    if (bounds instanceof MultiPolygon) {
+        const mp = new MultiPolygon();
+        mp.polygons = bounds.polygons.map((p) => clonePolygon(p));
+        return mp;
+    }
+    return clonePolygon(bounds);
+}
+/**
+ * A copy of `existing` (id, name, label, colour, colour override, source,
+ * file name, kind, z, …) with new geometry and optional extra fields. Use it
+ * whenever a tool edits a region's shape, so the edit never drops metadata and
+ * never mutates the store's instance.
+ */
+export function replaceBounds(existing, bounds, patch = {}) {
+    return Object.assign(new Region(), existing, patch, { bounds });
+}
+/** A closed ring rounded to whole pixels, as image-processing consumers expect. */
+function roundedPolygon(xs, ys, holes) {
+    return makePolygon(xs.map(Math.round), ys.map(Math.round), {
+        holes: holes?.map((ring) => ring.map(([x, y]) => [Math.round(x), Math.round(y)])),
+    });
+}
+/** A polygon's exterior and holes, with a bézier region flattened to its curve. */
+function flattenPolygon(p) {
+    if (!p.bezier)
+        return roundedPolygon(p.xpoints, p.ypoints, p.holes);
+    const closed = p.closed !== false;
+    const curve = bezierCurveFromHandles(p.xpoints, p.ypoints, resolveHandles(p.xpoints, p.ypoints, closed, p.handlesIn, p.handlesOut), closed);
+    const holes = p.holes?.map((ring, h) => {
+        const hx = ring.map((pt) => pt[0]);
+        const hy = ring.map((pt) => pt[1]);
+        const c = bezierCurveFromHandles(hx, hy, resolveHandles(hx, hy, true, p.holeHandlesIn?.[h], p.holeHandlesOut?.[h]), true);
+        return dropClosingPoint(c.xs, c.ys).xs.map((x, i) => [x, c.ys[i]]);
+    });
+    const ring = dropClosingPoint(curve.xs, curve.ys);
+    return roundedPolygon(ring.xs, ring.ys, holes);
+}
+/** A sampled closed curve repeats its first point at the end; rings don't. */
+function dropClosingPoint(xs, ys) {
+    const n = xs.length;
+    if (n > 1 && xs[0] === xs[n - 1] && ys[0] === ys[n - 1])
+        return { xs: xs.slice(0, -1), ys: ys.slice(0, -1) };
+    return { xs, ys };
+}
+/**
+ * The closed polygons a region covers, for image-processing consumers (crop,
+ * segmentation requests): a rectangle's four corners, a closed polygon with its
+ * holes (a bézier region as its flattened curve), one polygon per part of a
+ * multi-polygon. Open polylines cover no area and yield nothing. Coordinates
+ * are rounded to whole pixels.
+ */
+export function regionPolygons(region) {
+    const b = region.bounds;
+    if (b instanceof Rectangle) {
+        // Bottom-left first, as the previous Plotly-shape projection produced.
+        return [roundedPolygon([b.x, b.x + b.width, b.x + b.width, b.x], [b.y + b.height, b.y + b.height, b.y, b.y])];
+    }
+    if (b instanceof Polygon)
+        return b.closed === false ? [] : [flattenPolygon(b)];
+    if (b instanceof MultiPolygon)
+        return b.polygons.filter((p) => p.closed !== false).map(flattenPolygon);
+    return [];
+}
+/**
+ * The open polylines a region traces (a polyline, or a multi-polygon's open parts), as interleaved
+ * `x, y` image px; a bézier polyline as its flattened curve. Closed shapes yield nothing.
+ */
+export function regionPolylines(region) {
+    const b = region.bounds;
+    const parts = b instanceof Polygon ? [b] : b instanceof MultiPolygon ? b.polygons : [];
+    return parts
+        .filter((p) => p.closed === false && p.xpoints.length >= 2)
+        .map((p) => {
+        const { xs, ys } = p.bezier
+            ? bezierCurveFromHandles(p.xpoints, p.ypoints, resolveHandles(p.xpoints, p.ypoints, false, p.handlesIn, p.handlesOut), false)
+            : { xs: p.xpoints, ys: p.ypoints };
+        return Float64Array.from(xs.flatMap((x, i) => [x, ys[i]]));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polygon-factory.js","sourceRoot":"","sources":["../../../../src/lib/models/polygon-factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { MultiPolygon, Polygon, Rectangle, Region } from './region';\nimport { bezierCurveFromHandles, resolveHandles } from './bezier';\n\n/**\n * Polygon / Region construction and cloning in one place, so callers stop\n * hand-filling `npoints`, `xpoints`, `ypoints`, `coordinates` and `closed`\n * (three redundant views of one ring that every mutator must keep in sync).\n */\n\n/** Options for {@link makePolygon}. */\nexport interface MakePolygonOptions {\n  /** false for an open polyline; default true. */\n  closed?: boolean;\n  /** Interior rings; omitted when absent or empty. */\n  holes?: number[][][];\n  bezier?: boolean;\n}\n\n/** A Polygon over the given vertex arrays (taken by reference). */\nexport function makePolygon(xs: number[], ys: number[], opts: MakePolygonOptions = {}): Polygon {\n  const poly = new Polygon();\n  poly.npoints = xs.length;\n  poly.xpoints = xs;\n  poly.ypoints = ys;\n  poly.coordinates = xs.map((x, i) => [x, ys[i]]);\n  poly.closed = opts.closed ?? true;\n  if (opts.bezier) poly.bezier = true;\n  if (opts.holes && opts.holes.length) poly.holes = opts.holes;\n  return poly;\n}\n\n/** The four corners of a rectangle as a closed ring (clockwise from top-left). */\nexport function rectToRing(r: Pick<Rectangle, 'x' | 'y' | 'width' | 'height'>): { xs: number[]; ys: number[] } {\n  return {\n    xs: [r.x, r.x + r.width, r.x + r.width, r.x],\n    ys: [r.y, r.y, r.y + r.height, r.y + r.height],\n  };\n}\n\n/** A deep copy of a polygon: vertices, holes and every bézier handle. */\nexport function clonePolygon(p: Polygon): Polygon {\n  const poly = new Polygon();\n  poly.npoints = p.npoints;\n  poly.xpoints = p.xpoints.slice();\n  poly.ypoints = p.ypoints.slice();\n  poly.coordinates = p.coordinates.map((c) => c.slice());\n  poly.closed = p.closed;\n  poly.bezier = p.bezier;\n  if (p.handlesIn) poly.handlesIn = p.handlesIn.map((o) => o.slice());\n  if (p.handlesOut) poly.handlesOut = p.handlesOut.map((o) => o.slice());\n  if (p.holes) poly.holes = p.holes.map((ring) => ring.map((pt) => pt.slice()));\n  if (p.holeHandlesIn) poly.holeHandlesIn = p.holeHandlesIn.map((r) => r.map((o) => o.slice()));\n  if (p.holeHandlesOut) poly.holeHandlesOut = p.holeHandlesOut.map((r) => r.map((o) => o.slice()));\n  return poly;\n}\n\n/** A deep copy of any region geometry. */\nexport function cloneBounds(bounds: Rectangle | Polygon | MultiPolygon): Rectangle | Polygon | MultiPolygon {\n  if (bounds instanceof Rectangle) {\n    const rect = new Rectangle();\n    rect.x = bounds.x;\n    rect.y = bounds.y;\n    rect.width = bounds.width;\n    rect.height = bounds.height;\n    return rect;\n  }\n  if (bounds instanceof MultiPolygon) {\n    const mp = new MultiPolygon();\n    mp.polygons = bounds.polygons.map((p) => clonePolygon(p));\n    return mp;\n  }\n  return clonePolygon(bounds);\n}\n\n/**\n * A copy of `existing` (id, name, label, colour, colour override, source,\n * file name, kind, z, …) with new geometry and optional extra fields. Use it\n * whenever a tool edits a region's shape, so the edit never drops metadata and\n * never mutates the store's instance.\n */\nexport function replaceBounds(existing: Region, bounds: Region['bounds'], patch: Partial<Region> = {}): Region {\n  return Object.assign(new Region(), existing, patch, { bounds });\n}\n\n/** A closed ring rounded to whole pixels, as image-processing consumers expect. */\nfunction roundedPolygon(xs: number[], ys: number[], holes?: number[][][]): Polygon {\n  return makePolygon(xs.map(Math.round), ys.map(Math.round), {\n    holes: holes?.map((ring) => ring.map(([x, y]) => [Math.round(x), Math.round(y)])),\n  });\n}\n\n/** A polygon's exterior and holes, with a bézier region flattened to its curve. */\nfunction flattenPolygon(p: Polygon): Polygon {\n  if (!p.bezier) return roundedPolygon(p.xpoints, p.ypoints, p.holes);\n  const closed = p.closed !== false;\n  const curve = bezierCurveFromHandles(\n    p.xpoints,\n    p.ypoints,\n    resolveHandles(p.xpoints, p.ypoints, closed, p.handlesIn, p.handlesOut),\n    closed,\n  );\n  const holes = p.holes?.map((ring, h) => {\n    const hx = ring.map((pt) => pt[0]);\n    const hy = ring.map((pt) => pt[1]);\n    const c = bezierCurveFromHandles(\n      hx,\n      hy,\n      resolveHandles(hx, hy, true, p.holeHandlesIn?.[h], p.holeHandlesOut?.[h]),\n      true,\n    );\n    return dropClosingPoint(c.xs, c.ys).xs.map((x, i) => [x, c.ys[i]]);\n  });\n  const ring = dropClosingPoint(curve.xs, curve.ys);\n  return roundedPolygon(ring.xs, ring.ys, holes);\n}\n\n/** A sampled closed curve repeats its first point at the end; rings don't. */\nfunction dropClosingPoint(xs: number[], ys: number[]): { xs: number[]; ys: number[] } {\n  const n = xs.length;\n  if (n > 1 && xs[0] === xs[n - 1] && ys[0] === ys[n - 1]) return { xs: xs.slice(0, -1), ys: ys.slice(0, -1) };\n  return { xs, ys };\n}\n\n/**\n * The closed polygons a region covers, for image-processing consumers (crop,\n * segmentation requests): a rectangle's four corners, a closed polygon with its\n * holes (a bézier region as its flattened curve), one polygon per part of a\n * multi-polygon. Open polylines cover no area and yield nothing. Coordinates\n * are rounded to whole pixels.\n */\nexport function regionPolygons(region: Region): Polygon[] {\n  const b = region.bounds;\n  if (b instanceof Rectangle) {\n    // Bottom-left first, as the previous Plotly-shape projection produced.\n    return [roundedPolygon([b.x, b.x + b.width, b.x + b.width, b.x], [b.y + b.height, b.y + b.height, b.y, b.y])];\n  }\n  if (b instanceof Polygon) return b.closed === false ? [] : [flattenPolygon(b)];\n  if (b instanceof MultiPolygon) return b.polygons.filter((p) => p.closed !== false).map(flattenPolygon);\n  return [];\n}\n\n/**\n * The open polylines a region traces (a polyline, or a multi-polygon's open parts), as interleaved\n * `x, y` image px; a bézier polyline as its flattened curve. Closed shapes yield nothing.\n */\nexport function regionPolylines(region: Region): Float64Array[] {\n  const b = region.bounds;\n  const parts = b instanceof Polygon ? [b] : b instanceof MultiPolygon ? b.polygons : [];\n  return parts\n    .filter((p) => p.closed === false && p.xpoints.length >= 2)\n    .map((p) => {\n      const { xs, ys } = p.bezier\n        ? bezierCurveFromHandles(\n            p.xpoints,\n            p.ypoints,\n            resolveHandles(p.xpoints, p.ypoints, false, p.handlesIn, p.handlesOut),\n            false,\n          )\n        : { xs: p.xpoints, ys: p.ypoints };\n      return Float64Array.from(xs.flatMap((x, i) => [x, ys[i]]));\n    });\n}\n"]}

package/esm2022/lib/models/region-clone.mjs

@@ -0,0 +1,68 @@
+import { MultiPolygon, Polygon, Rectangle, Region } from './region';
+/**
+ * Copy-on-write region copies and geometry equality (RT-13). Stored regions
+ * are shared with the undo history, so a change is always a copy; these
+ * helpers return the input unchanged when the patch would not change it.
+ * (Deep geometry copies are `cloneBounds` / `clonePolygon` in `polygon-factory`.)
+ */
+/** A shallow copy of `r` with `patch` applied; `r` itself is never changed. */
+export function withRegionPatch(r, patch) {
+    return Object.assign(new Region(), r, patch);
+}
+/** `r` tagged with slice `z`: itself when it already is, else a copy. */
+export function withRegionZ(r, z) {
+    return r.z === z ? r : withRegionPatch(r, { z });
+}
+/**
+ * True when two regions have the same geometry: equal rectangles, or polygons
+ * (each part of a multi-polygon, in order) with the same vertices, open/closed
+ * state and holes. Bézier handles, labels and colours are not compared. Mixed
+ * kinds are never equal.
+ */
+export function regionsEqual(a, b) {
+    const ba = a.bounds, bb = b.bounds;
+    if (ba instanceof Rectangle && bb instanceof Rectangle) {
+        return ba.x === bb.x && ba.y === bb.y && ba.width === bb.width && ba.height === bb.height;
+    }
+    if (ba instanceof MultiPolygon && bb instanceof MultiPolygon) {
+        if (ba.polygons.length !== bb.polygons.length)
+            return false;
+        for (let i = 0; i < ba.polygons.length; i++) {
+            if (!polygonsEqual(ba.polygons[i], bb.polygons[i]))
+                return false;
+        }
+        return true;
+    }
+    if (ba instanceof Polygon && bb instanceof Polygon) {
+        return polygonsEqual(ba, bb);
+    }
+    return false;
+}
+/** Same vertices, open/closed state and holes (see {@link regionsEqual}). */
+export function polygonsEqual(pa, pb) {
+    if ((pa.closed !== false) !== (pb.closed !== false))
+        return false;
+    if (pa.xpoints.length !== pb.xpoints.length)
+        return false;
+    for (let i = 0; i < pa.xpoints.length; i++) {
+        if (pa.xpoints[i] !== pb.xpoints[i] || pa.ypoints[i] !== pb.ypoints[i])
+            return false;
+    }
+    return holesEqual(pa.holes, pb.holes);
+}
+function holesEqual(a, b) {
+    const na = a?.length ?? 0, nb = b?.length ?? 0;
+    if (na !== nb)
+        return false;
+    for (let h = 0; h < na; h++) {
+        const ra = a[h], rb = b[h];
+        if (ra.length !== rb.length)
+            return false;
+        for (let i = 0; i < ra.length; i++) {
+            if (ra[i][0] !== rb[i][0] || ra[i][1] !== rb[i][1])
+                return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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