flo-mat 4.0.3 → 4.1.0

package/__tests__/find-2-prong/get-medial/dd-get-medial-point-coeffs-same-curve.spec.ts

@@ -0,0 +1,106 @@
+import { expect, test } from '@jest/globals';
+import { squares } from 'squares-rng';
+import { getMedialPointCoeffsBez2_SameCurve, getMedialPointCoeffsBez3_SameCurve } from 'flo-bezier3';
+import { ddGetMedialPointCoeffsBez2_SameCurve } from '../../../src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez2-same-curve.js';
+import { ddGetMedialPointCoeffsBez3_SameCurve } from '../../../src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez3-same-curve.js';
+import { ddNormal } from 'flo-bezier3';
+
+
+function toDdVec(v: number[]): number[][] {
+    return v.map(x => [0, x]);
+}
+
+function ddPolyToDouble(poly: number[][]): number[] {
+    return poly.map(c => c[0] + c[1]);
+}
+
+function normalizedPoly(poly: number[]): number[] {
+    let m = 0;
+    for (const x of poly) {
+        const ax = Math.abs(x);
+        if (ax > m) { m = ax; }
+    }
+
+    if (m === 0) {
+        return poly.slice();
+    }
+
+    return poly.map(x => x / m);
+}
+
+function randomNumberIn01(seed: number): number {
+    return squares(seed) * 2**-32;
+}
+
+function randomSignedValue(seed: number): number {
+    const sign = randomNumberIn01(seed) < 0.5 ? -1 : 1;
+    const exponent = Math.floor(randomNumberIn01(seed + 1) * 61) - 30;
+    const mantissa = 1 + Math.floor(randomNumberIn01(seed + 2) * 2**20);
+
+    return sign * mantissa * 2**exponent;
+}
+
+function randomPoint(seed: number): number[] {
+    return [
+        randomSignedValue(seed),
+        randomSignedValue(seed + 1009)
+    ];
+}
+
+
+test('dd same-curve coefficients match flo-bezier3 double coefficients', function() {
+    const epsMain = [2**16];
+    const epsD = [2**8];
+    const epsH = [2**13];
+    const casesPerOrder = 32;
+    let seed = 246813579;
+
+    for (let i = 0; i < casesPerOrder; i++) {
+        const t = 0.01 + 0.98 * randomNumberIn01(seed); seed += 7;
+
+        const ps2 = [
+            randomPoint(seed),
+            randomPoint(seed + 13),
+            randomPoint(seed + 29)
+        ];
+        seed += 43;
+
+        const n2Dd = ddNormal(ps2, t);
+        let v2 = [n2Dd[0][1], n2Dd[1][1]];
+        if (Math.abs(v2[0]) + Math.abs(v2[1]) < 2**-20) {
+            v2 = [v2[0] + 1, v2[1] - 1];
+        }
+        const v2Dd = toDdVec(v2);
+
+        const coeffs2 = getMedialPointCoeffsBez2_SameCurve(t, v2, ps2);
+        const ddCoeffs2 = ddGetMedialPointCoeffsBez2_SameCurve(t, v2Dd, ps2);
+
+        expect(normalizedPoly(coeffs2.A)).toBeNearly(epsMain, normalizedPoly(ddPolyToDouble(ddCoeffs2.A)));
+        expect(normalizedPoly(coeffs2.B)).toBeNearly(epsMain, normalizedPoly(ddPolyToDouble(ddCoeffs2.B)));
+        expect(normalizedPoly(coeffs2.H)).toBeNearly(epsH, normalizedPoly(ddPolyToDouble(ddCoeffs2.H)));
+
+        const ps3 = [
+            randomPoint(seed),
+            randomPoint(seed + 17),
+            randomPoint(seed + 31),
+            randomPoint(seed + 47)
+        ];
+        seed += 59;
+
+        const n3Dd = ddNormal(ps3, t);
+        let v3 = [n3Dd[0][1], n3Dd[1][1]];
+        if (Math.abs(v3[0]) + Math.abs(v3[1]) < 2**-20) {
+            v3 = [v3[0] + 1, v3[1] - 1];
+        }
+        const v3Dd = toDdVec(v3);
+
+        const coeffs3 = getMedialPointCoeffsBez3_SameCurve(t, v3, ps3);
+        const ddCoeffs3 = ddGetMedialPointCoeffsBez3_SameCurve(t, v3Dd, ps3);
+
+        expect(normalizedPoly(coeffs3.A)).toBeNearly(epsMain, normalizedPoly(ddPolyToDouble(ddCoeffs3.A)));
+        expect(normalizedPoly(coeffs3.B)).toBeNearly(epsMain, normalizedPoly(ddPolyToDouble(ddCoeffs3.B)));
+        expect(normalizedPoly(coeffs3.C)).toBeNearly(epsMain, normalizedPoly(ddPolyToDouble(ddCoeffs3.C)));
+        expect(normalizedPoly(coeffs3.D)).toBeNearly(epsD, normalizedPoly(ddPolyToDouble(ddCoeffs3.D)));
+        expect(normalizedPoly(coeffs3.H)).toBeNearly(epsH, normalizedPoly(ddPolyToDouble(ddCoeffs3.H)));
+    }
+});

package/__tests__/find-2-prong/get-medial/dd-get-medial-point-coeffs.spec.ts

@@ -0,0 +1,73 @@
+import { expect, test } from '@jest/globals';
+import { getMedialPointCoeffs } from 'flo-bezier3';
+import { ddGetMedialPointCoeffs } from '../../../src/get-medial-points/double-double/dd-get-medial-point-coeffs.js';
+import { squares } from 'squares-rng';
+
+
+function toDdVec(v: number[]): number[][] {
+    return v.map(x => [0, x]);
+}
+
+function ddPolyToDouble(poly: number[][]): number[] {
+    return poly.map(c => c[1]);
+}
+
+
+function randomNumberIn01(seed: number): number {
+    return squares(seed) * 2**-32;
+}
+
+function randomSignedValue(seed: number): number {
+    const sign = randomNumberIn01(seed) < 0.5 ? -1 : 1;
+    const exponent = Math.floor(randomNumberIn01(seed + 1) * 81) - 40;
+    const mantissa = 1 + randomNumberIn01(seed + 2);
+
+    return sign * mantissa * 2**exponent;
+}
+
+function randomPoint(seed: number): number[] {
+    return [
+        randomSignedValue(seed),
+        randomSignedValue(seed + 1009)
+    ];
+}
+
+
+test('ddGetMedialPointCoeffs matches flo-bezier3 double coefficients', function() {
+    const ulps = 2**12;
+
+    const cases: { p: number[]; v: number[]; ps: number[][] }[] = [];
+    const casesPerOrder = 24;
+    let seed = 123456789;
+
+    for (let controlPointCount = 1; controlPointCount <= 4; controlPointCount++) {
+        for (let i = 0; i < casesPerOrder; i++) {
+            const p = randomPoint(seed); seed += 11;
+            let v = randomPoint(seed); seed += 11;
+
+            // Keep the direction away from near-zero vectors.
+            if (Math.abs(v[0]) + Math.abs(v[1]) < 2**-20) {
+                v = [v[0] + 1, v[1] - 1];
+            }
+
+            const ps: number[][] = [];
+            for (let j = 0; j < controlPointCount; j++) {
+                ps.push(randomPoint(seed));
+                seed += 13;
+            }
+
+            cases.push({ p, v, ps });
+        }
+    }
+
+    for (const { p, v, ps } of cases) {
+        const coeffs = getMedialPointCoeffs(p, v, ps);
+        const ddCoeffs = ddGetMedialPointCoeffs(toDdVec(p), toDdVec(v), ps);
+
+        expect(coeffs.A).toBeNearly(ulps, ddPolyToDouble(ddCoeffs.A));
+        expect(coeffs.B).toBeNearly(ulps, ddPolyToDouble(ddCoeffs.B));
+        expect(coeffs.C).toBeNearly(ulps, ddPolyToDouble(ddCoeffs.C));
+        expect(coeffs.D).toBeNearly(ulps, ddPolyToDouble(ddCoeffs.D));
+        expect(coeffs.H).toBeNearly(ulps, ddPolyToDouble(ddCoeffs.H));
+    }
+});

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

@@ -11,9 +11,11 @@ import { translate } from 'flo-vector2d';
 test('getClosestPoints', function() {
     const maxPowerOf2 = 11;
     const nnorm = [20.25, 239];
+    const nnormDd = [[0,20.25], [0,239]];
     const ps = [[610, -20], [484, -20], [384, 20.5]];
     const t = 0.25;
     const p = [548.625, -17.46875];
+    const pDd = [[0,548.625], [0,-17.46875]];
     const xO = translate(p, nnorm);//?
     const curve: Curve = {
         idx: 0,
@@ -25,7 +27,8 @@ test('getClosestPoints', function() {
 
     const yPos: PrePointOnShape = {
         isSource: true,
-        p, t, curve
+        p, t, curve,
+        pDd
     };
     const for1Prong = false;
     const angle = 0;
@@ -41,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, yPos, for1Prong, angle, curvePiece);
+    const r = getClosestPoint(maxPowerOf2, nnorm, nnormDd, yPos, for1Prong, angle, curvePiece);
 
     r;//?
 

package/__tests__/helpers/close-to.ts

@@ -1,12 +1,12 @@
 import type { ObjOrArray } from "./obj-or-array.js";
+import { eps } from '../../src/error-analysis/gamma.js';
 
-const { EPSILON: eps, POSITIVE_INFINITY: inf } = Number;
-const abs = Math.abs;
+const { abs } = Math;
 
 
 /**
- * @param ulpsOrEps If a number then 2\*\*1 means last bit, 2\*\*2 means last 2 bits, etc... 
- * else if an array containing a single number then 1 means 1 eps, 2 means 2 eps, etc...
+ * @param ulpsOrEps if a number then 2\*\*1 means last bit, 2\*\*2 means last 2 bits, etc... 
+ * else if an array containing a single number then 1 means 1 `eps`, 2 means 2 `eps`, etc...
  */
 function closeTo(ulpsOrEps: number | number[]) {
     let isUlps = true;
@@ -22,7 +22,7 @@ function closeTo(ulpsOrEps: number | number[]) {
         if (typeof expected === 'number') {
             if (typeof actual !== 'number') { return false; }
             const actual_ = actual as number;
-            if (expected === inf) { return actual_ === inf; }
+            if (expected === Infinity) { return actual_ === Infinity; }
             const error = abs((isUlps ? expected : 1)*(ulpsOrEps as number)*eps);
             
             return (

package/__tests__/specific-cases/load-svg/load-svg.ts

@@ -0,0 +1,30 @@
+import * as cheerio from 'cheerio';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+
+async function loadSvgs(
+        pathToSvg: string) {
+
+    const absolutePath = resolve(process.cwd(), '__tests__', 'specific-cases', pathToSvg);
+    const data = await readFile(absolutePath, 'utf8');
+
+    const $ = cheerio.load(data, { xmlMode : true });
+
+    const $svgs = $('glyph');
+
+    const svgs: { name: string; d: string; }[] = [];
+    for (let i=0; i<$svgs.length; i++) {
+        const $svg = $svgs[i];
+        const attribs = $svg.attribs;
+        svgs.push({
+            name: attribs["glyph-name"],
+            d: attribs.d
+        })
+    }
+
+    return svgs;
+}
+
+
+export { loadSvgs }

package/__tests__/specific-cases/specific-cases.spec.ts

@@ -1,6 +1,170 @@
-import { expect, test } from '@jest/globals';
+import { describe, expect, test } from '@jest/globals';
+import { reconstructFromMats } from '../../src/reconstruct-from-mat/reconstruct-from-mat.js';
+import { findMats } from '../../src/find-mat/find-mats.js';
+import { loadSvgs } from './load-svg/load-svg.js';
+import { getPathsFromStr, ddGetShapeArea, simplifyPaths } from 'flo-boolean';
+import { sum } from '../../src/utils/sum.js';
+import { Mat } from '../../src/mat/mat.js';
 
-test.skip('[STUB]', () => {
-    // TODO: implement test
-    expect(true).toBe(true);
+const { abs, max, sqrt } = Math;
+
+
+const MIN_NUM_ACCURATE_BITS_SQRT_AREA = 14;
+const MIN_NUM_ACCURATE_BITS_RADIUS = 20;
+
+
+type TestCase = {
+    filename: string;
+    svgNames: string[];
+}
+
+
+const testCaseSvgs = [
+    ".notdef", "woodland", "exclam", "testD", "testL", "testO",
+    "testComplex", "ampersand", "testComplexish", "quotesingle", "parenleft", "parenright",
+    "asterisk", "plus", "comma", "hyphen", "period", "slash", "zero", "one", "two",
+    "three", "four", "five", "six", "seven", "eight", "nine", "colon", "semicolon",
+    "less", "equal", "greater", "question", "at", "A", "B", "C", "D", "E2",
+    "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "T2",
+    "U", "V", "W", "X", "Y", "Z", "bracketleft", "backslash", "bracketright", "asciicircum",
+    "underscore", "grave", "a", "b", "c", "d", "e", "f", "g", "h2", "h", "i", "j",
+    "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
+    "x", "y", "z", "braceleft", "bar", "braceright", "asciitilde", "Agrave", "Aacute",
+    "Acircumflex", "Atilde", "Adieresis", "Aring", "AE", "Ccedilla", "Eth",
+
+    "3",
+    // "AA",   // boolean
+    // "aaa",  // boolean
+    "ae", "exclammm", "MM", "Mt", "Mt2", "Mt3", "Mt4", "Mt5",
+    "Mth", "notdef", "onehalf", "yen", "ant", "arab",
+    // "BBB",
+    // "bb",
+    "bump_tube1",
+    // "bump_tube2",
+    // "china",
+    "china1", "circle_in_circle", "circle_in_square", "concave_poly",
+    "EEE", "fff", "gecko", "hart",
+    // "hat",
+    "A-2", "B-2",
+    "CCC", "DDD", "E-2", "holepole", "holy_poly", "intersecting", "intersecting1",
+    // "intersecting2",
+    "koldat", "koldat14", "koldat15", "koldat16", "koldat17", "koldat18",
+    "koldat19", "koldat2", "koldat20", "koldat21", "koldat22", "koldat23", "koldat24", "koldat25",
+    "koldat26", "koldat3", "koldat4",
+    // "koldat51",  // just reconstruct that's a bit off
+    "koldat52", "koldat53", "koldat54",
+    "koldat55", "koldat56", "koldat57", "koldat58", "koldat59",
+    // "koldat6",
+    "koldat60", "koldat61",
+    "koldat62", "koldat63", "koldat64", "koldat7", "Lamda",
+    "lb",
+    "matthew",
+    "new1",
+    "new2", "new3", "noobd3v1", "noobd3v2", "OO", "PP", "p1", "p2",
+    "p3", "p4", "p5", "play1", "play2",
+    // "play3",
+    "l1", "l2", "poly", "poly-04",
+    "poly-11", "poly-12", "poly-121",
+    // "quad_blob",
+    "ra", "SSS", "simple",
+    // "so copy",
+    "so", "square", "square_in_circle", "square_in_square",
+    // "TTT",
+    "T2",
+    "geck1", "t4", "test1", "test2", "test3", "test4", "tt", "two_hole"
+]
+
+test('Should correctly reconstruct original shape from medial axis for specific test cases', async function() {
+    const testCases: TestCase[] = [
+        {
+            filename: 'achispado',
+            svgNames: testCaseSvgs
+            // svgNames: ['percent']
+        }
+    ];
+
+    for (const testCase of testCases) {
+        await testIt(testCase);
+    }
+
+
+    async function testIt(
+            testCase: TestCase) {
+
+        const { filename, svgNames } = testCase;
+
+        const svgs = await loadSvgs(`./test-svgs/${filename}.svg`);
+
+        for (const svgName of svgNames) {
+            const pathStr = svgs.find(glyph => glyph.name === svgName)!.d;
+
+            const bezierLoops = getPathsFromStr(pathStr);
+
+            const loopss = simplifyPaths(bezierLoops, undefined, { forceOrientationNegative: true });
+
+            let mats: Mat[];
+            try {
+                mats = findMats(bezierLoops, {
+                    applySat: false,
+                    simplify: false,
+                    satScale: 1.01,
+                    maxCurviness: 0.25,
+                    maxLength: 40,
+                    angleIncrement: 15,
+                    // simplifyTolerance: 2**-5
+                    // minBezLength-\ 
+                });
+            } catch (e) {
+                console.log(`Unable to find MATs for ${svgName}`)
+                throw e;
+            }
+
+            const maxPO2 = max(...mats.map(mat => mat.meta.maxCoordPowerOf2));
+
+            const areass = loopss.map(loops => {
+                const areas = loops.map(loop => ddGetShapeArea(loop.beziers)[1]);
+                return areas;
+            });
+
+            const piecesss = reconstructFromMats(mats, MIN_NUM_ACCURATE_BITS_RADIUS);
+
+            const areass_ = piecesss.map(piecess => {
+                return piecess.map(loop => {
+                    return ddGetShapeArea(loop)[1];
+                });
+            });
+
+            checkAreas(maxPO2, svgName, areass, areass_);
+        }
+    }
 });
+
+
+function checkAreas(
+        maxPO2: number,
+        svgName: string,
+        areass: number[][],
+        areass_: number[][]) {
+
+    if (areass.length !== areass_.length) {
+        throw new Error('number of areas mismatch')
+    }
+
+    const areas = areass.map(sum);
+    const areas_ = areass_.map(sum);
+
+    const tol = 2**(maxPO2 - MIN_NUM_ACCURATE_BITS_SQRT_AREA);
+
+    for (let i=0; i<areas.length; i++) {
+        const area = areas[i];
+        const area_ = areas_[i];
+
+        // area;//?
+        // area_;//?
+        const err = sqrt(abs(area)) - sqrt(abs(area_));
+
+        if (err > tol) {
+            throw new Error(`Areas mismatch (${svgName}), area idx ${i}, found: sqrt(area): ${sqrt(abs(area))} vs ${sqrt(abs(area_))}, err: ${err}, tol: ${tol}`);
+        }
+    }
+}