flo-mat 4.1.4 → 5.0.1

package/__tests__/utils/get-beziers-from-tangents.spec.ts

@@ -0,0 +1,142 @@
+import { expect, test } from '@jest/globals';
+import { cross, distanceBetween, fromTo, toUnitVector, translate } from 'flo-vector2d';
+import { getBeziersFromTangents } from '../../src/utils/get-beziers-from-tangents.js';
+import { expectBezierClose, expectBeziersConnected, expectPointClose } from '../helpers/expect-point-close.js';
+
+
+const startTan = (ps: number[][]) => toUnitVector(fromTo(ps[0], ps[1]));
+const endTan   = (ps: number[][]) => toUnitVector(fromTo(ps[ps.length-2], ps[ps.length-1]));
+/** tangent line at `p` with direction `angle` radians from the x-axis (and the given length) */
+const line = (p: number[], angle: number, length = 1) =>
+    [p, translate(p, [length*Math.cos(angle), length*Math.sin(angle)])];
+
+
+/** The invariants of a twisted result: two quadratics, exact ends, smooth join. */
+function checkTwoQuadratics(pss: number[][][], p0: number[], p1: number[], d0: number[], d1: number[]) {
+    expect(pss.length).toBe(2);
+    expect(pss[0].length).toBe(3);
+    expect(pss[1].length).toBe(3);
+
+    // endpoints and end tangents are exact
+    expect(pss[0][0]).toBe(p0);
+    expect(pss[1][2]).toBe(p1);
+    expect(cross(startTan(pss[0]), toUnitVector(d0))).toBeCloseTo(0, 12);
+    expect(cross(endTan(pss[1]), toUnitVector(d1))).toBeCloseTo(0, 12);
+
+    // joined, and smoothly so
+    expectBeziersConnected(pss, 12);
+    expect(cross(endTan(pss[0]), startTan(pss[1]))).toBeCloseTo(0, 12);
+
+    // control points lie on the tangent lines a quarter chord away from the
+    // endpoints, towards the other endpoint
+    const chord = distanceBetween(p0, p1);
+    expect(distanceBetween(p0, pss[0][1])).toBeCloseTo(chord/4, 9);
+    expect(distanceBetween(p1, pss[1][1])).toBeCloseTo(chord/4, 9);
+    expect(distanceBetween(pss[0][1], p1)).toBeLessThan(distanceBetween(p0, p1) + chord/4);
+    expect(distanceBetween(pss[1][1], p0)).toBeLessThan(distanceBetween(p0, p1) + chord/4);
+}
+
+
+test('getBeziersFromTangents - not twisted: a single quadratic', function() {
+    // tangents (1,1) at [0,0] and (1,-1) at [10,0] meet at [5,5]
+    const pss = getBeziersFromTangents(line([0,0], Math.PI/4), line([10,0], -Math.PI/4));
+    expect(pss.length).toBe(1);
+    expectBezierClose(pss[0], [[0,0],[5,5],[10,0]]);
+});
+
+
+test('getBeziersFromTangents - collinear: a line', function() {
+    const pss = getBeziersFromTangents(line([0,0], 0), line([10,0], 0));
+    expect(pss).toEqual([[[0,0],[10,0]]]);
+});
+
+
+test('getBeziersFromTangents - collinear with the intersection landing on an endpoint: a line', function() {
+    // From the `getMats1` fixture (edge 3 -> 145): both tangents point along
+    // the chord [46,54] -> [81.5,18.5] but numerically the lines intersect
+    // exactly at the end point. This must not produce a degenerate quadratic
+    // `[p0, p1, p1]` (with a zero end tangent) but a line.
+    const s = Math.SQRT1_2;
+    const l0 = [[46,54], [46+s, 54-s]];
+    const l1 = [[81.5,18.5], [81.5-s, 18.5+s]];
+    const pss = getBeziersFromTangents(l0, l1);
+    expect(pss.length).toBe(1);
+    expect(pss[0].length).toBe(2);
+    expectPointClose(pss[0][0], [46,54]);
+    expectPointClose(pss[0][1], [81.5,18.5]);
+});
+
+
+test('getBeziersFromTangents - twisted (inflection): two quadratics', function() {
+    // tangents tilted to the *same* side at both ends force an S-shape
+    const cases = [
+        { p0: [0,0], p1: [10,0], a0:  0.006, a1:  0.006 },  // symmetric
+        { p0: [0,0], p1: [10,0], a0:  0.008, a1:  0.001 },  // asymmetric
+        { p0: [3,7], p1: [9,2],  a0: -0.007, a1: -0.004 },  // rotated chord
+        { p0: [0,0], p1: [10,0], a0:  0.5,   a1:  0.3   },  // strongly twisted
+        { p0: [0,0], p1: [10,0], a0:  Math.PI/2, a1: Math.PI/2 },  // tangents perpendicular to the chord
+    ];
+    for (const { p0, p1, a0, a1 } of cases) {
+        const chordAngle = Math.atan2(p1[1]-p0[1], p1[0]-p0[0]);
+        const l0 = line(p0, chordAngle + a0);
+        const l1 = line(p1, chordAngle + a1);
+        const d0 = fromTo(l0[0], l0[1]);
+        const d1 = fromTo(l1[0], l1[1]);
+
+        checkTwoQuadratics(getBeziersFromTangents(l0, l1), p0, p1, d0, d1);
+    }
+});
+
+
+test('getBeziersFromTangents - scale, tangent magnitude and orientation do not matter', function() {
+    const p0 = [0,0], p1 = [10,0];
+    const ref = getBeziersFromTangents(line(p0, 0.006), line(p1, 0.006));
+
+    const expectSame = (pss: number[][][]) => {
+        expect(pss.length).toBe(ref.length);
+        pss.forEach((ps, i) => ps.forEach((p, k) => expectPointClose(p, ref[i][k], 9)));
+    };
+    // tangent magnitude (e.g. an unnormalized bezier derivative)
+    expectSame(getBeziersFromTangents(line(p0, 0.006, 123.4), line(p1, 0.006, 0.001)));
+    // tangent orientation (either direction along the tangent line)
+    expectSame(getBeziersFromTangents(line(p0, 0.006 + Math.PI), line(p1, 0.006)));
+    expectSame(getBeziersFromTangents(line(p0, 0.006), line(p1, 0.006 + Math.PI)));
+    // scale: the same configuration scaled by 1000 (and by 1/1000) gives the
+    // same *kind* of result, scaled
+    for (const s of [1000, 1/1000]) {
+        const pss = getBeziersFromTangents(line([0,0], 0.006), line([10*s,0], 0.006));
+        expect(pss.length).toBe(ref.length);
+        pss.forEach((ps, i) => ps.forEach((p, k) => {
+            expectPointClose(p, [ref[i][k][0]*s, ref[i][k][1]*s], 9);
+        }));
+    }
+});
+
+
+test('getBeziersFromTangents - twisted but within tolerance: a line', function() {
+    // barely twisted (sine of the angle below 2**-16): a straight line will do
+    const pss = getBeziersFromTangents(line([0,0], 1e-6), line([10,0], 1e-6));
+    expect(pss.length).toBe(1);
+    expectBezierClose(pss[0], [[0,0],[10,0]]);
+    // ...at any scale
+    const pss2 = getBeziersFromTangents(line([0,0], 1e-6), line([1e6,0], 1e-6));
+    expect(pss2.length).toBe(1);
+    expect(pss2[0].length).toBe(2);
+    // ...but just above the tolerance it is two quadratics
+    expect(getBeziersFromTangents(line([0,0], 2e-5), line([10,0], 2e-5)).length).toBe(2);
+});
+
+
+test('getBeziersFromTangents - coinciding endpoints: a degenerate line', function() {
+    const p = [46,8];
+    const pss = getBeziersFromTangents([p, [47,8]], [p, [46,9]]);
+    expect(pss).toEqual([[p, p]]);
+    // the same from the two nodes of a 1-prong (identical tangent lines)
+    expect(getBeziersFromTangents([p, [47,9]], [p, [47,9]])).toEqual([[p, p]]);
+});
+
+
+test('getBeziersFromTangents - degenerate tangent: a line', function() {
+    const pss = getBeziersFromTangents([[0,0], [0,0]], line([10,0], 0.3));
+    expect(pss).toEqual([[[0,0],[10,0]]]);
+});