flo-mat 4.1.5 → 5.0.2

package/src/find-3-prong/find-3-prong-for-delta3s.ts

@@ -1,214 +1,197 @@
-import type { CpNode } from '../cp-node/cp-node.js';
-import type { CurvePiece } from '../mat/curve-piece.js';
-import type { ThreeProngInfo } from './three-prong-info.js';
-import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
-import { circumCenter as getCircumCenter, fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
-import { tangent } from 'flo-bezier3';
-import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
-import { getClosestPoints } from './get-closest-points.js';
-import { calcBetterX } from './calc-better-x.js';
-import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
-import { getCorner } from '../corner/get-corner.js';
-import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
-import { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
-import { isSharp } from '../cp-node/fs/is-sharp.js';
-
-const { min, abs, asin } = Math;
-
-
-/**
- * Finds a 3-prong using only the 3 given δs.
- * 
- * @param δs the boundary pieces
- * @param idx δ identifier
- * @param k δs identifier
- * @param curvePiecess
- * @param maxCoordPowerOf2
- * 
- * @internal
- */
-function find3ProngForDelta3s(
-        δs: [CpNode, CpNode][], 
-        idx: number, 
-        k: number,
-        curvePiecess: CurvePiece[][],
-        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
-
-    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
-    const MAX_ITERATIONS = 10;
-
-    const δs_: [[CpNode,CpNode], [CpNode,CpNode], [CpNode,CpNode]] = [
-        δs[0],
-        δs[idx], 
-        δs[δs.length-1]
-    ];
-
-    const curvePieces_: [CurvePiece[], CurvePiece[], CurvePiece[]] = [
-        curvePiecess[0], 
-        curvePiecess[idx], 
-        curvePiecess[δs.length - 1]
-    ];
-
-    const δ3ss: [
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]],
-        [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]]
-    ] = [
-        [δs_[0], δs_[1], δs_[2]],
-        [δs_[1], δs_[2], δs_[0]],
-        [δs_[2], δs_[0], δs_[1]],
-    ];
-
-    const curvePiecess_: [
-        [CurvePiece[], CurvePiece[], CurvePiece[]],
-        [CurvePiece[], CurvePiece[], CurvePiece[]],
-        [CurvePiece[], CurvePiece[], CurvePiece[]]
-    ] = [
-        [curvePieces_[0], curvePieces_[1], curvePieces_[2]],
-        [curvePieces_[1], curvePieces_[2], curvePieces_[0]],
-        [curvePieces_[2], curvePieces_[0], curvePieces_[1]],
-    ]
-
-
-    const δ3s = δ3ss[k];
-    const curvePiece3s = curvePiecess_[k];
-
-    if (isSharp(δ3s[0][0])) { return undefined; }
-
-    //----------------------------
-    // const l1 = curvePiece3s[0].length;
-    // const l2 = curvePiece3s[1].length;
-    // const l3 = curvePiece3s[2].length;
-    // if (l1 === 1 && l2 == 1 && l3 === 1) {
-    //     // console.log('aaa');
-    //     const A = curvePiece3s[0][0].curve.ps;
-    //     const B = curvePiece3s[1][0].curve.ps;
-    //     const C = curvePiece3s[2][0].curve.ps;
-
-    //     console.log(A.length, B.length, C.length);
-    // } else {
-    //     // console.log('bbb');
-    // }
-    //----------------------------
-
-
-    let poss: PrePointOnShape[] = undefined!;
-    let j = 0;  // Safeguard for slow convergence
-    let x = calcInitial3ProngCenter(δ3s, curvePiece3s);
-
-    let tolerance = Infinity;
-    while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
-        j++;
-        
-        poss = getClosestPoints(x, curvePiece3s);
-        if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
-
-            // FUTURE - the code can be cleaned up and sped up a lot if we don't
-            // use this function as is but instead use δs[0] and δs[2] as is
-            // and make δs[1] include all the rest of the beziers around the 
-            // loop. This check, for instance, would be eliminated completely.
-            return undefined;
-        }
-
-        const circumCenter = getCircumCenter(poss.map(x => x.p));
-        const vectorToZeroV = fromTo(x, circumCenter);
-
-        if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
-
-            // FUTURE - the code can be cleaned up and sped up a lot if we don't
-            // use this function as is but instead use δs[0] and δs[2] as is
-            // and make δs[1] include all the rest of the beziers around the 
-            // loop. This check, for instance, would be eliminated completely.
-            return undefined;
-        }
-        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
-        x = upds.newX;
-        poss = upds.newPoss;
-
-        const V = len(vectorToZeroV); // The 'potential'
-        
-        tolerance = abs(V - upds.newV);
-    }
-
-    const radius = (distanceBetween(x, poss[0].p) + 
-                    distanceBetween(x, poss[1].p) + 
-                    distanceBetween(x, poss[2].p)) / 3;
-
-    const circle = { center: x, radius };
-
-    //-------------------------------------------------------------------------
-    // Calculate the unit tangent vector at 3-prong circle points - they should 
-    // be very close to tangent to the boundary piece tangents at those points 
-    // (up to sign). Dull corners is a common special case.
-    //-------------------------------------------------------------------------
-    let totalAngleError = 0;
-    for (let i=0; i<3; i++) {
-        const pos = poss[i];
-        //----------------------------
-        // Tangent of circle at point
-        //----------------------------
-        const v = toUnitVector(fromTo(pos.p, x));
-        const v1 = rotate90Degrees(v);
-        
-        
-        //-----------------------------------
-        // Check if point is on dull crorner
-        //-----------------------------------
-        if (isPosCorner(pos) && getPosCorner$(pos).isDull) {
-            const corner = getCorner(pos.curve.ps, pos.curve.next.ps);
-            const tans = corner.tangents;
-            const perps = tans.map( rotate90Degrees );
-                
-            const angleError1 = asin( cross( perps[0], v ) );
-            const angleError2 = asin( cross( v, perps[1] ) );
-            
-            let angleError = 0;
-            if (angleError1 > 0) { angleError += angleError1; }
-            if (angleError2 > 0) { angleError += angleError2; }
-            
-            totalAngleError += angleError;
-        } else {
-            //---------------------------
-            // Tangent of curve at point
-            //---------------------------
-            const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
-            
-            // Cross is more numerically stable than Vector.dot at angles a
-            // multiple of π **and** is close to the actual angle value
-            // and can thus just be added to cone method of looking at 
-            // tolerance.
-            
-            // Should be close to zero and is close to the actual angle.
-            const cross_ = abs( asin( cross(v1, v2) ) );
-            
-            totalAngleError += cross_;
-        }
-    }
-
-    //-------------------------------------------------------------------------
-    // Calculate radiusDelta, the difference between the radius and the closest
-    // point to the 3-prong. It should be around 0. If not, this is not a good 
-    // candidate for the 3-prong.
-    //-------------------------------------------------------------------------
-    const closestDs = [];
-    for (let i=0; i<curvePiecess.length; i++) {
-        const pos = getCloseBoundaryPointsCertified(
-            curvePiecess[i],
-            x
-        )[0];
-
-        closestDs.push( distanceBetween(pos.p, x) );
-    }
-    const closestD = min(...closestDs);
-    const radiusDelta = abs(radius - closestD);
-
-    // Weights below still need to be optimized.
-    const W1 = 1;
-    const W2 = 1;
-    const error = W1*radiusDelta + W2*totalAngleError;
-
-    return { threeProngInfo: { poss, circle, δ3s }, error };
-}
-
-
-export { find3ProngForDelta3s }
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from '../mat/curve-piece.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import { circumCenter as getCircumCenter, fromTo, len, distanceBetween, toUnitVector, rotate90Degrees, cross } from 'flo-vector2d';
+import { tangent } from 'flo-bezier3';
+import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
+import { getClosestPoints } from './get-closest-points.js';
+import { calcBetterX } from './calc-better-x.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { cullCurvePieces } from '../closest-boundary-point/cull-curve-pieces.js';
+import { getCorner$ } from '../corner/get-corner.js';
+import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
+import { getPosCorner$ } from '../point-on-shape/get-pos-corner.js';
+import { isSharp } from '../cp-node/fs/is-sharp.js';
+
+const { abs, asin } = Math;
+
+
+/**
+ * Finds a 3-prong using only the 3 given δs.
+ * 
+ * @param δs the boundary pieces
+ * @param idx δ identifier
+ * @param k δs identifier
+ * @param curvePiecess the curve pieces of each boundary piece
+ * @param allCurvePieces all of the above flattened into one array
+ * @param maxCoordPowerOf2
+ * 
+ * @internal
+ */
+
+function find3ProngForDelta3s(
+        δs: [CpNode, CpNode][], 
+        idx: number, 
+        k: number,
+        curvePiecess: CurvePiece[][],
+        allCurvePieces: CurvePiece[],
+        maxCoordPowerOf2: number): { error: number, threeProngInfo: ThreeProngInfo } | undefined {
+
+    const TOLERANCE = 2**(maxCoordPowerOf2 - 32);
+    const MAX_ITERATIONS = 10;
+
+    // The three boundary pieces (and their curve pieces) with the first, 
+    // the `idx`th and the last taken, rotated so that the one with index `k`
+    // comes first (the first one is treated specially below).
+    const δs_ = [δs[0], δs[idx], δs[δs.length-1]];
+    const curvePieces_ = [curvePiecess[0], curvePiecess[idx], curvePiecess[δs.length-1]];
+    const r = (i: number) => (k + i) % 3;
+    const δ3s: [[CpNode,CpNode], [CpNode,CpNode], [CpNode,CpNode]] = 
+        [δs_[r(0)], δs_[r(1)], δs_[r(2)]];
+    const curvePiece3s: [CurvePiece[], CurvePiece[], CurvePiece[]] = 
+        [curvePieces_[r(0)], curvePieces_[r(1)], curvePieces_[r(2)]];
+
+    if (isSharp(δ3s[0][0])) { return undefined; }
+
+    //----------------------------
+    // const l1 = curvePiece3s[0].length;
+    // const l2 = curvePiece3s[1].length;
+    // const l3 = curvePiece3s[2].length;
+    // if (l1 === 1 && l2 == 1 && l3 === 1) {
+    //     // console.log('aaa');
+    //     const A = curvePiece3s[0][0].curve.ps;
+    //     const B = curvePiece3s[1][0].curve.ps;
+    //     const C = curvePiece3s[2][0].curve.ps;
+
+    //     console.log(A.length, B.length, C.length);
+    // } else {
+    //     // console.log('bbb');
+    // }
+    //----------------------------
+
+
+    let poss: PrePointOnShape[] = undefined!;
+    let j = 0;  // Safeguard for slow convergence
+    let x = calcInitial3ProngCenter(δ3s, curvePiece3s);
+
+    if (!Number.isFinite(x[0]) || !Number.isFinite(x[1])) {
+
+        // FUTURE - the code can be cleaned up and sped up a lot if we don't
+        // use this function as is but instead use δs[0] and δs[2] as is
+        // and make δs[1] include all the rest of the beziers around the 
+        // loop. This check, for instance, would be eliminated completely.
+        return undefined;
+    }
+
+    // the closest points on the three boundary pieces to the current center
+    poss = getClosestPoints(x, curvePiece3s);
+
+    let tolerance = Infinity;
+    while (tolerance > TOLERANCE && j < MAX_ITERATIONS) { 
+        j++;
+
+
+        const circumCenter = getCircumCenter(poss.map(x => x.p));
+        const vectorToZeroV = fromTo(x, circumCenter);
+
+        if (!Number.isFinite(vectorToZeroV[0]) || !Number.isFinite(vectorToZeroV[1])) {
+
+            // FUTURE - the code can be cleaned up and sped up a lot if we don't
+            // use this function as is but instead use δs[0] and δs[2] as is
+            // and make δs[1] include all the rest of the beziers around the 
+            // loop. This check, for instance, would be eliminated completely.
+            return undefined;
+        }
+        const upds = calcBetterX(curvePiece3s, x, vectorToZeroV);
+        x = upds.newX;
+        // `calcBetterX` already found the closest points at the new center -
+        // use them for the next iteration instead of searching again
+        poss = upds.newPoss;
+
+        const V = len(vectorToZeroV); // The 'potential'
+        
+        tolerance = abs(V - upds.newV);
+    }
+
+    const radius = (distanceBetween(x, poss[0].p) + 
+                    distanceBetween(x, poss[1].p) + 
+                    distanceBetween(x, poss[2].p)) / 3;
+
+    const circle = { center: x, radius };
+
+    //-------------------------------------------------------------------------
+    // Calculate the unit tangent vector at 3-prong circle points - they should 
+    // be very close to tangent to the boundary piece tangents at those points 
+    // (up to sign). Dull corners is a common special case.
+    //-------------------------------------------------------------------------
+    let totalAngleError = 0;
+    for (let i=0; i<3; i++) {
+        const pos = poss[i];
+        //----------------------------
+        // Tangent of circle at point
+        //----------------------------
+        const v = toUnitVector(fromTo(pos.p, x));
+        const v1 = rotate90Degrees(v);
+        
+        
+        //-----------------------------------
+        // Check if point is on dull crorner
+        //-----------------------------------
+        if (isPosCorner(pos) && getPosCorner$(pos).isDull) {
+            const corner = getCorner$(pos.curve.ps, pos.curve.next.ps);
+            const tans = corner.tangents;
+            const perps = tans.map( rotate90Degrees );
+                
+            const angleError1 = asin( cross( perps[0], v ) );
+            const angleError2 = asin( cross( v, perps[1] ) );
+            
+            let angleError = 0;
+            if (angleError1 > 0) { angleError += angleError1; }
+            if (angleError2 > 0) { angleError += angleError2; }
+            
+            totalAngleError += angleError;
+        } else {
+            //---------------------------
+            // Tangent of curve at point
+            //---------------------------
+            const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
+            
+            // Cross is more numerically stable than Vector.dot at angles a
+            // multiple of π **and** is close to the actual angle value
+            // and can thus just be added to cone method of looking at 
+            // tolerance.
+            
+            // Should be close to zero and is close to the actual angle.
+            const cross_ = abs( asin( cross(v1, v2) ) );
+            
+            totalAngleError += cross_;
+        }
+    }
+
+    //-------------------------------------------------------------------------
+    // Calculate radiusDelta, the difference between the radius and the closest
+    // point to the 3-prong. It should be around 0. If not, this is not a good 
+    // candidate for the 3-prong.
+    //-------------------------------------------------------------------------
+    // Only boundary pieces that come within the radius of the center can be
+    // closer than the three touching pieces, so cull against the radius first
+    // (cheap, memoized bounding box tests) and run the (expensive) certified
+    // closest point search once on the survivors only. The touching pieces 
+    // always survive (their distance is about the radius) so the result is
+    // the true closest distance over all the boundary pieces.
+    const nearCurvePieces = cullCurvePieces(allCurvePieces, x, (1 + 2**-20)*radius*radius);
+    const closestPos = getCloseBoundaryPointsCertified(nearCurvePieces, x)[0];
+    const closestD = closestPos === undefined ? radius : distanceBetween(closestPos.p, x);
+    const radiusDelta = abs(radius - closestD);
+
+    // Weights below still need to be optimized.
+    const W1 = 1;
+    const W2 = 1;
+    const error = W1*radiusDelta + W2*totalAngleError;
+
+    return { threeProngInfo: { poss, circle, δ3s }, error };
+}
+
+
+export { find3ProngForDelta3s }

package/src/find-3-prong/find-3-prong.ts

@@ -1,51 +1,54 @@
-import type { CpNode } from '../cp-node/cp-node.js';
-import type { ThreeProngInfo } from './three-prong-info.js';
-import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
-import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
-
-
-/**
- * Find and return a 3-prong from the given boundary piece.
- * 
- * @param δs A boundary piece
- * @param maxCoordPowerOf2 The maximum coordinate power of 2 value used to
- * calculate floating point tolerances.
- * 
- * @internal
- */ 
-function find3Prong(
-        δs: [CpNode, CpNode][],
-        maxCoordPowerOf2: number): ThreeProngInfo {
-
-    // FUTURE if `δs.length > (some threshold (say 4 or 5))` then add two-prongs
-    // to reduced the number of permutations required
-    // if (δs.length > 3) { console.log(δs.length); }
-
-    const curvePiecess = δs.map(getBoundaryPieceBeziers);
-
-    // The best candidate amongst the different 'permutations' of the given δs.
-    let threeProng: ThreeProngInfo;
-
-    let smallestError = Infinity;
-    for (let i=1; i<δs.length - 1; i++) {
-        for (let k=0; k<3; k++) {
-            const r = find3ProngForDelta3s(
-                δs, i, k, curvePiecess, maxCoordPowerOf2
-            );
-
-            if (r === undefined) { continue; }
-
-            const { error, threeProngInfo } = r;
-
-            if (error < smallestError) {
-                smallestError = error;
-                threeProng = threeProngInfo;
-            }
-        }
-    }
-
-    return threeProng!;
-}
-
-
-export { find3Prong }
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { ThreeProngInfo } from './three-prong-info.js';
+import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
+import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
+
+
+/**
+ * Find and return a 3-prong from the given boundary piece.
+ * 
+ * @param δs A boundary piece
+ * @param maxCoordPowerOf2 The maximum coordinate power of 2 value used to
+ * calculate floating point tolerances.
+ * 
+ * @internal
+ */ 
+
+function find3Prong(
+        δs: [CpNode, CpNode][],
+        maxCoordPowerOf2: number): ThreeProngInfo {
+
+    // FUTURE if `δs.length > (some threshold (say 4 or 5))` then add two-prongs
+    // to reduced the number of permutations required
+    // if (δs.length > 3) { console.log(δs.length); }
+
+    const curvePiecess = δs.map(getBoundaryPieceBeziers);
+    // all the curve pieces of all the boundary pieces (for culling against)
+    const allCurvePieces = curvePiecess.flat();
+
+    // The best candidate amongst the different 'permutations' of the given δs.
+    let threeProng: ThreeProngInfo;
+
+    let smallestError = Infinity;
+    for (let i=1; i<δs.length - 1; i++) {
+        for (let k=0; k<3; k++) {
+            const r = find3ProngForDelta3s(
+                δs, i, k, curvePiecess, allCurvePieces, maxCoordPowerOf2
+            );
+
+            if (r === undefined) { continue; }
+
+            const { error, threeProngInfo } = r;
+
+            if (error < smallestError) {
+                smallestError = error;
+                threeProng = threeProngInfo;
+            }
+        }
+    }
+
+    return threeProng!;
+}
+
+
+export { find3Prong }

package/src/find-3-prong/find-and-add-3-prongs.ts

@@ -36,12 +36,31 @@ function findAndAdd3Prongs(
     }
 
     const addedCpNodes: CpNode[][] = [];
+    let maxIterations: number | undefined = undefined;
+    let iterations = 0;
     do {
         if (cpStart === undefined) { continue; }
         const visitedCps = traverseCp(cpStart);
-    
+
         if (visitedCps.length <= 2) { break; }
 
+        // Each added 3-prong splits off a part of the traversed face so the
+        // number of iterations is bounded by the initial face size. If the
+        // face does not shrink (e.g. a geometrically invalid vertex causing the
+        // same 3-prong to be re-inserted again and again) fail loudly instead
+        // of looping forever.
+        if (maxIterations === undefined) {
+            maxIterations = 2*visitedCps.length + 16;
+        }
+        if (++iterations > maxIterations) {
+            const pos = cpStart.pointOnShape;
+            throw new Error(
+                `findAndAdd3Prongs: no convergence after ${iterations} iterations ` +
+                `(face with ${visitedCps.length} vertices, start CpNode id ${cpStart.id} ` +
+                `on curve ${pos.curve.idx} at t = ${pos.t}, radius ${pos.circle.radius})`
+            );
+        }
+
         const { closeBysFor3Prong, cpNodes } = findAndAdd3Prong(meta, visitedCps);
 
         addedCpNodes.push(cpNodes);

package/src/find-mat/create-initial-cp-tree.ts

@@ -41,8 +41,8 @@ function createInitialCpTree(
             const pos1: PointOnShape = { ...ppos, curve,             t: 1, circle, order: -1, order2: 0 };
             const pos2: PointOnShape = { ...ppos, curve: curve.next, t: 0, circle, order: +1, order2: 0 };
 
-            cpNode1 = insertCpNode(true, false, false, cpTree, pos1, cpNode2, undefined, /* unused */ lastInsertId)!;
-            cpNode2 = insertCpNode(true, false, false, cpTree, pos2, cpNode1, undefined, /* unused */ lastInsertId)!;
+            cpNode1 = insertCpNode(true, false, false, cpTree, pos1, cpNode2, undefined, lastInsertId)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, pos2, cpNode1, undefined, lastInsertId)!;
             
             cpNode1.prevOnCircle = cpNode2;
             cpNode2.prevOnCircle = cpNode1;

package/src/find-mat/find-mat.ts

@@ -8,7 +8,7 @@ import type { MatOptions } from './mat-options.js';
 import type { MatMeta } from '../mat/mat-meta.js';
 import { findAndAdd3ProngsOnLoop } from '../find-3-prong/find-and-add-3-prongs-on-loop.js';
 import { createInitialCpTree } from './create-initial-cp-tree.js';
-import { getPartialMeta, addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
+import { addDebugElems, addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './get-meta.js';
 import { getSharpCornersOnLoop } from './get-sharp-corners.js';
 import { getDullCornersOnLoop } from './get-dull-corners-on-loop.js';
 import { findAndAdd2ProngsOnAllLoops } from '../find-2-prong/find-and-add-2-prongs-on-all-loops.js';
@@ -16,7 +16,6 @@ import { getFor2ProngsOnLoop } from './get-for-2-prongs-on-loop.js';
 import { getFor1ProngsOnLoop } from './get-for-1-prongs-on-loop.js';
 import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-closing-2-prongs.js';
 import { getShapeBounds } from '../svg/get-shape-bounds.js';
-import { checkOrdering } from '../debug/functions/check-ordering.js';
 
 
 /**
@@ -34,6 +33,7 @@ function findMat(
         } {
 
     addDebugInfo1();
+    addDebugElems(loops);
 
     const { minBezLength, maxCurviness, maxLength, angleIncrement } = options;
 
@@ -51,10 +51,9 @@ function findMat(
     const lastInsertId = { id: 0 };
     const cpTrees = createInitialCpTree(loops, sharpCornersPerLoop, lastInsertId);
 
-    const _meta = getPartialMeta(loops);
     const meta: MatMeta = {
         maxCoordPowerOf2, squaredDiagonalLength, loops, cpTrees,// pointToCpNode,
-        lastInsertId, ..._meta
+        lastInsertId
     };
 
     let cpNode: CpNode | undefined;
@@ -89,7 +88,6 @@ function findMat(
         if (_debug_.directives.stopAfterThreeProngs) { return { cpNode, meta }; }
     }
 
-    // if (cpNode !== undefined) { checkOrdering(meta, cpNode); }
 
     const mat = { cpNode, meta };
 
@@ -105,4 +103,4 @@ export { findMat }
 
 /** Curvilinear Shape Features (CSFs) */
 // const csfs = getCsfs(meta, minBezLength, loops);
-// const ligatures = getLigatures(meta, csfs);
+// const ligatures = getLigatures(meta, csfs);