flo-mat 2.0.4 → 3.0.0

package/src/{mat/find-mat/find-3-prong → find-3-prong.ts}/find-3-prong-for-delta3s.ts

@@ -6,23 +6,25 @@ import {
     cross 
 } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
-import { Debug } from '../../../debug/debug.js';
-import { CpNode } from '../../../cp-node.js';
-import { BezierPiece } from '../../bezier-piece.js';
-import { isPosDullCorner, IPointOnShape } from '../../../point-on-shape.js';
-import { getClosestBoundaryPoint } from '../../closest-boundary-point/get-closest-boundary-point.js';
+import { Debug } from '../debug/debug.js';
+import { CpNode, isSharp } from '../cp-node/cp-node.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
 import { calcInitial3ProngCenter } from './calc-initial-3-prong-center.js';
 import { getClosestPoints } from './get-closest-points.js';
 import { calcBetterX } from './calc-better-x.js';
-import { Curve, getCornerAtEnd } from '../../../curve.js';
+import { getCornerAtEnd } from '../curve/curve.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { createPos } from '../point-on-shape/create-pos.js';
 
 
-/** @hidden */
+/** @internal */
 const calcVectorToZeroV_StraightToIt = fromTo;
 
 
 /**
- * @hidden
+ * @internal
  * Finds a 3-prong using only the 3 given δs.
  * @param δs The boundary pieces
  * @param idx δ identifier
@@ -37,7 +39,7 @@ function find3ProngForDelta3s(
         bezierPiecess: BezierPiece[][],
         extreme: number) {
 
-    const TOLERANCE = extreme * 1e-10;
+    const TOLERANCE = 2**-32*extreme;
     const MAX_ITERATIONS = 10;
 
     const δs_ = [
@@ -68,10 +70,10 @@ function find3ProngForDelta3s(
     const δ3s = δ3ss[k];
     const bezierPiece3s = bezierPiecess_[k];
 
-    if (δ3s[0][0].isSharp()) { return undefined; }
+    if (isSharp(δ3s[0][0])) { return undefined; }
 
 
-    let ps: IPointOnShape[];
+    let ps: (PointOnShape | undefined)[];
     let circumCenter_;
     let j = 0; // Safeguard for slow convergence
     let x = calcInitial3ProngCenter(δ3s, bezierPiece3s);
@@ -97,7 +99,7 @@ function find3ProngForDelta3s(
             return undefined;
         }
 
-        circumCenter_ = circumCenter(ps.map(x => x.p));
+        circumCenter_ = circumCenter(ps.map(x => x!.p));
 
         const vectorToZeroV = calcVectorToZeroV_StraightToIt(x, circumCenter_);
 
@@ -125,9 +127,9 @@ function find3ProngForDelta3s(
         tolerance = Math.abs(V - upds.newV);
     }
 
-    const radius = (distanceBetween(x, ps[0].p) + 
-                distanceBetween(x, ps[1].p) + 
-                distanceBetween(x, ps[2].p)) / 3;
+    const radius = (distanceBetween(x, ps![0]!.p) + 
+                    distanceBetween(x, ps![1]!.p) + 
+                    distanceBetween(x, ps![2]!.p)) / 3;
 
     const circle = { center: x, radius };
 
@@ -138,21 +140,19 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     let totalAngleError = 0;
     for (let i=0; i<3; i++) {
-        const p = ps[i];
+        const p = ps![i];
         //----------------------------
         // Tangent of circle at point
         //----------------------------
-        const v = toUnitVector(fromTo(p.p, x));
+        const v = toUnitVector(fromTo(p!.p, x));
         const v1 = rotate90Degrees(v);
         
         
         //-----------------------------------
         // Check if point is on dull crorner
         //-----------------------------------
-        //if (PointOnShape.isDullCorner(p)) {
-        if (isPosDullCorner(p)) {
-            //const corner = Curve.getCornerAtEnd(p.curve);
-            const corner = getCornerAtEnd(p.curve);
+        if (isPosDullCorner(p!)) {
+            const corner = getCornerAtEnd(p!.curve);
             const tans = corner.tangents;
             const perps = tans.map( rotate90Degrees );
                 
@@ -168,7 +168,7 @@ function find3ProngForDelta3s(
             //---------------------------
             // Tangent of curve at point
             //---------------------------
-            const v2 = toUnitVector( tangent(p.curve.ps, p.t) );
+            const v2 = toUnitVector( tangent(p!.curve.ps, p!.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
             // multiple of Math.PI **and** is close to the actual angle value
@@ -189,11 +189,11 @@ function find3ProngForDelta3s(
     //-------------------------------------------------------------------------
     const closestDs = [];
     for (let i=0; i<bezierPiecess.length; i++) {
-        const p = getClosestBoundaryPoint(
-            bezierPiecess[i], x, undefined, undefined
-        );
-        
-        closestDs.push( distanceBetween(p.pos.p, x) );
+        const p = getCloseBoundaryPointsCertified(
+            bezierPiecess[i], x
+        )[0];
+
+        closestDs.push( distanceBetween(p.p, x) );
     }
     const closestD = Math.min(...closestDs);
     const radiusDelta = Math.abs(radius - closestD);
@@ -203,7 +203,7 @@ function find3ProngForDelta3s(
     const W2 = 1;
     const error = W1*radiusDelta + W2*totalAngleError;
 
-    return { ps, circle, error, δ3s };
+    return { ps: ps!, circle, error, δ3s };
 }
 
 

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

@@ -0,0 +1,148 @@
+/** @internal */
+declare const _debug_: Debug; 
+
+import { fromTo } from 'flo-bezier3';
+import { Debug } from '../debug/debug.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { Circle } from '../geometry/circle.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { createEmptyThreeProngForDebugging } from '../debug/three-prong-for-debugging.js';
+import { find3ProngForDelta3s } from './find-3-prong-for-delta3s.js';
+import { getBoundaryPieceBeziers } from '../mat/get-boundary-piece-beziers.js';
+import { BezierPiece } from '../mat/bezier-piece.js';
+
+
+interface CandidateThreeProng {
+	circle: {
+		center: number[];
+		radius: number;
+	};
+	ps: PointOnShape[];
+}
+
+
+/**
+ * @internal
+ * Find and return a 3-prong from the given boundary piece.
+ * @param δs A boundary piece
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */ 
+function find3Prong(δs: CpNode[][], extreme: number) {
+	const bezierPiecess = δs.map(getBoundaryPieceBeziers);
+	addDebugInfo1(bezierPiecess);
+	const candidateThreeProngs: CandidateThreeProng[] = [];
+
+	// The best candidate amongst the different 'permutations' of the given δs.
+	let threeProng: { 
+        circle: Circle, 
+        ps: PointOnShape[], 
+        δ3s: CpNode[][] 
+    };
+	let bestIndx = undefined; 
+	let smallestError = Number.POSITIVE_INFINITY;
+	for (let i=1; i<δs.length-1; i++) {
+		for (let k=0; k<3; k++) {
+			addDebugInfo2();
+
+			const threeProngInfo = 
+				find3ProngForDelta3s(δs, i, k, bezierPiecess, extreme);
+			if (!threeProngInfo) { continue; }
+
+			const { circle, ps: poss, error, δ3s } = threeProngInfo;
+			
+			addDebugInfo3(candidateThreeProngs, circle, poss as PointOnShape[]);
+			
+			if (error < smallestError) {
+				smallestError = error;
+				
+				bestIndx = i-1;
+				threeProng = { circle, ps: poss as PointOnShape[], δ3s };
+			}
+		}
+	}
+
+	addDebugInfo4(threeProng!, δs, bestIndx, candidateThreeProngs);
+	
+	return threeProng!;
+}
+
+
+function addDebugInfo2() {
+	if (typeof _debug_ !== 'undefined') { 
+		const threeProngs = _debug_.generated.elems.threeProng;
+		const d = threeProngs[threeProngs.length-1];
+		const trace: number[][] = [];
+		d.traces.push(trace);
+	}
+}
+
+function addDebugInfo3(
+		candidateThreeProngs: CandidateThreeProng[],
+		circle: Circle,
+		ps: PointOnShape[]) {
+
+	if (typeof _debug_ !== 'undefined') { 
+		candidateThreeProngs.push({ circle, ps });
+	}
+}
+
+
+function addDebugInfo4(
+		threeProng: {
+			circle: Circle;
+			ps: PointOnShape[];
+			δ3s: CpNode[][]
+		},
+		δs: CpNode[][],
+		bestIndx: number | undefined,
+		candidateThreeProngs: CandidateThreeProng[]) {
+
+	if (typeof _debug_ !== 'undefined') { 
+		const threeProngs = _debug_.generated.elems.threeProng;
+		const d = threeProngs[threeProngs.length-1];
+
+		d.generated = _debug_.generated;
+		if (threeProng !== undefined) {
+			d.circle = threeProng.circle;
+			d.poss = threeProng.ps;
+			d.cp3ss = threeProng.δ3s;
+		}
+		d.cpss = δs;
+		d.bestIndx = bestIndx!;
+		d.candidateThreeProngs = candidateThreeProngs;
+	}
+}
+
+
+function addDebugInfo1(
+		bezierPiecess: BezierPiece[][]) {
+
+	if (typeof _debug_ !== 'undefined') { 
+		const threeProngs = _debug_.generated.elems.threeProng;
+		threeProngs.push(createEmptyThreeProngForDebugging());
+
+		const d = threeProngs[threeProngs.length-1];
+		d.boundaries = [];
+		for (const bezierPieces of bezierPiecess) {
+			const boundary: number[][][] = [];
+			d.boundaries.push(boundary);
+			for (const bezierPiece of bezierPieces) {
+				/* qqq
+				let bezier = fromTo(bezierPiece.curve.ps)(
+					bezierPiece.ts[0], bezierPiece.ts[1]
+				);
+				*/
+				const bezier = fromTo(
+					bezierPiece.curve.ps,
+					bezierPiece.ts[0], bezierPiece.ts[1]
+				);
+				boundary.push(bezier);
+			}
+		}
+		d.traces = [];
+	}
+}
+
+
+export { find3Prong }

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

@@ -0,0 +1,111 @@
+/** @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 { traverseCp } from '../cp-node/traverse-cp.js';
+import { Loop } from 'flo-boolean';
+import { Circle } from '../geometry/circle.js';
+import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
+import { find3Prong } from './find-3-prong.js';
+import { add3Prong  } from './add-3-prong.js';
+
+
+/**
+ * @internal
+ * Starting from some ContactPoint, traverses the shape going around Vertices
+ * and if more than two Vertices have been visited in total then recursively 
+ * adds 3-prongs until only one or two Vertices have been visited. 
+ * 
+ * This process further subdivides the shape.
+ * 
+ * @param cpGraphs
+ * @param cpStart The ContactPoint from where to start the process.
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+let ii = 0;
+function findAndAdd3Prongs(
+		cpGraphs: Map<Loop,LlRbTree<CpNode>>,
+		cpStart: CpNode,
+		extreme: number): CpNode[] {
+
+	let visitedCps: CpNode[];
+	
+	do {
+		visitedCps = traverseCp(cpStart);
+	
+		if (visitedCps.length > 2) {
+			const newCpNodes = findAndAdd3Prong(cpGraphs, visitedCps, extreme);
+			if (newCpNodes.length === 1) {
+				// There was another closeby cpNode
+				const closeCpNode = newCpNodes[0];
+			}
+			ii++;
+		}
+
+		if (typeof _debug_ !== 'undefined') {
+            if (ii === _debug_.directives.stopAfterThreeProngsNum) {
+                return undefined!;
+            }
+        }
+	} while (visitedCps.length > 2);
+
+	return visitedCps;
+}
+
+
+/**
+ * @internal
+ * Finds and add a 3-prong MAT circle to the given shape.
+ * @param cpGraphs
+ * @param visitedCps
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAdd3Prong(
+		cpGraphs: Map<Loop,LlRbTree<CpNode>>,
+		visitedCps: CpNode[],
+		extreme: number): CpNode[] {
+	
+	const δs: [CpNode, CpNode][] = [];
+	for (const visitedCp of visitedCps) {
+		δs.push([visitedCp, visitedCp.next]);
+	}
+	
+	const threeProng = find3Prong(δs, extreme);
+	
+	const orders: number[] = [];
+	for (let i=0; i<3; i++) {
+		orders.push(
+			calcPosOrder(threeProng.circle, threeProng.ps[i])
+		);
+	}
+	
+	const newCpNodes = add3Prong(cpGraphs, orders, threeProng);
+
+	if (typeof _debug_ !== 'undefined') {
+		if (newCpNodes.length === 3) {
+			add3ProngDebugInfo(newCpNodes[0].cp.circle, visitedCps);
+		}
+	}
+
+	return newCpNodes;
+}
+
+
+/** @internal */
+function add3ProngDebugInfo(
+		circle: Circle, 
+		visitedCps: CpNode[]) {
+
+	const threeProngs = _debug_.generated.elems.threeProng;
+	const len = threeProngs.length;
+	const data = threeProngs[len-1];
+	data.visitedCps = visitedCps;
+	data.circle = circle;
+}
+
+
+export { findAndAdd3Prongs }

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

@@ -0,0 +1,109 @@
+/** @internal */
+declare const _debug_: Debug; 
+
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { Debug } from '../debug/debug.js';
+import { CpNode, getCpNodesOnCircle } from '../cp-node/cp-node.js';
+import { Loop } from 'flo-boolean';
+import { isPosSharpCorner } from '../point-on-shape/is-pos-sharp-corner.js';
+import { fixOrdering } from '../find-mat/fix-ordering.js';
+import { findAndAdd3Prongs } from './find-and-add-3-prongs.js';
+
+
+interface Edge {
+    fromCpNode: CpNode;
+    cpStart: CpNode;
+}
+
+
+/**
+ * @internal
+ * Finds and adds all 3-prongs.
+ * @param cpGraphs
+ * @param cpStart The CpNode to start traversing from. 
+ * @param extreme The maximum coordinate value used to calculate floating point
+ * tolerances.
+ */
+function findAndAddAll3Prongs(
+        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
+        cpStart: CpNode,
+        extreme: number) {
+
+    // Don't change this function to be recursive, the call stack may overflow 
+    // if there are too many two-prongs.
+
+    const visitedEdges = new Map<CpNode, Set<CpNode>>();
+
+    const edgesToCheck: Edge[] = [{ fromCpNode: undefined! as CpNode, cpStart }];
+
+    while (edgesToCheck.length) {
+        const { fromCpNode, cpStart } = edgesToCheck.shift()!;
+
+        markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
+        
+        for (const cpNode of getCpNodesOnCircle(cpStart)) {
+
+            if (!isPosSharpCorner(cpNode.cp.pointOnShape)) {
+                if (findAndAdd3Prongs(cpGraphs, cpNode, extreme) === undefined) {
+                    console.log('Unable to find 3-prong');
+                    return; // only for debugging purposes
+                }
+            }
+
+            if (hasEdgeBeenTaken(visitedEdges, cpNode, cpNode.next)) {
+                continue; // We already visited this edge
+            }
+
+            edgesToCheck.push({ fromCpNode: cpStart, cpStart: cpNode.next }); 
+        }
+    }
+
+    // for (const [k,v] of cpGraphs) {
+    //     fixOrdering(v.root!.datum);
+    // }
+}
+
+
+/**
+ * @internal
+ * Marks the given edge as already taken.
+ */
+function markEdgeAsTaken(
+        visitedEdges: Map<CpNode, Set<CpNode>>,
+        cp1: CpNode, 
+        cp2: CpNode) {
+
+    if (cp1 === undefined) { return; }
+
+    markEdgeAsTaken_(cp1, cp2);
+    markEdgeAsTaken_(cp2, cp1);
+
+    function markEdgeAsTaken_(cp1: CpNode, cp2: CpNode) {
+        let visited = visitedEdges.get(cp1);
+        if (!visited) { 
+            visited = new Set<CpNode>();
+            visitedEdges.set(cp1, visited);
+        }  
+        visited.add(cp2);
+    }
+}
+
+
+/** @internal */
+function hasEdgeBeenTaken(
+        visitedEdges: Map<CpNode, Set<CpNode>>,
+        cp1: CpNode, 
+        cp2: CpNode) {
+
+    let cps: Set<CpNode> | undefined;
+
+    cps = visitedEdges.get(cp1);
+    const takenForward = cps && cps.has(cp2); 
+
+    cps = visitedEdges.get(cp2);
+    const takenBackwards = cps && cps.has(cp1); 
+
+    return takenForward || takenBackwards;
+}
+
+export { findAndAddAll3Prongs }

package/src/find-3-prong.ts/get-closest-points.ts

@@ -0,0 +1,24 @@
+import { BezierPiece  } from '../mat/bezier-piece.js';
+import { getCloseBoundaryPointsCertified } from '../closest-boundary-point/get-close-boundary-points-certified.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+
+
+/**
+ * @internal
+ * @param x 
+ * @param bezierPiece3s 
+ * @param extreme 
+ */
+function getClosestPoints(
+        x: number[], 
+        bezierPiece3s: BezierPiece[][]) {
+
+    return bezierPiece3s.map(bezierPieces => {
+        return getCloseBoundaryPointsCertified(
+            bezierPieces, x
+        )[0];
+    });
+}
+
+
+export { getClosestPoints }

package/src/{mat/find-mat → find-mat}/add-debug-info.ts

@@ -1,9 +1,9 @@
 import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
-import { Debug }   from '../../debug/debug.js';
-import { Loop } from '../../loop.js';
-import { Curve, getCornerAtEnd } from '../../curve.js';
-import { Mat } from '../../mat.js';
-import { getBoundingBox_ } from '../../get-bounding-box-.js';
+import { Debug }   from '../debug/debug.js';
+import { Loop } from 'flo-boolean';
+import { Curve, getCornerAtEnd } from '../curve/curve.js';
+import { Mat } from '../mat/mat.js';
+import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
 
 
 /** @internal */
@@ -13,7 +13,7 @@ declare const _debug_: Debug;
 let timingStart: number;
 
 
-/** @hidden */
+/** @internal */
 function addDebugInfo1(loops: Loop[]) {
     if (typeof _debug_ === 'undefined') { return; }
     
@@ -32,7 +32,7 @@ function addDebugInfo1(loops: Loop[]) {
         let i = 0;
         loop.curves.forEach(function(curve: Curve) {
             const ps = curve.ps;
-            const hull = getBoundingHull(ps); 
+            const hull = getBoundingHull(ps)!; 
 
             generated.elems.boundingHull.push(hull);
 
@@ -43,9 +43,9 @@ function addDebugInfo1(loops: Loop[]) {
             generated.elems.tightBoundingBox.push(tightBoundingBox);
 
             const corner = getCornerAtEnd(curve);
-            if (corner.isSharp) {
+            if (corner.isQuiteSharp) {
                 generated.elems.sharpCorner.push(curve);
-            } else if (corner.isDull) {
+            } else if (corner.isQuiteDull) {
                 generated.elems.dullCorner.push(curve);
             }
 
@@ -55,7 +55,7 @@ function addDebugInfo1(loops: Loop[]) {
 }
 
 
-/** @hidden */
+/** @internal */
 function addDebugInfo2() {
     if (typeof _debug_ === 'undefined') { return; }
 

package/src/{mat/find-mat → find-mat}/create-initial-cp-graph.ts

@@ -1,12 +1,12 @@
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from '../../loop.js';
-import { CpNode } from '../../cp-node.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-import { ContactPoint } from '../../contact-point.js';
+import { Loop } from 'flo-boolean';
+import { CpNode, cpNodeComparator, insertCpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { ContactPoint } from '../contact-point/contact-point.js';
 
 
 /**
- * @hidden
+ * @internal
  * Creates the initial ContactPoint loops from the given sharp corners.
  * @param shape
  * @param sharpCornerss
@@ -14,7 +14,7 @@ import { ContactPoint } from '../../contact-point.js';
 function createInitialCpGraph(
         loops: Loop[], 
         cpTrees: Map<Loop, LlRbTree<CpNode>>,
-        sharpCornerss: IPointOnShape[][]/*,
+        sharpCornerss: PointOnShape[][]/*,
         xMap: Map<number[][],{ ps: number[][] }>*/) {
 
     let cpNode;
@@ -22,11 +22,10 @@ function createInitialCpGraph(
     for (let k=0; k<sharpCornerss.length; k++) {
         const sharpCorners = sharpCornerss[k];
 
-        // qqq const cpTree = new LlRbTree(CpNode.comparator, [], true);
-        const cpTree = new LlRbTree(CpNode.comparator, false);
+        const cpTree = new LlRbTree(cpNodeComparator, false);
         
-        let cpNode1 = undefined;
-        let cpNode2 = undefined;
+        let cpNode1: CpNode = undefined!;
+        let cpNode2: CpNode = undefined!;
         for (const pos of sharpCorners) {
             const ps = pos.curve.next.ps;
             //const x = xMap.get(ps);
@@ -37,8 +36,8 @@ function createInitialCpGraph(
             const cp1: ContactPoint = { pointOnShape: pos, circle, order: -1, order2: 0 };
             const cp2: ContactPoint = { pointOnShape: pos, circle, order: +1, order2: 0 };
 
-            cpNode1 = CpNode.insert(false, /*isIntersection*/ false, cpTree, cp1, cpNode2);
-            cpNode2 = CpNode.insert(false, /*isIntersection*/ false, cpTree, cp2, cpNode1);
+            cpNode1 = insertCpNode(false, /*isIntersection*/ false, cpTree, cp1, cpNode2!);
+            cpNode2 = insertCpNode(false, /*isIntersection*/ false, cpTree, cp2, cpNode1);
             
             cpNode1.prevOnCircle = cpNode2; 
             cpNode2.prevOnCircle = cpNode1;