flo-mat 4.1.5 → 5.0.1

package/__tests__/cp-node/fs/insert-cp-node.spec.ts

@@ -1,7 +1,91 @@
 import { expect, test } from '@jest/globals';
+import { RbTree } from 'flo-ll-rb-tree';
+import type { CpNode } from '../../../src/cp-node/cp-node.js';
+import type { PointOnShape } from '../../../src/point-on-shape/point-on-shape.js';
 import { insertCpNode } from '../../../src/cp-node/fs/insert-cp-node.js';
+import { cpNodeComparator } from '../../../src/cp-node/fs/cp-node-comparator.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('insertCpNode [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+/** A point on the shape (on the curve of the given node at `t`) with a zero disk. */
+function posOnCurveOf(cpNode: CpNode, t: number, p: number[]): PointOnShape {
+    return {
+        curve: cpNode.pointOnShape.curve, t, p,
+        pDd: [[0,p[0]],[0,p[1]]], isSource: true,
+        circle: { center: p, radius: 0 }, order: 0, order2: 0
+    };
+}
+
+
+test('insertCpNode', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const all = getAllOnLoop(cpNode);
+    const cpTree = new RbTree<CpNode>(cpNodeComparator);
+    for (const cp of all) { cpTree.insert(cp); }
+    const lastInsertId = { id: 1000 };
+
+    // insert between [24,8] (id 1, end of curve 0) and [46,8] (id 10, end of
+    // curve 1) a point halfway along curve 1
+    const pred = byId(1);
+    const succ = byId(10);
+    const pos = posOnCurveOf(succ, 0.5, [35, 8]);
+    const inserted = insertCpNode(false, false, false, cpTree, pos, pred, succ, lastInsertId)!;
+
+    expect(inserted).toBeDefined();
+    expect(inserted.id).toBe(1000);
+    expect(lastInsertId.id).toBe(1001);
+    expect(inserted.pointOnShape).toBe(pos);
+    expect(inserted.isHoleClosing).toBe(false);
+    expect(inserted.isIntersection).toBe(false);
+    // linked into the loop...
+    expect(inserted.prev).toBe(pred);
+    expect(inserted.next).toBe(succ);
+    expect(pred.next).toBe(inserted);
+    expect(succ.prev).toBe(inserted);
+    expect(getAllOnLoop(cpNode).length).toBe(all.length + 1);
+    // ...and into the tree, in order
+    expect(cpTree.find(inserted)?.datum).toBe(inserted);
+    expect(cpTree.size).toBe(all.length + 1);
+    const inOrder = cpTree.toArr();
+    expect(inOrder.length).toBe(all.length + 1);
+    expect(inOrder[inOrder.indexOf(pred) + 1]).toBe(inserted);
+    expect(inOrder[inOrder.indexOf(inserted) + 1]).toBe(succ);
+    // the on-circle edges are left for the caller to set
+    expect(inserted.nextOnCircle).toBeUndefined();
+    expect(inserted.prevOnCircle).toBeUndefined();
+
+    {
+        // A point on curve 3 does not belong between ids 1 and 10 - refused
+        // unless told to insert regardless. (At t=0.25 - not t=0.5 where id
+        // 145 already sits, which the tree would treat as a duplicate.)
+        const wrongPos = posOnCurveOf(byId(145), 0.25, [63.75, 54]);
+        const r = insertCpNode(false, false, false, cpTree, wrongPos, pred, inserted, lastInsertId);
+        expect(r).toBeUndefined();
+        expect(pred.next).toBe(inserted);
+        expect(cpTree.size).toBe(all.length + 1);
+        expect(lastInsertId.id).toBe(1001);
+
+        const forced = insertCpNode(true, true, true, cpTree, wrongPos, pred, inserted, lastInsertId)!;
+        expect(forced).toBeDefined();
+        expect(forced.id).toBe(1001);
+        expect(forced.isHoleClosing).toBe(true);
+        expect(forced.isIntersection).toBe(true);
+        expect(pred.next).toBe(forced);
+        expect(forced.next).toBe(inserted);
+        expect(inserted.prev).toBe(forced);
+        expect(cpTree.size).toBe(all.length + 2);
+    }
+
+    {
+        // without a predecessor the node starts a loop of its own
+        const emptyTree = new RbTree<CpNode>(cpNodeComparator);
+        const lone = insertCpNode(false, false, false, emptyTree, pos, undefined, undefined, lastInsertId)!;
+        expect(lone.next).toBe(lone);
+        expect(lone.prev).toBe(lone);
+        expect(emptyTree.size).toBe(1);
+        expect(emptyTree.toArr()[0]).toBe(lone);
+    }
 });

package/__tests__/cp-node/fs/is-special.spec.ts

@@ -10,7 +10,7 @@ test('isSpecial', function() {
     const allOnLoop = getAllOnLoop(cpNode);
 
     for (const n of allOnLoop) {
-        const expected = getRealProngCount(n) !== 2 && !n.isHoleClosing;
+        const expected = getRealProngCount(n) !== 2 || n.isHoleClosing;
         expect(isSpecial(n)).toBe(expected);
     }
 });

package/__tests__/cp-node/fs/remove-cp-node.spec.ts

@@ -1,7 +1,46 @@
 import { expect, test } from '@jest/globals';
+import { RbTree } from 'flo-ll-rb-tree';
+import type { CpNode } from '../../../src/cp-node/cp-node.js';
+import type { MatMeta } from '../../../src/mat/mat-meta.js';
 import { removeCpNode } from '../../../src/cp-node/fs/remove-cp-node.js';
+import { cpNodeComparator } from '../../../src/cp-node/fs/cp-node-comparator.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('removeCpNode [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('removeCpNode', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const all = getAllOnLoop(cpNode);
+
+    const loop = cpNode.pointOnShape.curve.loop;
+    const cpTree = new RbTree<CpNode>(cpNodeComparator);
+    for (const cp of all) { cpTree.insert(cp); }
+    const meta = { cpTrees: new Map([[loop, cpTree]]) } as unknown as MatMeta;
+
+    const cp = byId(10);
+    const prev = cp.prev;  // id 1
+    const next = cp.next;  // id 144
+    expect(cpTree.find(cp)?.datum).toBe(cp);
+
+    removeCpNode(cp, meta);
+
+    // (compare `CpNode`s by identity / id only - they are circular structures
+    // that must not be deep-compared)
+
+    // unlinked from the loop...
+    expect(prev.next).toBe(next);
+    expect(next.prev).toBe(prev);
+    const remaining = getAllOnLoop(cpNode);
+    expect(remaining.length).toBe(all.length - 1);
+    expect(remaining.includes(cp)).toBe(false);
+    // ...and from the tree, with everything else still there
+    expect(cpTree.find(cp)).toBeUndefined();
+    expect(cpTree.size).toBe(all.length - 1);
+    const expectedIds = all.filter(c => c !== cp).sort(cpNodeComparator).map(c => c.id);
+    expect(cpTree.toArr().map(c => c.id)).toEqual(expectedIds);
+    // the removed node itself is left untouched
+    expect(cp.prev).toBe(prev);
+    expect(cp.next).toBe(next);
 });

package/__tests__/find-2-prong/calc-seperation-tolerance.spec.ts

@@ -0,0 +1,46 @@
+import { expect, test } from '@jest/globals';
+import { calcSquaredSeperationTolerance } from '../../src/find-2-prong/calc-seperation-tolerance.js';
+
+
+/**
+ * Reference: the squared chord `(2r·sin(θ/2))²` with `θ` from the law of
+ * cosines formulation, computed via `1 - cos θ` to avoid cancellation.
+ */
+function refSquaredChord(R: number, r: number, δ: number) {
+    const oneMinusCos = (R*δ + δ*δ/2) / ((R - r)*(r + δ));
+    const θ = 2*Math.asin(Math.sqrt(oneMinusCos/2));
+    return (2*r*Math.sin(θ/2))**2;
+}
+
+
+test('calcSquaredSeperationTolerance', function() {
+    // a spread of osculating radii, MAT radii and (tiny) distance tolerances
+    const cases: [number, number, number][] = [
+        [100, 50, 2**-34], [100, 99, 2**-34], [1000, 0.5, 2**-30],
+        [100, 99.999, 2**-34], [37.3, 12.1, 2**-40], [2**20, 1000, 2**-24],
+    ];
+    for (const [R, r, δ] of cases) {
+        const d2 = calcSquaredSeperationTolerance(R, r, δ);
+        expect(Number.isFinite(d2)).toBe(true);
+        expect(d2).toBeGreaterThan(0);
+        // agrees with the trigonometric reference
+        expect(d2 / refSquaredChord(R, r, δ)).toBeCloseTo(1, 12);
+    }
+
+    // the closer the MAT radius gets to the osculating radius (a near
+    // 1-prong) the larger the separation required
+    const grow = [10, 50, 90, 99, 99.9].map(r => calcSquaredSeperationTolerance(100, r, 2**-34));
+    for (let i=1; i<grow.length; i++) { expect(grow[i]).toBeGreaterThan(grow[i-1]); }
+
+    // ...and a larger error tolerance requires more separation too
+    expect(calcSquaredSeperationTolerance(100, 50, 2**-30))
+        .toBeGreaterThan(calcSquaredSeperationTolerance(100, 50, 2**-34));
+
+    // the enlarged MAT circle reaching the osculating circle: reject everything
+    expect(calcSquaredSeperationTolerance(100, 100, 2**-34)).toBe(Infinity);
+    expect(calcSquaredSeperationTolerance(100, 100 - 2**-40, 2**-34)).toBe(Infinity);
+    expect(calcSquaredSeperationTolerance(100, 120, 2**-34)).toBe(Infinity);
+
+    // sanity: a concrete value (R=100, r=50, δ=2**-34), chord ~ 1.079e-4
+    expect(Math.sqrt(calcSquaredSeperationTolerance(100, 50, 2**-34))).toBeCloseTo(1.078959e-4, 9);
+});

package/__tests__/find-2-prong/get-medial/get-closest-points.spec.ts

@@ -44,7 +44,7 @@ test('getClosestPoints', function() {
     const def = deflate(H,t);//?
     // def = [47279295, -157379071.5, 100304568, -23598664.03125, 1904993.75390625]
 
-    const r = getClosestPoint(maxPowerOf2, nnorm, nnormDd, yPos, for1Prong, angle, curvePiece);
+    const r = getClosestPoint(maxPowerOf2, nnormDd, yPos, for1Prong, angle, curvePiece);
 
     r;//?
 

package/__tests__/floyd-warshall/get-graph.spec.ts

@@ -0,0 +1,100 @@
+import { expect, test } from '@jest/globals';
+import type { CpNode } from '../../src/cp-node/cp-node.js';
+import { getGraph } from '../../src/floyd-warshall/get-graph.js';
+import { getAllOnLoop } from '../../src/cp-node/fs/get-all-on-loop.js';
+import { getAllOnCircle } from '../../src/cp-node/fs/get-all-on-circle.js';
+import { isVertexSpecial } from '../../src/cp-node/fs/is-vertex-special.js';
+import { getPathsFromStr } from 'flo-boolean';
+import { findMats } from '../../src/find-mat/find-mats.js';
+import { getMats1 } from '../get-mats1.js';
+
+
+/** One `CpNode` per special vertex (leaves, 3-prongs, hole closers). */
+function getSpecialVertices(cpNode: CpNode): CpNode[] {
+    const seen = new Set<CpNode>();
+    const vertices: CpNode[] = [];
+    for (const cp of getAllOnLoop(cpNode)) {
+        if (seen.has(cp)) { continue; }
+        for (const c of getAllOnCircle(cp)) { seen.add(c); }
+        if (isVertexSpecial(cp)) { vertices.push(cp); }
+    }
+    return vertices;
+}
+
+
+function checkGraph(graph: number[][], V: number, symmetricLengths: boolean) {
+    expect(graph.length).toBe(V);
+    for (let i=0; i<V; i++) {
+        expect(graph[i].length).toBe(V);
+        expect(graph[i][i]).toBe(0);
+        let adjacent = 0;
+        for (let j=0; j<V; j++) {
+            const d = graph[i][j];
+            // symmetric adjacency...
+            expect(Number.isFinite(graph[j][i])).toBe(Number.isFinite(d));
+            // ...and symmetric lengths (up to the summation order of the edge
+            // lengths) - except across hole closers, where the two directions
+            // currently accumulate slightly different lengths (pre-existing)
+            if (symmetricLengths && Number.isFinite(d)) {
+                expect(d).toBeCloseTo(graph[j][i], 9);
+            }
+            expect(d >= 0).toBe(true);
+            if (i !== j && Number.isFinite(d)) { adjacent++; }
+        }
+        // the MAT is connected: every special vertex has a neighbour
+        expect(adjacent).toBeGreaterThan(0);
+    }
+}
+
+
+test('getGraph - single loop fixture', function() {
+    const { cpNode } = getMats1()[0];
+    const vertices = getSpecialVertices(cpNode);
+    // 5 leaves + 3 3-prongs
+    expect(vertices.length).toBe(8);
+
+    const graph = getGraph(vertices);
+    checkGraph(graph, vertices.length, true);
+
+    // the 3-prong {142,143,144} (center [81.5,-12.64]) is adjacent to the
+    // 3-prong at [81.5,18.5] by a straight vertical edge of length 31.14...
+    const i = vertices.findIndex(v => v.pointOnShape.circle.center[1] === 18.5);
+    const j = vertices.findIndex(v => v.pointOnShape.circle.center[1] === -12.641417453935567);
+    expect(i).toBeGreaterThanOrEqual(0);
+    expect(j).toBeGreaterThanOrEqual(0);
+    expect(graph[i][j]).toBeCloseTo(18.5 + 12.641417453935567, 9);
+});
+
+
+test('getGraph - shape with a hole (hole closers are skipped via their twins)', function() {
+    // (not the SAT-processed fixture: the SAT culls all the spurs of a square
+    // frame, leaving only a cycle of 2-prongs and thus no special vertices)
+    const loops = getPathsFromStr(
+        'M0 0 L100 0 L100 100 L0 100 Z ' +
+        'M30 30 L30 70 L70 70 L70 30 Z'
+    );
+    const { cpNode } = findMats(loops, { applySat: false, simplify: false })[0];
+    const vertices = getSpecialVertices(cpNode).filter(v => !v.isHoleClosing);
+    // 4 outer-corner leaves + 4 3-prongs where the spurs meet the ring
+    expect(vertices.length).toBe(8);
+
+    // must terminate (the walk over a hole closer continues on the other loop)
+    const graph = getGraph(vertices);
+    checkGraph(graph, vertices.length, false);
+
+    // the 4 leaves are each adjacent to exactly one 3-prong (their spur)...
+    const leaves = vertices.filter(v => v.pointOnShape.circle.radius === 0);
+    expect(leaves.length).toBe(4);
+    for (const leaf of leaves) {
+        const i = vertices.indexOf(leaf);
+        const finite = graph[i].filter((d, j) => j !== i && Number.isFinite(d));
+        expect(finite.length).toBe(1);
+    }
+    // ...and each 3-prong to its spur leaf and its two ring neighbours
+    for (const v of vertices) {
+        if (v.pointOnShape.circle.radius === 0) { continue; }
+        const i = vertices.indexOf(v);
+        const finite = graph[i].filter((d, j) => j !== i && Number.isFinite(d));
+        expect(finite.length).toBe(3);
+    }
+});

package/__tests__/get-mats-with-hole.ts

@@ -0,0 +1,28 @@
+import type { Mat } from "../src/mat/mat.js";
+import { getPathsFromStr } from 'flo-boolean';
+import { findMats } from "../src/find-mat/find-mats.js";
+
+
+// Cache - the tests using this fixture must not mutate it.
+let mats: Mat[] | undefined = undefined;
+
+/**
+ * A square with a square hole - forces hole-closing 2-prongs (which `getMats1`
+ * does not have). Unlike `getMats1` this is calculated and thus susceptible to
+ * small perturbations in the algorithm, so only test *structural* properties
+ * against it.
+ */
+function getMatsWithHole(): Mat[] {
+    if (mats) { return mats; }
+
+    const loops = getPathsFromStr(
+        'M0 0 L100 0 L100 100 L0 100 Z ' +
+        'M30 30 L30 70 L70 70 L70 30 Z'
+    );
+    mats = findMats(loops, {});
+
+    return mats;
+}
+
+
+export { getMatsWithHole }

package/__tests__/get-mats1.spec.ts

@@ -0,0 +1,61 @@
+import { expect, test } from '@jest/globals';
+import type { Circle } from '../src/geometry/circle.js';
+import { getMats1, cpNodeStringifyable1 } from './get-mats1.js';
+import { getAllOnCircle } from '../src/cp-node/fs/get-all-on-circle.js';
+import { getAllOnLoop_ByLoop } from '../src/cp-node/fs/get-all-on-loop-by-loop.js';
+
+
+test('`getMats1` fixture: one `Circle` object per on-circle ring', function() {
+    {
+        // The stringifyable literal itself (before `fromStringifyable` 
+        // normalizes anything) must already share one `Circle` object per
+        // on-circle ring and no `Circle` object across rings.
+        const { cpNodes } = cpNodeStringifyable1;
+        const byId = new Map(cpNodes.map(cp => [cp.id, cp]));
+
+        const seen = new Set<number>();
+        const ringOfCircle = new Map<Circle, number[]>();
+        for (const cpNode of cpNodes) {
+            if (seen.has(cpNode.id)) { continue; }
+
+            // walk the ring via the `nextOnCircle` ids
+            const ring: number[] = [];
+            let cp = cpNode;
+            do {
+                ring.push(cp.id);
+                seen.add(cp.id);
+                cp = byId.get(cp.nextOnCircle as number)!;
+            } while (cp !== cpNode);
+
+            const { circle } = cpNode.pointOnShape;
+            for (const id of ring) {
+                expect(byId.get(id)!.pointOnShape.circle).toBe(circle);
+            }
+            expect(ringOfCircle.has(circle)).toBe(false);
+            ringOfCircle.set(circle, ring);
+        }
+
+        expect(ringOfCircle.size).toBe(10);
+    }
+    {
+        // ...and so does the `CpNode` graph built from it
+        const { cpNode } = getMats1()[0];
+        const cpNodes = getAllOnLoop_ByLoop(cpNode).flat();
+
+        const seen = new Set<typeof cpNode>();
+        const circles = new Set<Circle>();
+        for (const cp of cpNodes) {
+            if (seen.has(cp)) { continue; }
+
+            const { circle } = cp.pointOnShape;
+            for (const cp_ of getAllOnCircle(cp)) {
+                seen.add(cp_);
+                expect(cp_.pointOnShape.circle).toBe(circle);
+            }
+            expect(circles.has(circle)).toBe(false);
+            circles.add(circle);
+        }
+
+        expect(circles.size).toBe(10);
+    }
+});

package/__tests__/get-mats1.ts

@@ -1,83 +1,90 @@
 import type { Mat } from "../src/mat/mat.js";
 import type { CpNodeStringifyable } from "../src/cp-node/stringification/cp-node-stringifyable.js";
+import type { Circle } from "../src/geometry/circle.js";
 import { findMats } from "../src/find-mat/find-mats.js";
 import { fromStringifyable } from "../src/cp-node/stringification/from-stringifyable.js";
 
 
 
-// Cache; we use this one in tests since it is fixed and not susceptible to
-// small perturbations in the algorithm.
-let mats1: Mat[] | undefined = undefined;
-function getMats1() {
-    const _cpNode: CpNodeStringifyable = {
-        cpNodes: [
-            {
-                id: 0,
-                isHoleClosing: false,
-                isIntersection: false,
-                pointOnShape: {
-                    circle: {
-                        center: [24,8],
-                        radius: 0
-                    },
-                    curveIdx: 0,
-                    loopIdx: 0,
-                    p: [24, 8],
-                    pDd: [[0,24],[0,8]],
-                    t: 1,
-                    isSource: true,
-                    order: -1,
-                    order2: 0
-                },
-                prev: 11,
-                next: 1,
-                prevOnCircle: 1,
-                nextOnCircle: 1
+// One `Circle` object per on-circle ring (shared by all the ring's `CpNode`s
+// and by no other ring) - see `PointOnShape.circle`. The fixture has no hole
+// closers, so there are no twin rings with equal-but-distinct circles.
+const circle_0_1: Circle = { center: [24, 8], radius: 0 };
+const circle_10_11: Circle = { center: [46, -5.21425847941623], radius: 13.21425847941623 };
+const circle_142_143_144: Circle = { center: [81.5, -12.641417453935567], radius: 41.064803841095305 };
+const circle_145_146_147: Circle = { center: [81.5, 18.5], radius: 35.5 };
+const circle_2_3: Circle = { center: [46, 54], radius: 0 };
+const circle_4_5: Circle = { center: [117, 54], radius: 0 };
+const circle_6_7: Circle = { center: [139, 8], radius: 0 };
+const circle_8_9: Circle = { center: [82, -101], radius: 0 };
+const circle_148_149_150: Circle = { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263 };
+const circle_118_119: Circle = { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272 };
+
+
+/** mat-demo: "achispado" font, "comma" glyph - fixed MAT fixture */
+const cpNodeStringifyable1: CpNodeStringifyable = {
+    cpNodes: [
+        {
+            id: 0,
+            isHoleClosing: false,
+            isIntersection: false,
+            pointOnShape: {
+                circle: circle_0_1,
+                curveIdx: 0,
+                loopIdx: 0,
+                p: [24, 8],
+                pDd: [[0,24],[0,8]],
+                t: 1,
+                isSource: true,
+                order: -1,
+                order2: 0
             },
-            { id: 1,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [24, 8],                           radius: 0                    }, curveIdx: 0, loopIdx: 0, p: [24, 8],                           t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,24],[0,8]] }, prev: 0,   next: 10,  prevOnCircle: 0,   nextOnCircle: 0   },
-            { id: 10,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, -5.21425847941623],           radius: 13.21425847941623    }, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,8]] }, prev: 1,   next: 144, prevOnCircle: 11,  nextOnCircle: 11  },
-            { id: 144, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],       radius: 41.064803841095305   }, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: false , order: -0.5026547194480646,   order2: 0, pDd: [[0,46],[0,8]] }, prev: 10,  next: 147, prevOnCircle: 143, nextOnCircle: 142 },
-            { id: 147, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 2, loopIdx: 0, p: [46, 18.499999999999996],           t: 0.2282608695652173,   isSource: false , order: 0,                     order2: 0, pDd: [[0,46],[0,18.499999999999996]] }, prev: 144, next: 2,   prevOnCircle: 146, nextOnCircle: 145 },
-            { id: 2,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, 54],                         radius: 0                    }, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,54]] }, prev: 147, next: 3,   prevOnCircle: 3,   nextOnCircle: 3   },
-            { id: 3,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, 54],                         radius: 0                    }, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,46],[0,54]] }, prev: 2,   next: 145, prevOnCircle: 2,   nextOnCircle: 2   },
-            { id: 145, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 3, loopIdx: 0, p: [81.5, 54],                        t: 0.5,                  isSource: false , order: 0,                     order2: 0, pDd: [[0,81.5],[0,54]] }, prev: 3,   next: 4,   prevOnCircle: 147, nextOnCircle: 146 },
-            { id: 4,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [117, 54],                        radius: 0                    }, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,117],[0,54]] }, prev: 145, next: 5,   prevOnCircle: 5,   nextOnCircle: 5   },
-            { id: 5,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [117, 54],                        radius: 0                    }, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,117],[0,54]] }, prev: 4,   next: 146, prevOnCircle: 4,   nextOnCircle: 4   },
-            { id: 146, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, 18.5],                     radius: 35.5                 }, curveIdx: 4, loopIdx: 0, p: [117, 18.499999999999996],          t: 0.7717391304347827,   isSource: false , order: 0,                     order2: 0, pDd: [[0,117],[0,18.499999999999996]] }, prev: 5,   next: 142, prevOnCircle: 145, nextOnCircle: 147 },
-            { id: 142, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],       radius: 41.064803841095305   }, curveIdx: 4, loopIdx: 0, p: [117, 8],                          t: 1,                    isSource: false , order: -0.8644872659655476,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 146, next: 148, prevOnCircle: 144, nextOnCircle: 143 },
-            { id: 148, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.8598373023056252,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 142, next: 119, prevOnCircle: 150, nextOnCircle: 149 },
-            { id: 119, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272  }, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.07781165936695383,  order2: 0, pDd: [[0,117],[0,8]] }, prev: 148, next: 6,   prevOnCircle: 118, nextOnCircle: 118 },
-            { id: 6,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [139, 8],                          radius: 0                    }, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,139],[0,8]] }, prev: 119, next: 7,   prevOnCircle: 7,   nextOnCircle: 7   },
-            { id: 7,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [139, 8],                          radius: 0                    }, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,139],[0,8]] }, prev: 6,   next: 118, prevOnCircle: 6,   nextOnCircle: 6   },
-            { id: 118, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [115.9110440340909, -5.952334953607174], radius: 13.994766012811272  }, curveIdx: 6, loopIdx: 0, p: [128.3125, -12.4375],         t: 0.1875,               isSource: true  , order: 0,                     order2: 0, pDd: [[0,128.3125],[0,-12.4375]] }, prev: 7,   next: 149, prevOnCircle: 119, nextOnCircle: 119 },
-            { id: 149, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 6, loopIdx: 0, p: [118.08071791640388, -32.003539423017145], t: 0.36700494883501966, isSource: false , order: 0, order2: 0, pDd: [[0,118.08071791640388],[0,-32.003539423017145]] }, prev: 118, next: 8,   prevOnCircle: 148, nextOnCircle: 150 },
-            { id: 8,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [82, -101],                        radius: 0                    }, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,82],[0,-101]] }, prev: 149, next: 9,   prevOnCircle: 9,   nextOnCircle: 9   },
-            { id: 9,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [82, -101],                        radius: 0                    }, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,82],[0,-101]] }, prev: 8,   next: 150, prevOnCircle: 8,   nextOnCircle: 8   },
-            { id: 150, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.68410160768288, -12.970446490933696], radius: 41.07276841516263  }, curveIdx: 0, loopIdx: 0, p: [45.425023320690585, -32.264267964746104],  t: 0.6306030461949899, isSource: false , order: 0, order2: 0, pDd: [[0,45.425023320690585],[0,-32.264267964746104]] }, prev: 9,   next: 143, prevOnCircle: 149, nextOnCircle: 148 },
-            { id: 143, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [81.5, -12.641417453935567],         radius: 41.064803841095305   }, curveIdx: 0, loopIdx: 0, p: [45.24795284642707, -31.931497590699145],   t: 0.6336559854064299, isSource: false , order: 0, order2: 0, pDd: [[0,45.24795284642707],[0,-31.931497590699145]] }, prev: 150, next: 11,  prevOnCircle: 142, nextOnCircle: 144 },
-            { id: 11,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: { center: [46, -5.21425847941623],            radius: 13.21425847941623    }, curveIdx: 0, loopIdx: 0, p: [34.33444028251029, -11.421620530924521],   t: 0.8218199951291328, isSource: false , order: 0, order2: 0, pDd: [[0,34.33444028251029],[0,-11.421620530924521]] }, prev: 143, next: 0,   prevOnCircle: 10,  nextOnCircle: 10  }
-        ],
-        loops: [
-            { idx: 0, beziers: [[[82, -101], [24, 8]], [[24, 8], [46, 8]], [[46, 8], [46, 54]], [[46, 54], [117, 54]], [[117, 54], [117, 8]], [[117, 8], [139, 8]], [[139, 8], [82, -101]]] }
-        ]
-    };
-
-    const cpNode = fromStringifyable(_cpNode);
-
-    mats1 = [{ cpNode, meta: {
-        boundingHulls: undefined!,
+            prev: 11,
+            next: 1,
+            prevOnCircle: 1,
+            nextOnCircle: 1
+        },
+        { id: 1,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_0_1, curveIdx: 0, loopIdx: 0, p: [24, 8],                           t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,24],[0,8]] }, prev: 0,   next: 10,  prevOnCircle: 0,   nextOnCircle: 0   },
+        { id: 10,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_10_11, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,8]] }, prev: 1,   next: 144, prevOnCircle: 11,  nextOnCircle: 11  },
+        { id: 144, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 1, loopIdx: 0, p: [46, 8],                           t: 1,                    isSource: false , order: -0.5026547194480646,   order2: 0, pDd: [[0,46],[0,8]] }, prev: 10,  next: 147, prevOnCircle: 143, nextOnCircle: 142 },
+        { id: 147, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 2, loopIdx: 0, p: [46, 18.499999999999996],           t: 0.2282608695652173,   isSource: false , order: 0,                     order2: 0, pDd: [[0,46],[0,18.499999999999996]] }, prev: 144, next: 2,   prevOnCircle: 146, nextOnCircle: 145 },
+        { id: 2,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_2_3, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,46],[0,54]] }, prev: 147, next: 3,   prevOnCircle: 3,   nextOnCircle: 3   },
+        { id: 3,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_2_3, curveIdx: 2, loopIdx: 0, p: [46, 54],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,46],[0,54]] }, prev: 2,   next: 145, prevOnCircle: 2,   nextOnCircle: 2   },
+        { id: 145, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 3, loopIdx: 0, p: [81.5, 54],                        t: 0.5,                  isSource: false , order: 0,                     order2: 0, pDd: [[0,81.5],[0,54]] }, prev: 3,   next: 4,   prevOnCircle: 147, nextOnCircle: 146 },
+        { id: 4,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_4_5, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,117],[0,54]] }, prev: 145, next: 5,   prevOnCircle: 5,   nextOnCircle: 5   },
+        { id: 5,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_4_5, curveIdx: 3, loopIdx: 0, p: [117, 54],                         t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,117],[0,54]] }, prev: 4,   next: 146, prevOnCircle: 4,   nextOnCircle: 4   },
+        { id: 146, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_145_146_147, curveIdx: 4, loopIdx: 0, p: [117, 18.499999999999996],          t: 0.7717391304347827,   isSource: false , order: 0,                     order2: 0, pDd: [[0,117],[0,18.499999999999996]] }, prev: 5,   next: 142, prevOnCircle: 145, nextOnCircle: 147 },
+        { id: 142, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 4, loopIdx: 0, p: [117, 8],                          t: 1,                    isSource: false , order: -0.8644872659655476,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 146, next: 148, prevOnCircle: 144, nextOnCircle: 143 },
+        { id: 148, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.8598373023056252,   order2: 0, pDd: [[0,117],[0,8]] }, prev: 142, next: 119, prevOnCircle: 150, nextOnCircle: 149 },
+        { id: 119, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_118_119, curveIdx: 4, loopIdx: 0, p: [117, 8],                   t: 1,                    isSource: false , order: -0.07781165936695383,  order2: 0, pDd: [[0,117],[0,8]] }, prev: 148, next: 6,   prevOnCircle: 118, nextOnCircle: 118 },
+        { id: 6,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_6_7, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,139],[0,8]] }, prev: 119, next: 7,   prevOnCircle: 7,   nextOnCircle: 7   },
+        { id: 7,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_6_7, curveIdx: 5, loopIdx: 0, p: [139, 8],                          t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,139],[0,8]] }, prev: 6,   next: 118, prevOnCircle: 6,   nextOnCircle: 6   },
+        { id: 118, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_118_119, curveIdx: 6, loopIdx: 0, p: [128.3125, -12.4375],         t: 0.1875,               isSource: true  , order: 0,                     order2: 0, pDd: [[0,128.3125],[0,-12.4375]] }, prev: 7,   next: 149, prevOnCircle: 119, nextOnCircle: 119 },
+        { id: 149, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 6, loopIdx: 0, p: [118.08071791640388, -32.003539423017145], t: 0.36700494883501966, isSource: false , order: 0, order2: 0, pDd: [[0,118.08071791640388],[0,-32.003539423017145]] }, prev: 118, next: 8,   prevOnCircle: 148, nextOnCircle: 150 },
+        { id: 8,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_8_9, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: -1,                    order2: 0, pDd: [[0,82],[0,-101]] }, prev: 149, next: 9,   prevOnCircle: 9,   nextOnCircle: 9   },
+        { id: 9,   isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_8_9, curveIdx: 6, loopIdx: 0, p: [82, -101],                        t: 1,                    isSource: true  , order: 1,                     order2: 0, pDd: [[0,82],[0,-101]] }, prev: 8,   next: 150, prevOnCircle: 8,   nextOnCircle: 8   },
+        { id: 150, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_148_149_150, curveIdx: 0, loopIdx: 0, p: [45.425023320690585, -32.264267964746104],  t: 0.6306030461949899, isSource: false , order: 0, order2: 0, pDd: [[0,45.425023320690585],[0,-32.264267964746104]] }, prev: 9,   next: 143, prevOnCircle: 149, nextOnCircle: 148 },
+        { id: 143, isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_142_143_144, curveIdx: 0, loopIdx: 0, p: [45.24795284642707, -31.931497590699145],   t: 0.6336559854064299, isSource: false , order: 0, order2: 0, pDd: [[0,45.24795284642707],[0,-31.931497590699145]] }, prev: 150, next: 11,  prevOnCircle: 142, nextOnCircle: 144 },
+        { id: 11,  isHoleClosing: false, isIntersection: false, pointOnShape: { circle: circle_10_11, curveIdx: 0, loopIdx: 0, p: [34.33444028251029, -11.421620530924521],   t: 0.8218199951291328, isSource: false , order: 0, order2: 0, pDd: [[0,34.33444028251029],[0,-11.421620530924521]] }, prev: 143, next: 0,   prevOnCircle: 10,  nextOnCircle: 10  }
+    ],
+    loops: [
+        { idx: 0, beziers: [[[82, -101], [24, 8]], [[24, 8], [46, 8]], [[46, 8], [46, 54]], [[46, 54], [117, 54]], [[117, 54], [117, 8]], [[117, 8], [139, 8]], [[139, 8], [82, -101]]] }
+    ]
+};
+
+
+// We use this one in tests since it is fixed and not susceptible to
+// small perturbations in the algorithm.
+function getMats1(): Mat[] {
+    const cpNode = fromStringifyable(cpNodeStringifyable1);
+
+    return [{ cpNode, meta: {
         cpTrees: undefined!,
         loops: undefined!,
-        dullCorners: undefined!,
         lastInsertId: undefined!,
-        looseBoundingBoxes: undefined!,
         maxCoordPowerOf2: undefined!,
-        sharpCorners: undefined!,
-        squaredDiagonalLength: undefined!,
-        tightBoundingBoxes: undefined!
+        squaredDiagonalLength: undefined!
     } }];
-
-    return mats1;
 }
 
 
@@ -119,5 +126,6 @@ function _getMats1() {
 
 export {
     getMats1,
+    cpNodeStringifyable1,
     // _getMats1
 }

package/__tests__/helpers/cp-node-by-id.ts

@@ -0,0 +1,27 @@
+import type { CpNode } from "../../src/cp-node/cp-node.js";
+import { getAllOnLoop } from "../../src/cp-node/fs/get-all-on-loop.js";
+
+
+/**
+ * Returns the `CpNode` with the given `id` on the same loop as the given 
+ * `CpNode` (throws if not found) - for picking out specific nodes of the 
+ * `getMats1` fixture.
+ */
+function cpNodeById(
+        cpNode: CpNode,
+        id: number): CpNode {
+
+    const found = getAllOnLoop(cpNode).find(cp => cp.id === id);
+    if (!found) { throw new Error(`no CpNode with id ${id}`); }
+
+    return found;
+}
+
+
+/** Returns a function mapping ids to `CpNode`s on the given loop. */
+function cpNodesByIdOn(cpNode: CpNode) {
+    return (id: number) => cpNodeById(cpNode, id);
+}
+
+
+export { cpNodeById, cpNodesByIdOn }