flo-mat 4.1.4 → 5.0.1

package/__tests__/closest-boundary-point/get-endpoint-info.spec.ts

@@ -0,0 +1,140 @@
+import { expect, test } from '@jest/globals';
+import type { Curve } from 'flo-boolean';
+import type { FootAndEndpointInfo } from '../../src/closest-boundary-point/foot-and-endpoint-info.js';
+import { evalDeCasteljauDd } from 'flo-bezier3';
+import { ddDiffDouble, ddMultDd, ddAddDd, ddLt, ddGt, ddToStr } from 'double-double';
+import { getEndpointInfoCertified } from '../../src/closest-boundary-point/get-endpoint-info.js';
+import { squaredDistanceBetweenDd } from '../../src/find-2-prong/squared-distance-between-dd.js';
+import { eps } from '../../src/error-analysis/gamma.js';
+
+
+/**
+ * The *previous* (library) implementation, kept here for comparison only: the
+ * point is rounded to double precision *before* the distance is taken, which
+ * introduces an absolute error of about `|p|·eps/2` per coordinate; the
+ * returned interval only accounts for a *relative* error of `eps` in the
+ * squared distance and is thus too narrow whenever the point is closer to `x`
+ * than to the origin.
+ */
+function getEndpointInfoUncertified(
+        curve: Curve,
+        x: number[],
+        t: number): FootAndEndpointInfo {
+
+    const { ps } = curve;
+
+    const p = evalDeCasteljauDd(ps, [0,t]).map(v => v[0] + v[1]);
+    const d = squaredDistanceBetweenDd(p, x);
+    const dSquaredI = [d*(1 - eps), d*(1 + eps)];
+
+    const t_ = t === 0 ? 1 : t;
+    const curve_ = t === 0 ? curve.prev : curve;
+
+    return { curve: curve_, t: t_, dSquaredI };
+}
+
+
+/**
+ * The squared distance from `x` to the point at `t` on `ps` in double-double
+ * precision (accurate to roughly 30 significant digits): the reference value.
+ */
+function squaredDistanceDd(ps: number[][], t: number, x: number[]): number[] {
+    const pDd = evalDeCasteljauDd(ps, [0,t]);
+    const dx = ddDiffDouble(pDd[0], x[0]);
+    const dy = ddDiffDouble(pDd[1], x[1]);
+    return ddAddDd(ddMultDd(dx,dx), ddMultDd(dy,dy));
+}
+
+const contains = (I: number[], dRef: number[]) => !ddLt(dRef, [0,I[0]]) && !ddGt(dRef, [0,I[1]]);
+
+
+test('getEndpointInfoCertified vs the old implementation - point far from the origin, close to x', function() {
+    // A cubic with a chord of about 1000 units, living around coordinate
+    // 1000..2000 (as e.g. glyph outlines do); the point at `t` is about
+    // 1300 from the origin but less than 1 unit from `x`.
+    const ps = [[1000,0],[1300,0],[1700,0],[2000,0]];
+    const t = 0.3;
+    const curve = { ps } as Curve;
+    const p = evalDeCasteljauDd(ps, [0,t]).map(v => v[0] + v[1]);
+    const x = [Math.floor(p[0]), 0];  // on the line, just before the point
+    expect(p[0] - x[0]).toBeGreaterThan(0.1);
+    expect(p[0] - x[0]).toBeLessThan(1);
+
+    // The reference squared distance to ~30 digits. The error from rounding
+    // the point to double is about |p|*eps/2 ~ 1300 * 1.1e-16 ~ 1.4e-13 in
+    // the coordinate, i.e. ~3e-13 in the squared distance - roughly a
+    // thousand times the `eps` relative error the old interval claims.
+    const dRef = squaredDistanceDd(ps, t, x);
+
+    const oldI = getEndpointInfoUncertified(curve, x, t).dSquaredI;
+    const newI = getEndpointInfoCertified(curve, x, t).dSquaredI;
+
+    console.log(
+        `reference d²  = ${ddToStr(dRef)}\n` +
+        `old interval  = [${oldI[0]}, ${oldI[1]}]  width/d = ${(oldI[1]-oldI[0])/oldI[0]}\n` +
+        `new interval  = [${newI[0]}, ${newI[1]}]  width/d = ${(newI[1]-newI[0])/newI[0]}\n` +
+        `old interval contains reference: ${contains(oldI, dRef)}\n` +
+        `new interval contains reference: ${contains(newI, dRef)}`
+    );
+
+    // the old interval is far too narrow: it misses the reference value
+    expect(contains(oldI, dRef)).toBe(false);
+    // its claimed relative width is just ~2*eps (a couple of ulps)...
+    expect((oldI[1] - oldI[0]) / oldI[0]).toBeLessThan(4*eps);
+    // ...while the reference lies ~1000*eps away from it
+    const dRefApprox = dRef[1] + dRef[0];
+    expect(Math.abs(dRefApprox - oldI[1]) / oldI[1]).toBeGreaterThan(100*eps);
+
+    // the certified interval contains it and is only ~8*eps wide
+    expect(contains(newI, dRef)).toBe(true);
+    expect((newI[1] - newI[0]) / newI[0]).toBeLessThan(16*eps);
+});
+
+
+test('getEndpointInfoCertified - always contains the reference, old version does not', function() {
+    // sweep a few parameters and offsets on a curve far from the origin
+    const ps = [[5000,3000],[5400,3900],[6100,2200],[6000,3000]];
+    const curve = { ps } as Curve;
+
+    let oldMisses = 0;
+    let checks = 0;
+    for (const t of [0.1, 0.3, 0.45, 0.7, 0.9]) {
+        const p = evalDeCasteljauDd(ps, [0,t]).map(v => v[0] + v[1]);
+        for (const off of [[0.5,0.25],[-1,0.75],[2,-3],[0.1,-0.1]]) {
+            const x = [p[0] + off[0], p[1] + off[1]];
+            const dRef = squaredDistanceDd(ps, t, x);
+
+            expect(contains(getEndpointInfoCertified(curve, x, t).dSquaredI, dRef)).toBe(true);
+            if (!contains(getEndpointInfoUncertified(curve, x, t).dSquaredI, dRef)) { oldMisses++; }
+            checks++;
+        }
+    }
+
+    // the old interval misses most of the time (it is only right by luck)
+    expect(oldMisses).toBeGreaterThan(checks/2);
+});
+
+
+test('getEndpointInfoCertified - x (numerically) on the point: the lower bound is 0', function() {
+    const ps = [[1000,0],[1300,0],[1700,0],[2000,0]];
+    const curve = { ps } as Curve;
+    const t = 0.3;
+    const x = evalDeCasteljauDd(ps, [0,t]).map(v => v[0] + v[1]);  // the rounded point
+
+    const [lo, hi] = getEndpointInfoCertified(curve, x, t).dSquaredI;
+    // the true distance is about the rounding error of the point (~1e-13)
+    expect(lo).toBeGreaterThanOrEqual(0);
+    expect(hi).toBeLessThan(1e-24);
+    expect(contains([lo, hi], squaredDistanceDd(ps, t, x))).toBe(true);
+});
+
+
+test('getEndpointInfoCertified - endpoint at t=0 is attributed to the previous curve', function() {
+    const prev = { ps: [[0,0],[10,0]] } as Curve;
+    const curve = { ps: [[10,0],[10,10]], prev } as Curve;
+    const info = getEndpointInfoCertified(curve, [10,-1], 0);
+    expect(info.curve).toBe(prev);
+    expect(info.t).toBe(1);
+    expect(info.dSquaredI[0]).toBeLessThanOrEqual(1);
+    expect(info.dSquaredI[1]).toBeGreaterThanOrEqual(1);
+});

package/__tests__/closest-boundary-point/root-interval-to-distance-squared-interval.spec.ts

@@ -0,0 +1,87 @@
+import { expect, test } from '@jest/globals';
+import { evalDeCasteljau, getIntervalBox } from 'flo-bezier3';
+import { squaredDistanceBetween } from 'flo-vector2d';
+import { rootIntervalToDistanceSquaredInterval } from '../../src/closest-boundary-point/root-interval-to-distance-squared-interval.js';
+
+
+test('rootIntervalToDistanceSquaredInterval - exact cases on a plain box', function() {
+    const box = [[10, 20], [14, 23]];  // 4 wide, 3 high
+
+    // p inside the box: the min is 0, the max is the furthest corner
+    {
+        const [lo, hi] = rootIntervalToDistanceSquaredInterval(box, [11, 21]);
+        expect(lo).toBe(0);
+        expect(hi).toBeCloseTo(3**2 + 2**2, 12);  // corner [14,23]
+    }
+    // p directly below the box (within its x range): the min is the vertical
+    // gap, *not* the distance to a corner (which the old version returned)
+    {
+        const [lo, hi] = rootIntervalToDistanceSquaredInterval(box, [12, 15]);
+        expect(lo).toBeCloseTo(5**2, 12);
+        expect(lo).toBeLessThan(2**2 + 5**2);  // nearest corner [10,20] or [14,20]
+        expect(hi).toBeCloseTo(2**2 + 8**2, 12);
+    }
+    // p diagonally away from the box: the min and max are both at corners
+    {
+        const [lo, hi] = rootIntervalToDistanceSquaredInterval(box, [7, 16]);
+        expect(lo).toBeCloseTo(3**2 + 4**2, 12);  // corner [10,20]
+        expect(hi).toBeCloseTo(7**2 + 7**2, 12);  // corner [14,23]
+    }
+    // p on the box's boundary
+    {
+        const [lo] = rootIntervalToDistanceSquaredInterval(box, [10, 21.5]);
+        expect(lo).toBe(0);
+    }
+});
+
+
+test('rootIntervalToDistanceSquaredInterval - encloses the distances to a curve piece', function() {
+    // the box engulfs the piece, so the squared distance from `p` to every
+    // point of the piece must lie within the returned interval
+    const curves = [
+        [[0,0],[30,80],[70,-40],[100,0]],
+        [[1000,2000],[1200,2500],[1800,1900],[2000,2000]],
+        [[-5,3],[4,9],[12,-2]],
+    ];
+    const tRanges: [number, number][] = [[0.1, 0.11], [0.5, 0.5002], [0.9, 0.95], [0, 1]];
+    const offsets = [[0,0],[0.3,-0.2],[5,0],[0,-7],[40,40],[-1000,1]];
+
+    for (const ps of curves) {
+        for (const ts of tRanges) {
+            const box = getIntervalBox(ps, ts);
+            const mid = evalDeCasteljau(ps, (ts[0]+ts[1])/2);
+            for (const off of offsets) {
+                const p = [mid[0] + off[0], mid[1] + off[1]];
+                const [lo, hi] = rootIntervalToDistanceSquaredInterval(box, p);
+                expect(lo).toBeLessThanOrEqual(hi);
+
+                for (let i=0; i<=50; i++) {
+                    const t = ts[0] + (ts[1]-ts[0])*i/50;
+                    const d = squaredDistanceBetween(p, evalDeCasteljau(ps, t));
+                    expect(d).toBeGreaterThanOrEqual(lo);
+                    expect(d).toBeLessThanOrEqual(hi);
+                }
+            }
+        }
+    }
+});
+
+
+test('rootIntervalToDistanceSquaredInterval - the min is tight (not a corner distance)', function() {
+    // A nearly flat piece of a curve with `p` sitting right above its middle:
+    // the true minimum distance is about the vertical gap, while the
+    // distance to the nearest box corner is much larger.
+    const ps = [[0,0],[33,0.2],[66,0.2],[100,0]];
+    const ts: [number, number] = [0.2, 0.8];
+    const box = getIntervalBox(ps, ts);
+    const p = [50, 10];
+
+    const [lo] = rootIntervalToDistanceSquaredInterval(box, p);
+    const nearestCornerSq = Math.min(
+        ...[[box[0][0],box[0][1]],[box[0][0],box[1][1]],[box[1][0],box[0][1]],[box[1][0],box[1][1]]]
+            .map(c => squaredDistanceBetween(p, c))
+    );
+    // the gap is ~10 so lo ~ 100, while the corners are ~30 away horizontally
+    expect(lo).toBeLessThan(11**2);
+    expect(nearestCornerSq).toBeGreaterThan(30**2);
+});

package/__tests__/cp-node/circle-identity.spec.ts

@@ -0,0 +1,56 @@
+import { expect, test } from '@jest/globals';
+import type { CpNode } from '../../src/cp-node/cp-node.js';
+import type { Circle } from '../../src/geometry/circle.js';
+import { getPathsFromStr } from 'flo-boolean';
+import { findMats } from '../../src/find-mat/find-mats.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';
+import { toStringifyable } from '../../src/cp-node/stringification/to-stringifyable.js';
+import { fromStringifyable } from '../../src/cp-node/stringification/from-stringifyable.js';
+
+
+/**
+ * Checks the `PointOnShape.circle` invariant: one `Circle` object per
+ * on-circle ring, shared by all of the ring's `CpNode`s and by no other ring.
+ */
+function checkCircleIdentity(cpStart: CpNode): void {
+    const cpNodes = getAllOnLoop_ByLoop(cpStart).flat();
+
+    const ringOfCircle = new Map<Circle, CpNode[]>();
+    const seen = new Set<CpNode>();
+    for (const cpNode of cpNodes) {
+        if (seen.has(cpNode)) { continue; }
+
+        const ring = getAllOnCircle(cpNode);
+        const { circle } = cpNode.pointOnShape;
+        for (const cp of ring) {
+            seen.add(cp);
+            // shared by all of the ring's CpNodes
+            expect(cp.pointOnShape.circle).toBe(circle);
+        }
+
+        // ...and by no other ring
+        expect(ringOfCircle.has(circle)).toBe(false);
+        ringOfCircle.set(circle, ring);
+    }
+}
+
+
+test('one `Circle` object per on-circle ring (incl. hole closers)', function() {
+    // a square with a square hole - forces hole-closing 2-prongs
+    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, {})[0];
+
+    // the test is only meaningful if hole closers were actually created
+    const cpNodes = getAllOnLoop_ByLoop(cpNode).flat();
+    expect(cpNodes.some(cp => cp.holeCloserTwin !== undefined)).toBe(true);
+
+    checkCircleIdentity(cpNode);
+
+    // ...and the invariant survives a (JSON) stringification round trip
+    const json = JSON.stringify(toStringifyable(cpNode));
+    checkCircleIdentity(fromStringifyable(JSON.parse(json)));
+});

package/__tests__/cp-node/fs/get-all-on-loop-by-loop.spec.ts

@@ -0,0 +1,55 @@
+import { expect, test } from '@jest/globals';
+import { getAllOnLoop_ByLoop } from '../../../src/cp-node/fs/get-all-on-loop-by-loop.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('getAllOnLoop_ByLoop - single loop', function() {
+    const { cpNode } = getMats1()[0];
+    const all = getAllOnLoop(cpNode);
+
+    for (const cp of all) {
+        const cpNodess = getAllOnLoop_ByLoop(cp);
+        expect(cpNodess.length).toBe(1);
+        expect(cpNodess[0].length).toBe(all.length);
+        expect(cpNodess[0][0]).toBe(cp);
+        // same nodes, in the same (boundary) order
+        const expected = getAllOnLoop(cp);
+        expect(cpNodess[0].every((c, i) => c === expected[i])).toBe(true);
+    }
+});
+
+
+test('getAllOnLoop_ByLoop - two loops joined by hole closers', function() {
+    const { cpNode } = getMatsWithHole()[0];
+    // `getAllOnLoop` follows `next` across the hole closers and so visits
+    // the nodes of *both* loops
+    const all = getAllOnLoop(cpNode);
+    const loops = new Set(all.map(cp => cp.pointOnShape.curve.loop));
+    expect(loops.size).toBe(2);
+
+    // From *every* start node (in particular from hole closers, which used
+    // to drop the other loop) every node must be returned exactly once,
+    // grouped by loop.
+    for (const cp of all) {
+        const cpNodess = getAllOnLoop_ByLoop(cp);
+
+        expect(cpNodess.length).toBe(2);
+        const flat = cpNodess.flat();
+        expect(flat.length).toBe(all.length);
+        expect(new Set(flat).size).toBe(all.length);
+        for (const c of all) { expect(flat.includes(c)).toBe(true); }
+
+        // the first group starts at the given node
+        expect(cpNodess[0][0]).toBe(cp);
+
+        // each group is on a single loop and the groups are on different ones
+        const groupLoops = cpNodess.map(cpNodes => {
+            const loop = cpNodes[0].pointOnShape.curve.loop;
+            for (const c of cpNodes) { expect(c.pointOnShape.curve.loop).toBe(loop); }
+            return loop;
+        });
+        expect(new Set(groupLoops).size).toBe(2);
+    }
+});

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

@@ -1,7 +1,43 @@
 import { expect, test } from '@jest/globals';
 import { getInitialDegAngleBetweenMatCurves } from '../../../src/cp-node/fs/get-angle-between-mat-curves.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('getInitialDegAngleBetweenMatCurves [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getInitialDegAngleBetweenMatCurves', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+    const angle = (id1: number, id2: number) =>
+        getInitialDegAngleBetweenMatCurves(byId(id1), byId(id2));
+
+    // The angle is between the *initial* tangents of the MAT edges leaving
+    // the two `CpNode`s, folded into [0,90] (it is `|asin(cross)|`).
+    const nonTerminating = getAllOnLoop(cpNode).filter(cp => !isTerminating(cp));
+    for (const a of nonTerminating) {
+        expect(getInitialDegAngleBetweenMatCurves(a, a)).toBeCloseTo(0, 10);
+        for (const b of nonTerminating) {
+            const ab = getInitialDegAngleBetweenMatCurves(a, b);
+            const ba = getInitialDegAngleBetweenMatCurves(b, a);
+            expect(ab).toBeCloseTo(ba, 10);
+            expect(ab).toBeGreaterThanOrEqual(0);
+            expect(ab).toBeLessThanOrEqual(90);
+        }
+    }
+
+    // The 3-prong with center [81.5,18.5] (ids 147, 145, 146) has contact
+    // points [46,18.5], [81.5,54] and [117,18.5]; its edges leave along the
+    // bisectors (-1,1), (1,1) and (0,-1).
+    expect(angle(147, 145)).toBeCloseTo(90, 8);
+    expect(angle(147, 146)).toBeCloseTo(45, 8);  // 135 degrees folded into [0,90]
+    expect(angle(145, 146)).toBeCloseTo(45, 8);
+
+    // The medial axis is smooth through a 2-prong: the edge leaving the sharp
+    // corner [24,8] (id 1) and the edge continuing from the 2-prong it reaches
+    // (id 10) share a tangent.
+    expect(angle(1, 10)).toBeCloseTo(0, 6);
+    // ...and the two edges leaving a 2-prong (ids 10 and 11) are exactly
+    // opposite, which also folds to 0.
+    expect(angle(10, 11)).toBeCloseTo(0, 6);
 });

package/__tests__/cp-node/fs/get-boundary-bezier-parts-to-next.spec.ts

@@ -1,7 +1,91 @@
 import { expect, test } from '@jest/globals';
+import { fromTo, totalLength } from 'flo-bezier3';
 import { getBoundaryBezierPartsToNext } from '../../../src/cp-node/fs/get-boundary-bezier-parts-to-next.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 { getMats1 } from '../../get-mats1.js';
+import { getMatsWithHole } from '../../get-mats-with-hole.js';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
 
-test.skip('getBoundaryBezierPartsToNext [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getBoundaryBezierPartsToNext', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    {
+        // id 1 is at the end (t=1) of curve 0 and its next (id 10) at the end
+        // of curve 1 - so a degenerate piece of curve 0 and all of curve 1.
+        const cp = byId(1);
+        const parts = getBoundaryBezierPartsToNext(cp);
+        expect(parts.length).toBe(2);
+        expect(parts[0].ps).toBe(cp.pointOnShape.curve.ps);
+        expect(parts[0].ts).toEqual([1, 1]);
+        expect(parts[1].ps).toBe(cp.next.pointOnShape.curve.ps);
+        expect(parts[1].ts).toEqual([0, 1]);
+    }
+    {
+        // id 147 and its next (id 2) are both on curve 2 - a single piece.
+        const cp = byId(147);
+        const parts = getBoundaryBezierPartsToNext(cp);
+        expect(parts.length).toBe(1);
+        expect(parts[0].ps).toBe(cp.pointOnShape.curve.ps);
+        expect(parts[0].ts).toEqual([cp.pointOnShape.t, 1]);
+        expect(parts[0].ts[0]).toBeCloseTo(0.2282608695652173, 15);
+    }
+    {
+        // ids 150 -> 143 are both strictly inside curve 0
+        const cp = byId(150);
+        const parts = getBoundaryBezierPartsToNext(cp);
+        expect(parts.length).toBe(1);
+        expect(parts[0].ts).toEqual([cp.pointOnShape.t, cp.next.pointOnShape.t]);
+        expect(parts[0].ts[0]).toBeLessThan(parts[0].ts[1]);
+    }
+
+    // Structural invariants for every node: starts at the (curve,t) of this
+    // node, ends at the (curve,t) of the next node, skipped curves are taken
+    // whole, and the parameter intervals are ordered.
+    let total = 0;
+    for (const cp of getAllOnLoop(cpNode)) {
+        const parts = getBoundaryBezierPartsToNext(cp);
+        expect(parts.length).toBeGreaterThan(0);
+
+        const first = parts[0];
+        const last = parts[parts.length-1];
+        expect(first.ps).toBe(cp.pointOnShape.curve.ps);
+        expect(first.ts[0]).toBe(cp.pointOnShape.t);
+        expect(last.ps).toBe(cp.next.pointOnShape.curve.ps);
+        expect(last.ts[1]).toBe(cp.next.pointOnShape.t);
+        for (let i=1; i<parts.length; i++) {
+            expect(parts[i].ts[0]).toBe(0);
+            if (i < parts.length-1) { expect(parts[i].ts[1]).toBe(1); }
+        }
+        if (parts.length > 1) { expect(first.ts[1]).toBe(1); }
+        for (const { ts } of parts) { expect(ts[0]).toBeLessThanOrEqual(ts[1]); }
+
+        total += parts.reduce((s, bp) => s + totalLength(fromTo(bp.ps, bp.ts[0], bp.ts[1])), 0);
+    }
+
+    // ...and all the pieces together cover the boundary exactly once.
+    const perimeter = cpNode.pointOnShape.curve.loop.curves
+        .reduce((s, curve) => s + totalLength(curve.ps), 0);
+    expect(total).toBeCloseTo(perimeter, 8);
+});
+
+
+test('getBoundaryBezierPartsToNext - hole closers', function() {
+    const { cpNode } = getMatsWithHole()[0];
+    const cpNodes = getAllOnLoop_ByLoop(cpNode).flat();
+
+    // `[]` if and only if the next `CpNode` is on another loop
+    let crossings = 0;
+    for (const cp of cpNodes) {
+        const crossesLoops = cp.pointOnShape.curve.loop !== cp.next.pointOnShape.curve.loop;
+        const parts = getBoundaryBezierPartsToNext(cp);
+        expect(parts.length === 0).toBe(crossesLoops);
+        if (crossesLoops) {
+            crossings++;
+            expect(cp.isHoleClosing).toBe(true);
+        }
+    }
+    expect(crossings).toBeGreaterThan(0);
 });

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

@@ -1,7 +1,72 @@
 import { expect, test } from '@jest/globals';
+import { totalLength } from 'flo-bezier3';
 import { getBoundaryBeziersBetween } from '../../../src/cp-node/fs/get-boundary-beziers-between.js';
+import { getBoundaryBeziersToNext } from '../../../src/cp-node/fs/get-boundary-beziers-to-next.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';
+import { cpNodesByIdOn } from '../../helpers/cp-node-by-id.js';
+import { expectBeziersConnected, expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getBoundaryBeziersBetween [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+const length = (pss: number[][][]) => pss.reduce((s, ps) => s + totalLength(ps), 0);
+
+
+test('getBoundaryBeziersBetween', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    // to the next node: same as `getBoundaryBeziersToNext`
+    for (const cp of getAllOnLoop(cpNode)) {
+        const { pss, hasHoleCloser } = getBoundaryBeziersBetween(cp, cp.next);
+        expect(pss).toEqual(getBoundaryBeziersToNext(cp));
+        expect(hasHoleCloser).toBe(false);
+    }
+
+    {
+        // from [46,18.5] (id 147) around two corners to [117,54] (id 4):
+        // 35.5 up, 71 across - the piece leaving the end node is not included
+        const { pss, hasHoleCloser } = getBoundaryBeziersBetween(byId(147), byId(4));
+        expect(hasHoleCloser).toBe(false);
+        expectPointClose(pss[0][0], [46,18.5]);
+        expectPointClose(pss[pss.length-1][1], [117,54]);
+        expectBeziersConnected(pss);
+        expect(length(pss)).toBeCloseTo(35.5 + 71, 8);
+    }
+
+    // equal start and end: everything or nothing
+    const perimeter = cpNode.pointOnShape.curve.loop.curves
+        .reduce((s, curve) => s + totalLength(curve.ps), 0);
+    {
+        const { pss } = getBoundaryBeziersBetween(cpNode, cpNode);
+        expect(length(pss)).toBeCloseTo(perimeter, 8);
+        expectBeziersConnected(pss);
+        expectPointClose(pss[pss.length-1][1], pss[0][0]);
+    }
+    {
+        const { pss } = getBoundaryBeziersBetween(cpNode, cpNode, true);
+        expect(length(pss)).toBeCloseTo(perimeter, 8);
+    }
+    {
+        const { pss, hasHoleCloser } = getBoundaryBeziersBetween(cpNode, cpNode, false);
+        expect(pss).toEqual([]);
+        expect(hasHoleCloser).toBe(false);
+    }
+});
+
+
+test('getBoundaryBeziersBetween - hole closers', function() {
+    const { cpNode } = getMatsWithHole()[0];
+
+    // going all the way round passes the hole closers
+    const { hasHoleCloser } = getBoundaryBeziersBetween(cpNode, cpNode);
+    expect(hasHoleCloser).toBe(true);
+
+    // ...but a stretch without any hole closer reports none
+    const cps = getAllOnLoop(cpNode);
+    const i = cps.findIndex((cp, i) =>
+        !cp.isHoleClosing && !cps[(i+1) % cps.length].isHoleClosing);
+    expect(i).toBeGreaterThanOrEqual(0);
+    const cp = cps[i];
+    expect(getBoundaryBeziersBetween(cp, cp.next.next).hasHoleCloser).toBe(false);
 });

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

@@ -1,7 +1,45 @@
 import { expect, test } from '@jest/globals';
 import { getBoundaryBeziersToNext } from '../../../src/cp-node/fs/get-boundary-beziers-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 { expectBezierClose, expectBeziersConnected, expectPointClose } from '../../helpers/expect-point-close.js';
 
-test.skip('getBoundaryBeziersToNext [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getBoundaryBeziersToNext', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    {
+        // from the corner [24,8] (end of curve 0) to [46,8] (end of curve 1)
+        const pss = getBoundaryBeziersToNext(byId(1));
+        expect(pss.length).toBe(2);
+        expectBezierClose(pss[0], [[24,8],[24,8]]);  // degenerate rest of curve 0
+        expectBezierClose(pss[1], [[24,8],[46,8]]);  // all of curve 1
+    }
+    {
+        // from [46,18.5] up to the corner [46,54] - part of a single line
+        const pss = getBoundaryBeziersToNext(byId(147));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[46,18.5],[46,54]]);
+    }
+    {
+        // two nodes at the same point (a 1-prong corner) - zero length
+        const pss = getBoundaryBeziersToNext(byId(0));
+        expect(pss.length).toBe(1);
+        expectBezierClose(pss[0], [[24,8],[24,8]]);
+    }
+
+    // For every node the beziers run from the point of this node to that of
+    // the next, joined end to start.
+    for (const cp of getAllOnLoop(cpNode)) {
+        const pss = getBoundaryBeziersToNext(cp);
+        expect(pss.length).toBeGreaterThan(0);
+        expectPointClose(pss[0][0], cp.pointOnShape.p);
+        const last = pss[pss.length-1];
+        expectPointClose(last[last.length-1], cp.next.pointOnShape.p);
+        expectBeziersConnected(pss);
+        // the fixture boundary consists of lines only
+        for (const ps of pss) { expect(ps.length).toBe(2); }
+    }
 });

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

@@ -1,7 +1,24 @@
 import { expect, test } from '@jest/globals';
+import { totalLength } from 'flo-bezier3';
 import { getBoundaryDistanceToNext } from '../../../src/cp-node/fs/get-boundary-distance-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';
 
-test.skip('getBoundaryDistanceToNext [STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+
+test('getBoundaryDistanceToNext', function() {
+    const { cpNode } = getMats1()[0];
+    const byId = cpNodesByIdOn(cpNode);
+
+    expect(getBoundaryDistanceToNext(byId(1))).toBeCloseTo(22, 10);     // [24,8] -> [46,8]
+    expect(getBoundaryDistanceToNext(byId(147))).toBeCloseTo(35.5, 10); // [46,18.5] -> [46,54]
+    expect(getBoundaryDistanceToNext(byId(144))).toBeCloseTo(10.5, 10); // [46,8] -> [46,18.5] (crosses a corner)
+    expect(getBoundaryDistanceToNext(byId(0))).toBe(0);                 // two nodes at the same corner point
+
+    // the distances around the loop add up to the perimeter
+    const perimeter = cpNode.pointOnShape.curve.loop.curves
+        .reduce((s, curve) => s + totalLength(curve.ps), 0);
+    const total = getAllOnLoop(cpNode)
+        .reduce((s, cp) => s + getBoundaryDistanceToNext(cp), 0);
+    expect(total).toBeCloseTo(perimeter, 8);
 });