flo-mat 3.0.1 → 3.0.2

package/src/find-2-prong/add-1-prong.ts

@@ -1,32 +1,26 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug }   from '../debug/debug.js';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { addToCpGraph } from '../mat/add-to-cp-graph.js';
-import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+import { addToCpTree } from '../mat/add-to-cp-tree.js';
+import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { Circle } from '../geometry/circle.js';
+import { MatMeta } from '../mat/mat-meta.js';
+import { isPosCorner } from '../point-on-shape/is-pos-corner.js';
+import { getPosCorner } from '../point-on-shape/get-pos-corner.js';
 
 
 /**
  * @hidden
  * Add a 1-prong to the MAT.
- * @param cpGraphs
+ * @param cpTrees
  * @param pos 
  */
 function add1Prong(
+		meta: MatMeta,
 		radius: number,
         center: number[],
-        cpGraphs: Map<Loop,LlRbTree<CpNode>>, 
         pos: PointOnShape) {
 
-	//if (PointOnShape.isDullCorner(pos)) {
-    if (isPosDullCorner(pos)) {
+    if (isPosCorner(pos) && getPosCorner(pos).isDull) {
 		// This is a 1-prong at a dull corner.
 		
 		// TODO IMPORTANT 
@@ -40,28 +34,27 @@ function add1Prong(
 
 		//toRemove.push(posNode); // this!
 		
-		if (typeof _debug_ !== 'undefined') { 
+		// if (typeof _debug_ !== 'undefined') { 
             // _debug_.generated.elems.oneProngAtDullCorner.push(pos);
-        }
+        // }
 
 		return;
 	}
 	
-	// const circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
     const circle: Circle = { radius, center };
 	
 	const order = calcPosOrder(circle, pos);
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
-	if (isAnotherCpCloseby(cpGraphs, pos, circle, order, 0, 1000)) {
+	if (getCloseByCpIfExist(meta, pos, circle, order, 0, 1)) {
 		return;
 	}
 
-    const cpNodes = addToCpGraph(circle, [-0.5, +0.5], cpGraphs, [pos, pos]); 
+    const { anyFailed, cpNodes } = addToCpTree(false, false, circle, [-0.5, +0.5], meta.cpTrees, [pos, pos]); 
 	
-	if (typeof _debug_ !== 'undefined') { 
-        _debug_.generated.elems.oneProng.push(cpNodes);
-    }
+	// if (typeof _debug_ !== 'undefined') { 
+    //     _debug_.generated.elems.oneProng.push(cpNodes);
+    // }
 }
 
 

package/src/find-2-prong/add-2-prong.ts

@@ -1,214 +1,109 @@
-/** @internal */
-declare const _debug_: Debug;
-
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { exponent } from 'big-float-ts';
-import { Debug } from '../debug/debug.js';
 import { Loop } from 'flo-boolean';
-import { CpNode, insertCpNode } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
 import { Circle } from '../geometry/circle.js';
-import { ContactPoint } from '../contact-point/contact-point.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
 import { createPos } from '../point-on-shape/create-pos.js';
-import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
-import { getNeighbouringPoints } from '../mat/get-neighboring-cps.js';
-import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
-import { Curve } from '../curve/curve.js';
+import { getCloseByCpIfExist } from '../mat/get-closeby-cp-if-exist.js';
+import { MatMeta } from '../mat/mat-meta.js';
+import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+import { addToCpTree } from '../mat/add-to-cp-tree.js';
+import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
 
 
 /**
  * @internal
  * Adds a 2-prong contact circle to the shape.
- * @param cpGraphs
+ *
+ * @param cpTrees
  * @param circle Circle containing the 2 contact points
  * @param posSource The source point on shape
  * @param posAntipode The found antipodal point on shape
- * @param holeClosing True if this is a hole-closing 2-prong, false otherwise
- * @param extreme The maximum coordinate value used to calculate floating point
+ * @param isHoleClosing True if this is a hole-closing 2-prong, false otherwise
+ * @param maxCoordinate The maximum coordinate value used to calculate floating point
  * tolerances.
  */
 function add2Prong(
-		cpGraphs      : Map<Loop,LlRbTree<CpNode>>,
-        circle        : Circle, 
-        posSource     : PointOnShape, 
-		posAntipodes  : PointOnShape[],
-		holeClosing   : boolean,
-		extreme       : number): CpNode | undefined {
-
-	let t_s = posSource.t;
-	if (t_s === 0) {
-		t_s = 1;
-		posSource = createPos(posSource.curve.prev, t_s, true);
-	}
+		meta: MatMeta,
+        circle: Circle,
+		poss: PointOnShape[],
+		isHoleClosing: boolean): CpNode | undefined {
+
+	const { cpTrees } = meta;
 
-	const orderSource = calcPosOrder(circle, posSource);
-	const orderAntipodes = posAntipodes.map(
-		posAntipode => calcPosOrder(circle, posAntipode)
-	);
+	poss[0] = poss[0].t === 0
+		? createPos(poss[0].curve.prev, 1, true)
+		: poss[0];
 
+	const orders = poss.map(pos => calcPosOrder(circle, pos));
 
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
-
-	let isCloseByAntipodes = false;
-	for (let i=0; i<posAntipodes.length; i++) {
-		const posAntipode = posAntipodes[i];
-		const orderAntipode = orderAntipodes[i];
-
-		if (!!isAnotherCpCloseby(cpGraphs, posAntipode, circle, orderAntipode, 0, extreme)) {
-			isCloseByAntipodes = true;
-			break;
+	for (let i=0; i<poss.length; i++) {
+		if (!!getCloseByCpIfExist(meta, poss[i], circle, orders[i], 0, 2)) {
+			return undefined;
 		}
 	}
-	if (!!isAnotherCpCloseby(cpGraphs, posSource, circle, orderSource, 0, extreme) ||
-		isCloseByAntipodes) {
-
-		if (typeof _debug_ !== 'undefined') {
-			if (holeClosing) {
-				_debug_.generated.elems['twoProng_holeClosing'].pop();
-			} else {
-				_debug_.generated.elems['twoProng_regular'].pop();
-			}
-		}
-		return;
-	}
 
-	// Antipode
-	const newCpAntipodes: CpNode[] = [];
-	const cpAntipodes: ContactPoint[] = [];
-	const cpTreeAntipodes: LlRbTree<CpNode>[] = [];
-	const deltaAntipodes: CpNode[][] = [];
-	const loopAntipodes: Loop[] = [];
-	for (let i=0; i<posAntipodes.length; i++) {
-		const posAntipode = posAntipodes[i];
-		const orderAntipode = orderAntipodes[i];
-
-		const cpAntipode: ContactPoint = {
-			pointOnShape: posAntipode, circle, order: orderAntipode, order2: 0
-		};
-		cpAntipodes.push(cpAntipode);
-		const loopAntipode = posAntipode.curve.loop;
-		loopAntipodes.push(loopAntipode);
-		const cpTreeAntipode = cpGraphs.get(loopAntipode)!;
-		cpTreeAntipodes.push(cpTreeAntipode);
-		const deltaAntipode = getNeighbouringPoints(
-			cpTreeAntipode, posAntipode, orderAntipode, 0
-		);	
-		deltaAntipodes.push(deltaAntipode);
-
-		newCpAntipodes.push(insertCpNode(
-			holeClosing,
-			false,
-			cpTreeAntipode,
-			cpAntipode, 
-			deltaAntipode[0]
-		));
-	}
-	
-	
-	// Source
-	const cpSource: ContactPoint = { pointOnShape: posSource, circle, order: orderSource, order2: 0 };
-	const loopSource = posSource.curve.loop;
-	const cpTreeSource = cpGraphs.get(loopSource)!;
-	const deltaSource = getNeighbouringPoints(
-		cpTreeSource, posSource, orderSource, 0
-	);
-	const newCpSource = insertCpNode(
-		holeClosing,
-		false,
-		cpTreeSource,
-		cpSource, 
-		deltaSource[0]
-	);
+	const { anyFailed, cpNodes } = addToCpTree(isHoleClosing, isHoleClosing, circle, orders, cpTrees, poss);
 
-
-	// Connect graph
-	if (newCpAntipodes.length === 1) {
-		newCpSource.prevOnCircle = newCpAntipodes[0];
-		newCpSource.nextOnCircle = newCpAntipodes[0];
-	
-		newCpAntipodes[0].prevOnCircle = newCpSource;
-		newCpAntipodes[0].nextOnCircle = newCpSource;
-	} else {
-		const cpNodes = newCpAntipodes.slice();
-		cpNodes.push(newCpSource);
-
-		// Order points according to their angle with the x-axis
-		cpNodes.sort(byAngle(circle));
-
-		for (let i=0; i<cpNodes.length; i++) {
-			const iNext = (i + 1 === cpNodes.length) ? 0 : i + 1;
-			const iPrev = (i === 0) ? cpNodes.length-1 : i - 1;
-
-			const cpNodeCurr = cpNodes[i];
-			const cpNodeNext = cpNodes[iNext];
-			const cpNodePrev = cpNodes[iPrev];
-
-			cpNodeCurr.nextOnCircle = cpNodeNext;
-			cpNodeCurr.prevOnCircle = cpNodePrev;
-		}
-	}
-	
-
-	if (holeClosing) { 
-		// TODO - take care of case where there are more than 1 antipode
-		// Duplicate ContactPoints
-		const cpB2: ContactPoint = { pointOnShape: posAntipodes[0], circle, order: cpAntipodes[0].order, order2: +1 };
-		const newCpB2Node = insertCpNode(true, false, cpTreeAntipodes[0], cpB2, newCpAntipodes[0]);
-		
-		const cpB1: ContactPoint = { pointOnShape: posSource, circle, order: cpSource.order, order2: -1 };
-		const newCpB1Node = insertCpNode(true, false, cpTreeSource, cpB1, newCpSource.prev);
-		
-		// Connect graph
-		newCpB1Node.prevOnCircle = newCpB2Node;
-		newCpB1Node.nextOnCircle = newCpB2Node;
-		newCpB2Node.prevOnCircle = newCpB1Node;
-		newCpB2Node.nextOnCircle = newCpB1Node;
-		
-		newCpAntipodes[0].next = newCpSource;
-		newCpSource.prev = newCpAntipodes[0];
-		
-		newCpB1Node.next = newCpB2Node;
-		newCpB2Node.prev = newCpB1Node;
+	if (anyFailed) {
+		cpNodes.forEach(cpNode => {
+			if (cpNode !== undefined) {
+				removeCpNode(cpNode, cpTrees);
+			}
+		});
+		return undefined;
 	}
 
+	// Get points ordered according to their angle with the x-axis
+	// joinSpokes(circle, cpNodes);
 
-	if (typeof _debug_ !== 'undefined') {
-		let elems: TwoProngForDebugging[];
-		if (holeClosing) {
-			elems = _debug_.generated.elems['twoProng_holeClosing'];
-		} else {
-			elems = _debug_.generated.elems['twoProng_regular'];
-		}
-
-		const elem = elems[elems.length-1];
-
-		if (!newCpSource) { console.log('asas')}
-		elem.cpNode = newCpSource;
+	if (isHoleClosing) { 
+		closeHole(cpTrees, cpNodes as CpNode[]);
 	}
 
-	return newCpSource;
+	return cpNodes[0];  // return the source `CpNode`
 }
 
 
-/** @internal */
-function byAngle(circle: Circle) {
-	const c = circle.center;
+function closeHole(
+		cpTrees: Map<Loop, LlRbTree<CpNode>>,
+		cpNodes: CpNode[]) {
 
-	return function(_a: CpNode, _b: CpNode) {
-		let a = _a.cp.pointOnShape.p;
-		let b = _b.cp.pointOnShape.p;
+	const [cpNodeA, cpNodeB] = cpNodes;
+	// Duplicate ContactPoints
+	// const antipodeCpNode = cpNodeB[0];
+	const cpAntipode = cpNodeB.cp;
 
-		// Move onto origin
-		a = [a[0] - c[0], a[1] - c[1]];
-		b = [b[0] - c[0], b[1] - c[1]];
+	const cpNodeB2 = insertCpNode(
+		true,
+		true, false,
+		cpTrees.get(cpAntipode.pointOnShape.curve.loop)!,
+		{ ...cpAntipode, order2: +1 },
+		cpNodeB
+	)!;
 
-		const a_ = Math.atan2(a[1], a[0]);
-		const b_ = Math.atan2(b[1], b[0]);
+	const cpNodeB1 = insertCpNode(
+		true,
+		true, false,
+		cpTrees.get(cpNodeA.cp.pointOnShape.curve.loop)!,
+		{ ...cpNodeA.cp, order2: -1 },
+		cpNodeA.prev
+	)!;
 
-		return b_ - a_;
-	}
+	// Connect graph
+	cpNodeB1.prevOnCircle = cpNodeB2;
+	cpNodeB1.nextOnCircle = cpNodeB2;
+	cpNodeB2.prevOnCircle = cpNodeB1;
+	cpNodeB2.nextOnCircle = cpNodeB1;
+
+	cpNodeB.next = cpNodeA;
+	cpNodeA.prev = cpNodeB;
+
+	cpNodeB1.next = cpNodeB2;
+	cpNodeB2.prev = cpNodeB1;
 }
 
 

package/src/find-2-prong/add-debug-info.ts

@@ -1,11 +1,7 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { Debug } from '../debug/debug.js';
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { Circle } from '../geometry/circle.js';
 import { CpNode } from '../cp-node/cp-node.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CurvePiece } from '../mat/bezier-piece.js';
 import { TwoProngForDebugging } from '../debug/two-prong-for-debugging.js';
 import { getTwoProngType } from '../mat/get-two-prong-type.js';
 import { ElemType_TwoProng } from '../mat/elem-type-two-prong.js';
@@ -14,7 +10,7 @@ import { TXForDebugging } from './x-for-debugging.js';
 
 /** @internal */
 function addDebugInfo(
-        bezierPieces: BezierPiece[],
+        bezierPieces: CurvePiece[],
         failed: boolean, 
         x: number[],
         y: PointOnShape,
@@ -24,25 +20,25 @@ function addDebugInfo(
         xs: TXForDebugging[], 
         holeClosing: boolean) {
 
-    xs.push({ x, y, z, t: y.t });
-
-    const twoProng: TwoProngForDebugging = {
-            generated: _debug_.generated,
-            bezierPieces,
-            pos: y,
-            δ,
-            z: z ? z.p : undefined!,
-            circle,
-            xs,
-            failed,
-            holeClosing,
-            notAdded: false,
-            deleted: false,
-            cpNode: undefined!
-    };
-
-    const twoProngType = getTwoProngType(twoProng) as ElemType_TwoProng;
-    _debug_.generated.elems[twoProngType].push(twoProng);
+//     xs.push({ x, y, z, t: y.t });
+
+//     const twoProng: TwoProngForDebugging = {
+//             generated: _debug_.generated,
+//             bezierPieces,
+//             pos: y,
+//             δ,
+//             z: z ? z.p : undefined!,
+//             circle,
+//             xs,
+//             failed,
+//             holeClosing,
+//             notAdded: false,
+//             deleted: false,
+//             cpNode: undefined!
+//     };
+
+//     const twoProngType = getTwoProngType(twoProng) as ElemType_TwoProng;
+//     _debug_.generated.elems[twoProngType].push(twoProng);
 }
 
 

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -0,0 +1,121 @@
+import { ddAddDd, ddMultDd, twoSum, twoProduct, ddDiffDd, ddDivDd, twoDiff, ddMultDouble1 } from 'double-double';
+
+const ts = twoSum;
+const tp = twoProduct;
+const td = twoDiff;
+const qaq = ddAddDd;
+const qmq = ddMultDd;
+const qdq = ddDiffDd;
+const qmd = ddMultDouble1;
+
+const { asin, acos, cos, sqrt, PI: π } = Math;
+
+
+/**
+ * Calculates and returns an appropriate seperation tolerance between `CpNode`s.
+ * 
+ * @param R radius of the circle implied by the curvature at the boundary
+ * @param r radius of the MAT circle
+ * @param θ angle between point...
+ */
+function calcSeperationTolerance2(
+        R: number,
+        r: number,
+        δ: number) {
+
+    const a = r + δ;
+    if (a >= R) {
+        return Number.POSITIVE_INFINITY;
+    }
+
+    const b = R - r;  //?
+    const c = R;      //?
+    
+    const N = c*c - a*a - b*b;  //?
+    const N_ = qdq(qdq(tp(c,c), tp(a,a)), tp(b,b));
+    const D = 2*a*b;            //?
+    const D_ = tp(-2*a,b);
+    const Q = ddDivDd(N_,D_)[1];  //?
+    const cosC = -N/D;  //?
+    const C = acos(cosC);
+    const CC = acos(Q);
+
+    const θ = π - CC;  //?
+
+    return θ;
+    // return r*θ;  // approximate arc with line
+}
+
+
+export { calcSeperationTolerance }
+
+function degToRad(degrees: number) {
+    return degrees/360*2*Math.PI;
+}
+function radToDeg(rad: number) {
+    return rad*360/2/Math.PI;
+}
+
+
+const R = 699;
+const r = 698;
+const δ = 1000*2**-46; //?
+calcSeperationTolerance(R,r,δ);   //?
+calcSeperationTolerance2(R,r,δ);  //?
+calcSeperationTolerance3(R,r,δ);  //?
+
+function calcSeperationTolerance(
+        R: number,
+        r: number,
+        δ: number) {
+
+    const a = r + δ;
+    if (a >= R) {
+        return Number.POSITIVE_INFINITY;
+    }
+
+
+    const R_r_ = twoDiff(R,r);  //?
+    const A_  = qmd(r,R_r_);    //?
+    const N_ = qdq(qdq(A_, tp(r,δ)), tp(δ,δ/2));  //?
+    const D_ = qaq(A_,qmd(δ,R_r_));  //?
+
+    const R_r = R - r; //?
+    const A = r*R_r;   //?
+    const N = A - r*δ - (δ*δ)/2;  //?
+    const D = A + R_r*δ;      //?
+    const cosC = N/D;      //?
+    const Q = ddDivDd(N_,D_)[1];//?
+    // const Q = N_[1]/D_[1];//?
+    const C = acos(cosC);
+    const CC = acos(Q)
+
+    const θ = CC;  //?
+
+    // return r*θ;
+    return r*θ;
+}
+
+
+// * see https://en.wikipedia.org/wiki/Law_of_cosines, Version suited to small angles
+function calcSeperationTolerance3(
+        R: number,
+        r: number,
+        δ: number) {
+
+    const a = r + δ;  //?
+    const c = R - r;  //?
+    const b = R;      //?
+    
+    // c² = (a - b)² + 4ab*sin²(θ/2) OR
+    // (c² - (a - b)²)/4ab = sin²(θ/2)
+    const cc = c*c;  //? 
+    const abc = a*a + b*b - 2*a*b;  //?
+    const A = cc - abc;  //?
+    const B = sqrt(A/(4*a*b));  //?
+
+    const θ = 2*asin(B);  //?
+
+    return θ;
+    // return r*θ;  // approximate arc with line
+}

package/src/find-2-prong/cull-bezier-pieces.ts

@@ -1,6 +1,6 @@
 import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
-import { BezierPiece } from '../mat/bezier-piece.js';
-import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
+import { CurvePiece } from '../mat/curve-piece.js';
+import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
 
 
 /**
@@ -12,7 +12,7 @@ import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
  * @param rSquared
  */
 function cullBezierPieces2(
-        bezierPieces: BezierPiece[], 
+        bezierPieces: CurvePiece[], 
         p: number[], 
         rSquared: number) {
 
@@ -27,7 +27,7 @@ function cullBezierPieces2(
     for (const bezierPiece of bezierPieces) {
         const ps = bezierPiece.curve.ps;
         
-        const rect = getBoundingBox_(ps);
+        const rect = getBoundingBox$(ps);
         const bd = getClosestSquareDistanceToRect(rect, p);
         if (bd <= TOLERANCE*rSquared) {
             newPieces.push(bezierPiece);