flo-mat 4.1.5 → 5.0.2

package/__tests__/cp-node/fs/get-branch.spec.ts

@@ -1,7 +1,64 @@
 import { expect, test } from '@jest/globals';
 import { getBranch } from '../../../src/cp-node/fs/get-branch.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getRealProngCount } from '../../../src/cp-node/fs/get-real-prong-count.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getBranch [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getBranch', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const ids = (cps: { id: number }[]) => cps.map(cp => cp.id);
+
+    // The branch from the sharp corner [24,8] via the 2-prong {10,11} to the
+    // 3-prong {142,143,144}. `getBranch` walks forward to the first vertex
+    // that is not a 2-prong and then returns the branch *back* from there
+    // (without the final node), so the result depends on the direction of
+    // the given node.
+    expect(ids(getBranch(byId(1)))).toEqual([143, 11]);
+    expect(ids(getBranch(byId(10)))).toEqual([143, 11]);
+    expect(ids(getBranch(byId(11)))).toEqual([1, 10]);
+    expect(ids(getBranch(byId(143)))).toEqual([1, 10]);
+    // a terminating node first steps to its non-terminating twin
+    expect(ids(getBranch(byId(0)))).toEqual([143, 11]);
+
+    // single-edge branches between non-2-prong vertices
+    expect(ids(getBranch(byId(144)))).toEqual([146]);  // 3-prong -> 3-prong
+    expect(ids(getBranch(byId(147)))).toEqual([3]);    // 3-prong -> leaf
+
+    // Structural invariants for every node in the fixture (none are trivial)
+    for (const cp of getAllOnLoop(cpNode)) {
+        const branch = getBranch(cp);
+        expect(branch.length).toBeGreaterThan(0);
+
+        // consecutive along the boundary
+        for (let i=1; i<branch.length; i++) {
+            expect(branch[i]).toBe(branch[i-1].next);
+        }
+        // it starts at a vertex that is not a 2-prong, passes only 2-prongs
+        // and the (excluded) final node is again not a 2-prong
+        expect(getRealProngCount(branch[0])).not.toBe(2);
+        for (const cp of branch.slice(1)) {
+            expect(getRealProngCount(cp)).toBe(2);
+        }
+        const final = branch[branch.length-1].next;
+        expect(getRealProngCount(final)).not.toBe(2);
+        // every node of the branch represents a real (non-terminating) edge
+        for (const cp of branch) { expect(isTerminating(cp)).toBe(false); }
+    }
+
+    // The fixture MAT has 5 leaves, 3 3-prongs and 2 2-prongs, so there are
+    // 7 distinct branches (up to direction).
+    const branchKeys = new Set<string>();
+    for (const cp of getAllOnLoop(cpNode)) {
+        const branch = getBranch(cp);
+        // key by the unordered pair of end vertices (via their circles)
+        const a = branch[0].pointOnShape.circle;
+        const b = branch[branch.length-1].next.pointOnShape.circle;
+        const key = [a, b].map(c => `${c.center[0]},${c.center[1]},${c.radius}`).sort().join('|');
+        branchKeys.add(key);
+    }
+    expect(branchKeys.size).toBe(7);
 });

package/__tests__/cp-node/fs/get-cp-node-ordering.spec.ts

@@ -1,7 +1,23 @@
 import { expect, test } from '@jest/globals';
 import { getCpNodeOrdering } from '../../../src/cp-node/fs/get-cp-node-ordering.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('getCpNodeOrdering [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getCpNodeOrdering', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    expect(getCpNodeOrdering(byId(147))).toEqual({
+        idx: 2, t: 0.2282608695652173, order: 0, order2: 0
+    });
+    // the two nodes at the same corner point differ in `order` only
+    expect(getCpNodeOrdering(byId(0))).toEqual({ idx: 0, t: 1, order: -1, order2: 0 });
+    expect(getCpNodeOrdering(byId(1))).toEqual({ idx: 0, t: 1, order:  1, order2: 0 });
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        const { curve, t, order, order2 } = cp.pointOnShape;
+        expect(getCpNodeOrdering(cp)).toEqual({ idx: curve.idx, t, order, order2 });
+    }
 });

package/__tests__/cp-node/fs/get-distance-to-next.spec.ts

@@ -1,7 +1,40 @@
 import { expect, test } from '@jest/globals';
-import { getMatDistanceToNext } from '../../../src/cp-node/fs/get-distance-to-next.js';
+import { distanceBetween } from 'flo-vector2d';
+import { getMatDistanceToNext, getMatDistanceToNext$ } from '../../../src/cp-node/fs/get-distance-to-next.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getMatDistanceToNext [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getMatDistanceToNext', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const chord = (cp: typeof cpNode) => distanceBetween(
+        cp.pointOnShape.circle.center,
+        cp.next.pointOnShape.circle.center
+    );
+
+    // straight MAT edges: the arc length is the distance between the centers
+    // 3-prong center [81.5,18.5] -> sharp corner [46,54]
+    expect(getMatDistanceToNext(byId(147))).toBeCloseTo(35.5*Math.SQRT2, 9);
+    // sharp corner [24,8] -> 2-prong center [46,-5.21425847941623] (along the
+    // bisector of the corner)
+    expect(getMatDistanceToNext(byId(1))).toBeCloseTo(Math.hypot(22, 8 + 5.21425847941623), 9);
+
+    // a curved MAT edge (equidistant from a corner point and a line, i.e. a
+    // parabola) is strictly longer than its chord
+    expect(getMatDistanceToNext(byId(10))).toBeGreaterThan(chord(byId(10)) + 0.01);
+
+    // the two nodes at a 1-prong share a center
+    expect(getMatDistanceToNext(byId(0))).toBe(0);
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        const d = getMatDistanceToNext(cp);
+        // never shorter than the chord
+        expect(d).toBeGreaterThanOrEqual(chord(cp) - 1e-9);
+        if (isTerminating(cp)) { expect(d).toBe(0); }
+        // the memoized version agrees
+        expect(getMatDistanceToNext$(cp)).toBe(d);
+    }
 });

package/__tests__/cp-node/fs/get-edge-direction.spec.ts

@@ -1,7 +1,54 @@
 import { expect, test } from '@jest/globals';
+import { distanceBetween, dot, fromTo, toUnitVector } from 'flo-vector2d';
 import { getEdgeDirection } from '../../../src/cp-node/fs/get-edge-direction.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
+import { expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getEdgeDirection [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getEdgeDirection', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const dir = (id: number) => {
+        const [c, v] = getEdgeDirection(byId(id));
+        return fromTo(c, v);
+    };
+
+    // 3-prong with center [81.5,18.5] and contact points [46,18.5] (id 147),
+    // [81.5,54] (id 145) and [117,18.5] (id 146): each edge leaves along the
+    // bisector of the contact point of the node and the next one on the circle.
+    const s = Math.SQRT1_2;
+    expectPointClose(dir(147), [-s, s]);
+    expectPointClose(dir(145), [ s, s]);
+    expectPointClose(dir(146), [ 0,-1]);
+
+    // 1-prong at the sharp corner [24,8] (ids 0 and 1): the edge leaves along
+    // the bisector of the corner (both nodes sit at the same point).
+    const bisector = toUnitVector([
+        1 + 58/Math.hypot(58, 109),    // unit([46,8]-[24,8]) + unit([82,-101]-[24,8])
+        0 - 109/Math.hypot(58, 109)
+    ]);
+    expectPointClose(dir(0), bisector);
+    expectPointClose(dir(1), bisector);
+
+    // 2-prong {10,11} on the line [24,8]->[46,8] and the other edge of the
+    // corner: its direction continues the corner bisector (the MAT is smooth
+    // there) - and the opposite way for the node pointing back to the corner.
+    expectPointClose(dir(10), bisector);
+    expectPointClose(dir(11), [-bisector[0], -bisector[1]]);
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        const [c, v] = getEdgeDirection(cp);
+        // starts at the circle center, unit length
+        expect(c).toBe(cp.pointOnShape.circle.center);
+        expect(distanceBetween(c, v)).toBeCloseTo(1, 12);
+
+        // points towards the next vertex (never backwards)
+        if (!isTerminating(cp)) {
+            const toNext = fromTo(c, cp.next.pointOnShape.circle.center);
+            expect(dot(fromTo(c, v), toNext)).toBeGreaterThan(0);
+        }
+    }
 });

package/__tests__/cp-node/fs/get-first-exit.spec.ts

@@ -1,7 +1,82 @@
 import { expect, test } from '@jest/globals';
+import type { CpNode } from '../../../src/cp-node/cp-node.js';
 import { getFirstExit } from '../../../src/cp-node/fs/get-first-exit.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 { getProngCount } from '../../../src/cp-node/fs/get-prong-count.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { getMatsWithHole } from '../../get-mats-with-hole.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getFirstExit [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+/** The invariants `getFirstExit` must satisfy for every node of a MAT. */
+function checkFirstExits(cpNode: CpNode) {
+    for (const cp of getAllOnLoop(cpNode)) {
+        const exit = getFirstExit(cp);
+
+        // the expected result: the first non-terminating node strictly after
+        // `cp` going round the circle, if any
+        const others = getAllOnCircle(cp, true);
+        const expected = others.find(c => !isTerminating(c));
+
+        expect(exit).toBe(expected);
+        // never the node itself
+        expect(exit).not.toBe(cp);
+        if (exit !== undefined) {
+            expect(getAllOnCircle(cp).includes(exit)).toBe(true);
+            expect(isTerminating(exit)).toBe(false);
+        }
+    }
+}
+
+
+test('getFirstExit', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    // 1-prong at the corner [24,8]: from the terminating node 0 the exit is
+    // node 1; from node 1 there is no *other* exit.
+    expect(getFirstExit(byId(0))).toBe(byId(1));
+    expect(getFirstExit(byId(1))).toBeUndefined();
+
+    // 2-prong {10,11}: each is the exit after the other
+    expect(getFirstExit(byId(10))).toBe(byId(11));
+    expect(getFirstExit(byId(11))).toBe(byId(10));
+
+    // 3-prong {144,142,143} (all non-terminating): the next one on the circle
+    expect(getFirstExit(byId(144))).toBe(byId(142));
+    expect(getFirstExit(byId(142))).toBe(byId(143));
+    expect(getFirstExit(byId(143))).toBe(byId(144));
+
+    checkFirstExits(cpNode);
+});
+
+
+test('getFirstExit - terminating nodes on 3-prong rings', function() {
+    const { cpNode } = getMatsWithHole()[0];
+    const all = getAllOnLoop(cpNode);
+
+    // The test is only meaningful if there are terminating nodes on rings of
+    // 3 or more (where `next === prevOnCircle` no longer coincides with
+    // `isTerminating`, which is what used to trip this function up).
+    const terminatingOnBigRings = all.filter(cp =>
+        isTerminating(cp) && getProngCount(cp) >= 3
+    );
+    expect(terminatingOnBigRings.length).toBeGreaterThan(0);
+
+    checkFirstExits(cpNode);
+});
+
+
+test('getFirstExit - MAT consisting of a single point', function() {
+    // Two nodes at the same point forming their own circle and loop (a
+    // degenerate MAT); neither exits the circle.
+    const a = { id: 0 } as unknown as CpNode;
+    const b = { id: 1 } as unknown as CpNode;
+    Object.assign(a, { next: b, prev: b, nextOnCircle: b, prevOnCircle: b });
+    Object.assign(b, { next: a, prev: a, nextOnCircle: a, prevOnCircle: a });
+
+    expect(getFirstExit(a)).toBeUndefined();
+    expect(getFirstExit(b)).toBeUndefined();
 });

package/__tests__/cp-node/fs/get-hole-closers.spec.ts

@@ -1,7 +1,36 @@
 import { expect, test } from '@jest/globals';
 import { getHoleClosers } from '../../../src/cp-node/fs/get-hole-closers.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
+import { getMatsWithHole } from '../../get-mats-with-hole.js';
 
-test.skip('getHoleClosers [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getHoleClosers', function() {
+    {
+        // a single loop has no holes to close
+        const { cpNode } = getMats1()[0];
+        expect(getHoleClosers(cpNode)).toEqual([]);
+    }
+    {
+        const { cpNode } = getMatsWithHole()[0];
+        const holeClosers = getHoleClosers(cpNode);
+
+        // the full set of hole closers on the loop, in loop order (compared
+        // by identity - `CpNode`s are circular structures)
+        const expected = getAllOnLoop(cpNode).filter(cp => cp.isHoleClosing);
+        expect(holeClosers.length).toBe(expected.length);
+        expect(holeClosers.every((cp, i) => cp === expected[i])).toBe(true);
+        expect(holeClosers.length).toBeGreaterThan(0);
+
+        // hole closers come in twins at the same point - one on each loop
+        expect(holeClosers.length % 2).toBe(0);
+        for (const cp of holeClosers) {
+            const twin = cp.holeCloserTwin!;
+            expect(twin).toBeDefined();
+            expect(twin.isHoleClosing).toBe(true);
+            expect(twin.holeCloserTwin).toBe(cp);
+            expect(twin.pointOnShape.p).toEqual(cp.pointOnShape.p);
+            expect(holeClosers.includes(twin)).toBe(true);
+        }
+    }
 });

package/__tests__/cp-node/fs/get-implied-boundary-bezier-between.spec.ts

@@ -1,7 +1,52 @@
 import { expect, test } from '@jest/globals';
 import { getImpliedBoundaryBezierBetween } from '../../../src/cp-node/fs/get-implied-boundary-bezier-between.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';
+import { expectBezierClose, expectBeziersConnected, expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getImpliedBoundaryBezierBetween [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getImpliedBoundaryBezierBetween', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    // Both points on the same straight boundary line: a single line.
+    {
+        const pss = getImpliedBoundaryBezierBetween(byId(147), byId(2));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[46,18.5],[46,54]]);
+    }
+    {
+        // the tangent at the corner [24,8] is taken from the *outgoing* curve
+        const pss = getImpliedBoundaryBezierBetween(byId(1), byId(10));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[24,8],[46,8]]);
+    }
+    {
+        // ...and at [46,8] (id 10, end of curve 1) likewise, so [46,8] ->
+        // [46,18.5] follows curve 2 (vertical)
+        const pss = getImpliedBoundaryBezierBetween(byId(10), byId(147));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[46,8],[46,18.5]]);
+    }
+    {
+        // Tangents (1,0) at [24,8] and (0,1) at [46,18.5] meet at the (cut)
+        // corner [46,8]: a single quadratic with that control point.
+        const pss = getImpliedBoundaryBezierBetween(byId(1), byId(147));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[24,8],[46,8],[46,18.5]]);
+    }
+
+    // For every pair of consecutive nodes the implied boundary runs from the
+    // one point to the other.
+    for (const cp of getAllOnLoop(cpNode)) {
+        const pss = getImpliedBoundaryBezierBetween(cp, cp.next);
+        expect(pss.length).toBeGreaterThan(0);
+        expect(pss.length).toBeLessThanOrEqual(2);
+        expectPointClose(pss[0][0], cp.pointOnShape.p);
+        const last = pss[pss.length-1];
+        expectPointClose(last[last.length-1], cp.next.pointOnShape.p);
+        expectBeziersConnected(pss);
+        for (const ps of pss) { expect([2,3]).toContain(ps.length); }
+    }
 });

package/__tests__/cp-node/fs/get-mat-curve-between.spec.ts

@@ -1,7 +1,81 @@
 import { expect, test } from '@jest/globals';
+import { cross, fromTo, toUnitVector } from 'flo-vector2d';
 import { getMatCurveBetween } from '../../../src/cp-node/fs/get-mat-curve-between.js';
+import { getEdgeDirection } from '../../../src/cp-node/fs/get-edge-direction.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
+import { expectBezierClose, expectBeziersConnected, expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getMatCurveBetween [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+/** unit direction of the given line `[p, q]` */
+const lineDir = (l: number[][]) => toUnitVector(fromTo(l[0], l[1]));
+/** unit tangent at the start / end of a bezier */
+const startTan = (ps: number[][]) => toUnitVector(fromTo(ps[0], ps[1]));
+const endTan   = (ps: number[][]) => toUnitVector(fromTo(ps[ps.length-2], ps[ps.length-1]));
+
+
+test('getMatCurveBetween', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    {
+        // 3-prong center [81.5,18.5] to the sharp corner [46,54]: the edge
+        // direction and the corner bisector are collinear - a straight line
+        const pss = getMatCurveBetween(byId(147), byId(2));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[81.5,18.5],[46,54]]);
+    }
+    {
+        // sharp corner [24,8] to the 2-prong on its bisector - a straight line
+        const pss = getMatCurveBetween(byId(1), byId(10));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[24,8],[46,-5.21425847941623]]);
+    }
+    {
+        // 2-prong {10,11} to the 3-prong {142,143,144}: the medial axis is a
+        // parabola here (equidistant from the corner point [46,8] and a line)
+        // - a single quadratic whose control point is the intersection of the
+        // two edge directions.
+        const pss = getMatCurveBetween(byId(10), byId(144));
+        expect(pss.length).toBe(1);
+        const ps = pss[0];
+        expect(ps.length).toBe(3);
+        const l0 = getEdgeDirection(byId(10));
+        const l1 = getEdgeDirection(byId(143));  // = 144.prevOnCircle
+        expect(cross(fromTo(l0[0], ps[1]), lineDir(l0))).toBeCloseTo(0, 9);
+        expect(cross(fromTo(l1[0], ps[1]), lineDir(l1))).toBeCloseTo(0, 9);
+    }
+
+    // For every MAT edge: 1 or 2 pieces (lines or quadratics), from the
+    // circle center of this node to that of the next, joined smoothly,
+    // leaving along the edge direction at the start and arriving along the
+    // edge direction at the end.
+    for (const cp of getAllOnLoop(cpNode)) {
+        const pss = getMatCurveBetween(cp, cp.next);
+        expect([1,2]).toContain(pss.length);
+        for (const ps of pss) { expect([2,3]).toContain(ps.length); }
+
+        const c0 = cp.pointOnShape.circle.center;
+        const c1 = cp.next.pointOnShape.circle.center;
+        expectPointClose(pss[0][0], c0);
+        const last = pss[pss.length-1];
+        expectPointClose(last[last.length-1], c1);
+        expectBeziersConnected(pss);
+
+        if (isTerminating(cp)) {
+            // both nodes share a center: a degenerate curve
+            for (const ps of pss) { for (const p of ps) { expectPointClose(p, c0); } }
+            continue;
+        }
+
+        const d0 = lineDir(getEdgeDirection(cp));
+        const d1 = lineDir(getEdgeDirection(cp.next.prevOnCircle));
+        expect(cross(startTan(pss[0]), d0)).toBeCloseTo(0, 4);
+        expect(cross(endTan(last), d1)).toBeCloseTo(0, 4);
+        if (pss.length === 2) {
+            expect(cross(endTan(pss[0]), startTan(pss[1]))).toBeCloseTo(0, 9);
+        }
+    }
 });

package/__tests__/cp-node/fs/get-mat-curve-to-next.spec.ts

@@ -1,7 +1,20 @@
 import { expect, test } from '@jest/globals';
-import { getMatCurveToNext } from '../../../src/cp-node/fs/get-mat-curve-to-next.js';
+import { getMatCurveToNext, getMatCurveToNext$ } from '../../../src/cp-node/fs/get-mat-curve-to-next.js';
+import { getMatCurveBetween } from '../../../src/cp-node/fs/get-mat-curve-between.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getMats1 } from '../../get-mats1.js';
 
-test.skip('getMatCurveToNext [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getMatCurveToNext', function() {
+    const { cpNode } = getMats1()[0];
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        const pss = getMatCurveToNext(cp);
+        expect(pss).toEqual(getMatCurveBetween(cp, cp.next));
+
+        // the memoized version returns the identical result, once computed
+        const pss$ = getMatCurveToNext$(cp);
+        expect(pss$).toEqual(pss);
+        expect(getMatCurveToNext$(cp)).toBe(pss$);
+    }
 });

package/__tests__/cp-node/fs/get-mat-curves-between.spec.ts

@@ -1,7 +1,42 @@
 import { expect, test } from '@jest/globals';
 import { getMatCurvesBetween } from '../../../src/cp-node/fs/get-mat-curves-between.js';
+import { getMatCurveToNext } from '../../../src/cp-node/fs/get-mat-curve-to-next.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';
+import { expectBeziersConnected, expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getMatCurvesBetween [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getMatCurvesBetween', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    // nothing between a node and itself
+    expect(getMatCurvesBetween(cpNode, cpNode)).toEqual([]);
+
+    // the flattened edges 1 -> 10 -> 144 -> 147 (the edge leaving the end
+    // node excluded)
+    const pss = getMatCurvesBetween(byId(1), byId(147));
+    expect(pss).toEqual([
+        ...getMatCurveToNext(byId(1)),
+        ...getMatCurveToNext(byId(10)),
+        ...getMatCurveToNext(byId(144)),
+    ]);
+    expectBeziersConnected(pss);
+    expectPointClose(pss[0][0], [24, 8]);
+    const last = pss[pss.length-1];
+    expectPointClose(last[last.length-1], [81.5, 18.5]);
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        expect(getMatCurvesBetween(cp, cp.next)).toEqual(getMatCurveToNext(cp));
+        expect(getMatCurvesBetween(cp, cp.next.next)).toEqual([
+            ...getMatCurveToNext(cp), ...getMatCurveToNext(cp.next)
+        ]);
+    }
+
+    // all the way round (to the predecessor) covers every edge but one
+    const all = getAllOnLoop(cpNode);
+    expect(getMatCurvesBetween(cpNode, cpNode.prev)).toEqual(
+        all.slice(0, -1).flatMap(getMatCurveToNext)
+    );
 });

package/__tests__/cp-node/fs/get-salience.spec.ts

@@ -1,7 +1,72 @@
 import { expect, test } from '@jest/globals';
+import { distanceBetween } from 'flo-vector2d';
 import { getSalience } from '../../../src/cp-node/fs/get-salience.js';
+import { getBoundaryBeziersBetween } from '../../../src/cp-node/fs/get-boundary-beziers-between.js';
+import { getAllOnLoop } from '../../../src/cp-node/fs/get-all-on-loop.js';
+import { getAllOnLoop_ByLoop } from '../../../src/cp-node/fs/get-all-on-loop-by-loop.js';
+import { getRealProngCount } from '../../../src/cp-node/fs/get-real-prong-count.js';
+import { getMats1 } from '../../get-mats1.js';
+import { getMatsWithHole } from '../../get-mats-with-hole.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getSalience [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getSalience', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    // Salience = (boundary length from this contact point forward to the next
+    // contact point on the circle) / (straight distance between them).
+
+    {
+        // 2-prong {10,11} touching [46,8] and a point on the other edge of the
+        // corner [24,8]: from id 11 the boundary runs to the corner and on to
+        // [46,8] - two equal tangent lengths of 22.
+        const cp = byId(11);
+        const d = distanceBetween(cp.pointOnShape.p, cp.nextOnCircle.pointOnShape.p);
+        expect(getSalience(cp)).toBeCloseTo(44/d, 9);
+    }
+    {
+        // 3-prong {142,143,144}: from [46,8] (id 144) forward to [117,8]
+        // (id 142) the boundary goes round the top of the rectangle:
+        // 46 + 71 + 46 = 163, against a chord of 71.
+        expect(getSalience(byId(144))).toBeCloseTo(163/71, 9);
+    }
+
+    // the boundary is never shorter than the chord
+    for (const cp of getAllOnLoop(cpNode)) {
+        if (getRealProngCount(cp) < 2) { continue; }  // 1-prongs: see below
+        const s = getSalience(cp);
+        expect(Number.isFinite(s)).toBe(true);
+        expect(s).toBeGreaterThanOrEqual(1);
+    }
+
+    // 1-prongs (two nodes at the same point): the terminating node has no
+    // boundary between itself and its twin - salience 0 - while the twin has
+    // the entire boundary - salience Infinity. Ids 0 and 1 at the corner
+    // [24,8] are such a pair.
+    expect(getSalience(byId(0))).toBe(0);
+    expect(getSalience(byId(1))).toBe(Infinity);
+    for (const cp of getAllOnLoop(cpNode)) {
+        if (getRealProngCount(cp) >= 2) { continue; }
+        const s = getSalience(cp);
+        expect(Number.isNaN(s)).toBe(false);
+        expect(s === 0 || s === Infinity).toBe(true);
+    }
+});
+
+
+test('getSalience - hole closers', function() {
+    const { cpNode } = getMatsWithHole()[0];
+
+    // a stretch of boundary passing a hole closer has infinite salience
+    const cpNodes = getAllOnLoop_ByLoop(cpNode).flat();
+    let infinite = 0;
+    for (const cp of cpNodes) {
+        const { hasHoleCloser } = getBoundaryBeziersBetween(cp, cp.nextOnCircle);
+        if (hasHoleCloser) {
+            infinite++;
+            expect(getSalience(cp)).toBe(Infinity);
+        }
+    }
+    expect(infinite).toBeGreaterThan(0);
 });

package/__tests__/cp-node/fs/get-vertex-forward-children.spec.ts

@@ -1,7 +1,44 @@
 import { expect, test } from '@jest/globals';
 import { getVertexForwardChildren } from '../../../src/cp-node/fs/get-vertex-forward-children.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 { isTerminating } from '../../../src/cp-node/fs/is-terminating.js';
+import { getMats1 } from '../../get-mats1.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getVertexForwardChildren [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getVertexForwardChildren', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const childIds = (id: number) => getVertexForwardChildren(byId(id)).map(cp => cp.id);
+
+    // Seen as a vertex entered via the given node (its `prevOnCircle` being
+    // the edge back to the parent), the forward children are the far ends of
+    // the other edges, in on-circle order.
+    expect(childIds(144)).toEqual([147, 148]);  // 3-prong: two children
+    expect(childIds(142)).toEqual([148, 11]);   // same 3-prong, entered differently
+    expect(childIds(147)).toEqual([2, 4]);      // 3-prong towards two leaves
+    expect(childIds(10)).toEqual([144]);        // 2-prong: one child
+    expect(childIds(1)).toEqual([10]);          // leaf, leaving
+    expect(childIds(0)).toEqual([]);            // leaf, entered - no children
+
+    for (const cp of getAllOnLoop(cpNode)) {
+        const children = getVertexForwardChildren(cp);
+
+        // one child per non-terminating node on the circle other than the one
+        // leading back
+        const ring = getAllOnCircle(cp);
+        const expected = ring
+            .filter(c => c !== cp.prevOnCircle && !isTerminating(c))
+            .map(c => c.next);
+        expect(children.length).toBe(expected.length);
+        expect(children.every((c, i) => c === expected[i])).toBe(true);
+
+        for (const child of children) {
+            // a child is reached by an edge from this vertex...
+            expect(child.prev.pointOnShape.circle).toBe(cp.pointOnShape.circle);
+            // ...to a different vertex
+            expect(child.pointOnShape.circle).not.toBe(cp.pointOnShape.circle);
+        }
+    }
 });