flo-mat 2.0.4 → 3.0.0

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

@@ -0,0 +1,89 @@
+/** @internal */
+declare const _debug_: Debug; 
+
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Debug } from '../debug/debug.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
+import { Mat } from '../mat/mat.js';
+import { findAndAddAll3Prongs } from '../find-3-prong.ts/find-and-add-all-3-prongs.js';
+import { createInitialCpGraph } from './create-initial-cp-graph.js';
+import { addDebugInfo1, addDebugInfo2, addDebugInfo3, addDebugInfo4 } from './add-debug-info.js';
+import { getSharpCornersOnLoop } from './get-sharp-corners.js';
+import { getDullCornersOnLoop } from './get-dull-corners.js';
+import { findAndAdd2ProngsOnAllPaths } from '../find-2-prong/find-and-add-2-prongs-on-all-paths.js';
+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';
+
+
+/**
+ * @internal
+ * Find the MAT of the given loops.
+ * @param loops The loops (that as a precondition must be ordered from highest 
+ * (i.e. smallest y-value) topmost point loops to lowest)
+ */
+function findMat(
+        loops: Loop[], 
+        minBezLength: number,
+        maxCurviness: number,
+        maxLength: number,
+        maxCoordinate: number): Mat {
+
+    addDebugInfo1(loops);
+        
+    const getSharpCornersOnLoop_ = getSharpCornersOnLoop(minBezLength);
+    const getDullCornersOnLoop_ = getDullCornersOnLoop(minBezLength);
+    const sharpCornersPerLoop = loops.map(getSharpCornersOnLoop_);
+    const dullCornersPerLoop = loops.map(getDullCornersOnLoop_);
+
+    const cpTrees: Map<Loop, LlRbTree<CpNode>> = new Map();
+    createInitialCpGraph(loops, cpTrees, sharpCornersPerLoop);
+
+    findAndAddHoleClosing2Prongs(loops, cpTrees, maxCoordinate);
+
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterHoleClosers) { return undefined!; }
+    }
+    addDebugInfo2();
+
+    const for1ProngsPerLoop = loops.map(
+        getFor1ProngsOnLoop(minBezLength)
+    );
+    const for2ProngsPerLoop = loops.map(
+        getFor2ProngsOnLoop(minBezLength, maxCurviness, maxLength)
+    );
+
+    let cpNode: CpNode | undefined;
+    cpNode = findAndAdd2ProngsOnAllPaths(
+        cpNode, loops, cpTrees, dullCornersPerLoop, maxCoordinate, false
+    );
+    cpNode = findAndAdd2ProngsOnAllPaths(
+        cpNode, loops, cpTrees, for1ProngsPerLoop, maxCoordinate, true
+    );
+    cpNode = findAndAdd2ProngsOnAllPaths(
+        cpNode, loops, cpTrees, for2ProngsPerLoop, maxCoordinate, false
+    );
+
+    addDebugInfo3();
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterTwoProngs) { return undefined!; }
+    }
+
+    if (cpNode === undefined) { return undefined!; }
+
+    findAndAddAll3Prongs(cpTrees, cpNode, maxCoordinate);
+
+    if (typeof _debug_ !== 'undefined') {
+        if (_debug_.directives.stopAfterThreeProngs) { return undefined!; }
+    }
+
+    const mat = { cpNode, cpTrees };
+
+    addDebugInfo4(mat);
+
+    return mat;
+}
+
+
+export { findMat }

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

@@ -0,0 +1,83 @@
+/** @internal */
+declare const _debug_: Debug; 
+
+import { beziersToSvgPathStr, simplifyPaths } from 'flo-boolean';
+import { Debug } from '../debug/debug.js';
+import { Mat } from '../mat/mat.js';
+import { findMat  } from './find-mat.js';
+import { getSizeParams } from './get-size-params.js';
+
+
+/**
+ * Finds and returns the Medial Axis Transforms (MATs) from the given array of 
+ * bezier loops representing shape boundaries.
+ * 
+ * @param bezierLoops An array of (possibly intersecting) loops with each loop 
+ * representing one or more piecewise smooth closed curves (i.e. shapes). Each 
+ * loop consists of an array of beziers represented by an array of control 
+ * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic 
+ * beziers respectively. Each point is a two-element array (ordered pair), the
+ * first of which is the x-coordinate and the second the y-coordinate.
+ * 
+ * @param maxCurviness The maximum value the 'curviness' of a curve can have 
+ * before an additional MAT point is inserted in between. Defaults to 0.4. 
+ * (Curviness is measured as the total angle in radians between the consecutive 
+ * vectors formed by the ordered control points of th bezier curve). The value
+ * is clipped in the range `[0.05,3]`.
+ * @param maxLength The maximum length a curve can have before an additional MAT 
+ * point is inserted. This value is scaled to a reference 1024 x 1024 
+ * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be 
+ * halved, e.g. from 10 to 5). Together with maxCurviness it represents a 
+ * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped 
+ * in [1,100].
+ */
+function findMats(
+		bezierLoops: number[][][][], 
+		maxCurviness = 0.4,
+        maxLength = 4): Mat[] {
+
+	// if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+
+	let maxCoordinate: number;
+	let minBezLength: number;
+	({ maxCurviness, maxLength, maxCoordinate, minBezLength } = 
+		getSizeParams(bezierLoops, maxCurviness, maxLength));
+
+	const loopss = simplifyPaths(bezierLoops);
+	// console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => v.map(v => v*2**4))))));
+	// console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers)));
+
+	const mats: Mat[] = [];
+	for (const loops of loopss) {
+		const mat = findMat(
+			loops, 
+			minBezLength, 
+			maxCurviness, 
+			maxLength,
+			maxCoordinate
+		);
+		if (mat) { mats.push(mat); }
+	}
+
+	return mats;
+}
+
+
+/**
+ * Returns an SVG path string representation of the given bezier loops.
+ * @param loops An array of loops having an array of bezier curves each given as 
+ * an array of control points.
+ */
+function loopsToSvgPathStr(
+		loops: number[][][][]) {
+
+	let str = '';
+	for (const loop of loops) {
+		str = str + beziersToSvgPathStr(loop) + '\n';
+	}
+
+	return str;
+}
+
+
+export { findMats }

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

@@ -0,0 +1,69 @@
+import { CpNode, cpNodeComparator, getAllOnLoop } from "../cp-node/cp-node.js";
+import { enhanceCpNode } from "../cp-node/enhance-cp-node.js";
+
+
+/**
+ * @internal
+ * 
+ * Use only for debugging. Check all nodes around the loop.
+ */
+function fixOrdering(
+        cpNode: CpNode) {
+
+    const cpStart = cpNode;
+
+    /* holeCloser order causes an issue here
+    {
+        const cpNodes = getAllOnLoop(cpStart);
+
+        cpNodes.sort(cpNodeComparator);
+        // console.log(cpNodes.map(cpn => enhanceCpNode(cpn).ordering))
+
+        const len = cpNodes.length;
+        for (let i=0; i<len; i++) {
+            const cpNode = cpNodes[i];
+            const prev = cpNodes[(i + len - 1)%len];
+            const next = cpNodes[(i + len + 1)%len];
+            if (cpNode.prev !== prev) {
+                // console.log(enhanceCpNode(cpNode));
+            }
+            if (cpNode.next !== next) {
+                // console.log(enhanceCpNode(cpNode));
+            }
+            // cpNode.prev = prev;
+            // cpNode.next = next;
+        }
+    }
+    */
+
+    /*
+    {
+        let cpNode2 = cpStart.next;
+        while (cpNode2 !== cpStart) {
+            const cpNode1 = cpNode2;
+            cpNode2 = cpNode2.next;
+
+            const c = cpNodeComparator(cpNode1, cpNode2)!;
+            const looplen = cpNode1.cp.pointOnShape.curve.loop.beziers.length;
+            if (c > 0 && !cpNode1.isHoleClosing && !cpNode2.isHoleClosing) {
+                const o1 = cpNode1.cp.pointOnShape.curve.idx;
+                const o2 = cpNode2.cp.pointOnShape.curve.idx;
+                if (if) {
+                   1;
+                } else {
+                    console.log('ORDER IS WRONG!', looplen, o1, o2)
+                    console.log(c);
+                    console.log(enhanceCpNode(cpNode1));
+                    console.log(enhanceCpNode(cpNode2));
+                    console.log('');
+                }
+            }
+        }
+	}
+    */
+
+	// return cpNodes;
+}
+
+
+export { fixOrdering }

package/src/find-mat/get-dull-corners.ts

@@ -0,0 +1,34 @@
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Loop } from 'flo-boolean';
+import { createPos } from '../point-on-shape/create-pos.js';
+import { getCornerAtEnd } from '../curve/curve.js';
+import { controlPointLinesLength } from 'flo-bezier3';
+
+
+/** @internal */
+function getDullCornersOnLoop(
+        minBezLength: number) {
+
+    return (loop: Loop) => {
+        const dullCorners: PointOnShape[] = [];
+
+        for (let i=0; i<loop.curves.length; i++) {
+            const curve = loop.curves[i];
+
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            
+            if (getCornerAtEnd(curve).isQuiteDull) {
+                dullCorners.push(createPos(curve, 1, true));
+                dullCorners.push(createPos(curve.next, 0, true));
+            }
+        }
+
+        return dullCorners;
+    }
+}
+
+
+
+export { getDullCornersOnLoop }

package/src/find-mat/get-for-1-prongs-on-loop.ts

@@ -0,0 +1,40 @@
+import { getCurvatureExtremaDd, getCurvatureExtremaE, controlPointLinesLength, getCurvatureExtrema } from 'flo-bezier3';
+import { Loop } from 'flo-boolean';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+
+
+/**
+ * @internal
+ * Get useful points on the shape - these incude points of maximum curvature and 
+ * points at the bezier-bezier interfaces.  
+ * @param loop
+ * @param additionalPointCount 
+ */
+function getFor1ProngsOnLoop(
+        minBezLength: number) {
+
+    return function(loop: Loop) {
+        const for1Prongs: PointOnShape[] = [];
+
+        for (let i=0; i<loop.curves.length; i++) {
+            const curve = loop.curves[i];
+
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            
+            // const { minima, maxima } = getCurvatureExtrema(curve.ps);
+            const { minima, maxima } = getCurvatureExtremaDd(curve.ps);
+            // const { minima, maxima } = getCurvatureExtremaE(curve.ps);
+            const maxAbsCurvatures = [...minima, ...maxima].map(t => createPos(curve, t, true));
+
+            for1Prongs.push(...maxAbsCurvatures);
+        }
+
+        return for1Prongs;
+    }
+}
+
+
+export { getFor1ProngsOnLoop }

package/src/find-mat/get-for-2-prongs-on-loop.ts

@@ -0,0 +1,44 @@
+import { splitByCurvatureAndLength, controlPointLinesLength } from 'flo-bezier3';
+import { Loop } from 'flo-boolean';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+
+
+/**
+ * @internal
+ * Get useful points on the shape - these incude points of maximum curvature and 
+ * points at the bezier-bezier interfaces.  
+ * @param loop
+ * @param additionalPointCount 
+ */
+function getFor2ProngsOnLoop(
+        minBezLength: number,
+        maxCurviness: number,
+        maxLength: number) {
+
+    return function(loop: Loop) {
+        const for2Prongs: PointOnShape[] = [];
+
+        for (let i=0; i<loop.curves.length; i++) {
+            const curve = loop.curves[i];
+
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            
+            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
+            // add at least one in the middle
+            if (ts.length === 2) { ts = [0, 0.5, 1]; }
+
+            const byCurvatureAndLength = 
+                ts.slice(1,ts.length-1).map(t => createPos(curve, t, true));
+
+            for2Prongs.push(...byCurvatureAndLength);
+        }
+
+        return for2Prongs;
+    }
+}
+
+
+export { getFor2ProngsOnLoop }

package/src/find-mat/get-sharp-corners.ts

@@ -0,0 +1,33 @@
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Loop } from 'flo-boolean';
+import { createPos } from '../point-on-shape/create-pos.js';
+import { getCornerAtEnd } from '../curve/curve.js';
+import { controlPointLinesLength } from 'flo-bezier3';
+
+
+/** @internal */
+function getSharpCornersOnLoop(
+        minBezLength: number) {
+            
+    return (loop: Loop) => {
+        const sharpCorners: PointOnShape[] = [];
+
+        for (let i=0; i<loop.curves.length; i++) {
+            const curve = loop.curves[i];
+
+            if (controlPointLinesLength(curve.ps) < minBezLength) {
+                continue;
+            }
+            
+            if (getCornerAtEnd(curve).isQuiteSharp) {
+                sharpCorners.push(createPos(curve, 1, true));
+            }
+        }
+
+        return sharpCorners;
+    }
+}
+
+
+
+export { getSharpCornersOnLoop }

package/src/find-mat/get-size-params.ts

@@ -0,0 +1,34 @@
+import { getLoopsMetrics } from '../loop/get-max-coordinate.js';
+
+
+function getSizeParams(
+        bezierLoops: number[][][][],
+        maxCurviness: number,
+        maxLength: number) {
+
+    // Gather some shape metrics
+    const { maxCoordinate, maxRadius } = getLoopsMetrics(bezierLoops);
+    const expMax = Math.ceil(Math.log2(maxCoordinate));
+    const minBezLengthSigBits = 16;
+    /** 
+     * If a curve is shorter than this value then no points on it will be 
+     * selected for the purpose of finding the MAT.
+     */
+    const minBezLength = 2**expMax * 2**(-minBezLengthSigBits);
+
+    // Limit the tolerance to a reasonable level
+    if (maxCurviness < 0.05) { maxCurviness = 0.05; }
+    if (maxCurviness > 3   ) { maxCurviness = 3;    }
+    // Limit the tolerance to a reasonable level
+    if (maxLength < 0.1) { maxLength = 0.1; }
+    if (maxLength > 100) { maxLength = 100; }
+    // Adjust length tolerance according to a reference max coordinate
+    const expMaxRadius = Math.ceil(Math.log2(maxRadius));
+    const maxLengthSigBits = 10;  // 1024 x 1024
+    maxLength = maxLength * (2**expMaxRadius * 2**(-maxLengthSigBits));
+
+    return { maxCurviness, maxLength, maxCoordinate, minBezLength };
+}
+
+
+export { getSizeParams }

package/src/{mat/find-mat → find-mat}/get-total-by.ts

@@ -1,11 +1,11 @@
-import { Curve } from '../../curve.js';
-import { Loop } from '../../loop.js';
+import { Curve } from '../curve/curve.js';
+import { Loop } from 'flo-boolean';
 
 
 /**
- * @hidden
+ * @internal
  * Helper function.
- * @hidden
+ * @internal
  * @param f
  */
 function getTotalBy(f: (curve: Curve) => number) {

package/src/{mat/geometry → geometry}/get-closest-square-distance-to-rect.ts

@@ -4,7 +4,7 @@ const squaredDistanceBetween = squaredDistanceBetween_;
 
 
 /**
- * @hidden
+ * @internal
  */
 function getClosestSquareDistanceToRect(
 		box: number[][], p: number[]): number {

package/src/{mat/geometry → geometry}/get-closest-squared-distance-to-rotated-rect.ts

@@ -4,12 +4,12 @@ import {
 
 
 /**
- * @hidden
+ * @internal
  */
 function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]) {
 	const ds = [0,1,2,3].map(i => squaredDistanceBetweenPointAndLineSegment(
 			p, 
-			[ps[i], ps[(i+1) % 4]]
+			[ps[i], ps[(i + 1) % 4]]
 		)				
 	);
 	

package/src/get-curve/get-curve-between.ts

@@ -2,13 +2,13 @@ import {
     fromTo, dot, cross, rotate90Degrees, interpolate, translate,
     lineLineIntersection
 } from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
 import { getEdgeDirection } from './get-edge-direction.js';
 
 
-/** @hidden */
+/** @internal */
 const TOLERANCE_ADD_2PRONG = 0.01;
-/** @hidden */
+/** @internal */
 const TOLERANCE_USE_LINE = 0.0001; // else cubic
 
 
@@ -20,7 +20,7 @@ const TOLERANCE_USE_LINE = 0.0001; // else cubic
  */
 function getCurveBetween(
         cpNodeFrom: CpNode, 
-        cpNodeTo: CpNode) {
+        cpNodeTo: CpNode): number[][] {
 
     const fromCc = cpNodeFrom.cp.circle.center;
     const fromL = getEdgeDirection(cpNodeFrom);
@@ -43,7 +43,7 @@ function getCurveBetween(
     }
     
     if (!twisted) {
-        return [fromCc, mid, toCc];
+        return [fromCc, mid!, toCc];
     } 
         
     const r = rotate90Degrees(c);
@@ -66,8 +66,8 @@ function getCurveBetween(
         const v2 = translate(r, m2);
         const l1 = [m1,v1];
         const l2 = [m2,v2];
-        const mid1 = lineLineIntersection(fromL, l1);
-        const mid2 = lineLineIntersection(toL,   l2);
+        const mid1 = lineLineIntersection(fromL, l1)!;
+        const mid2 = lineLineIntersection(toL,   l2)!;
 
         return [fromCc, mid1, mid2, toCc];
     } 

package/src/get-curve/get-edge-direction.ts

@@ -2,12 +2,13 @@ import {
     toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot
 } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
-import { isPosSharpCorner } from '../point-on-shape.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { isPosSharpCorner } from '../point-on-shape/is-pos-sharp-corner.js';
+import { Curve } from '../curve/curve.js';
 
 
 /**
- * @hidden
+ * @internal
  * Returns a line segment of unit length starting in the given Vertex center and
  * pointing in the direction of the medial axis (viewed as a rooted tree).
  * @param cpNode 
@@ -26,7 +27,6 @@ function getEdgeDirection(cpNode: CpNode) {
 
     let vDir;
     
-    //if (!PointOnShape.isSharpCorner(pos1)) {
     if (!isPosSharpCorner(pos1)) {
         if (p1[0] === p2[0] && p1[1] === p2[1]) {
             vDir = fromTo(p1, circleCenter); // A 1-prong
@@ -34,9 +34,9 @@ function getEdgeDirection(cpNode: CpNode) {
             vDir = rotate90Degrees( fromTo(p1, p2) ); // not a 1-prong.
         }
     } else {
-        let curve1;
-        let curve2;
-        // TODO - test if pos1.t can ever be 0 - it is terminating
+        let curve1: Curve;
+        let curve2: Curve;
+
         if (pos1.t === 0) {
             curve1 = pos1.curve;
             curve2 = pos1.curve.prev;
@@ -45,15 +45,15 @@ function getEdgeDirection(cpNode: CpNode) {
             curve2 = pos1.curve;
         }
 
-        const tan1 = toUnitVector(tangent(curve1.ps, 0));
-        const tan2 = reverse( toUnitVector(tangent(curve2.ps, 1)) );
+        const tan1 = toUnitVector(tangent(curve1!.ps, 0));
+        const tan2 = reverse( toUnitVector(tangent(curve2!.ps, 1)) );
         
         const x = dot(tan1, tan2);
         // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
         // recall the half angle formulas. Then the rotation matrix, R, can 
         // be calculated.
-        const cosθ = Math.sqrt((1+x)/2);
-        const sinθ = Math.sqrt((1-x)/2);
+        const cosθ = Math.sqrt((1 + x)/2);
+        const sinθ = Math.sqrt((1 - x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }