flo-mat 2.0.4 → 3.0.0

package/src/mat/closest-boundary-point/closest-point-on-curve.ts_

@@ -1,95 +0,0 @@
-
-import { deflate, allRootsPrecise, allRootsMultiWithErrBounds, toCasStr } from 'flo-poly';
-
-import { getObjClosestTo } from 'flo-vector2d';
-import { evaluate, getTangentPolyFromPoint, getTangentPolyFromPointExact } from 'flo-bezier3';
-import { estimate } from 'flo-numerical';
-
-import { Curve } from "../../curve";
-
-
-/** @hidden */
-// TODO - remove delta
-let DELTA = 1e-11;
-
-
-/**
- * @hidden
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointOnCurve(
-        curve: Curve, 
-        p: number[], 
-        [tS,tE]: number[] = [0,1], 
-        touchedCurve?: Curve,
-        t?: number) {
-
-    let poly = getTangentPolyFromPointExact(curve.ps, p);
-
-    //if (curve === touchedCurve) {
-    //    poly = deflate(poly, t);
-    //}
-
-    let roots = allRootsMultiWithErrBounds(
-        poly, 
-        poly.map(c => 0),  // because all coefficients are exact
-        () => [],           // ...
-        tS,
-        tE
-    ).map(t => t.tM);
-
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-
-    if (tS === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tS === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tS);
-    }
-
-    if (tE === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tE === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tE);
-    }
-
-    // This is to take care of a numerical issue - see shape p1.svg.
-    //let roots_: number[] = [];
-    //for (let i=0; i<roots.length; i++) {
-    //    let root = roots[i];
-    //    if (root !== 0 && root < DELTA) {
-    //        root = 0;
-    //    } else if (root !== 1 && 1-root < DELTA) {
-    //        root = 1;
-    //    }
-    //    roots_.push(root);
-    //}
-
-    let ev = evaluate(curve.ps);
-    //let ps = roots_.map(
-    let ps = roots.map(
-        root => ({ p: ev(root), t: root })
-    );
-
-    return getObjClosestTo(p, ps, p => p.p);
-}
-
-
-export { closestPointOnCurve }

package/src/mat/closest-boundary-point/closest-points-on-curve.ts

@@ -1,84 +0,0 @@
-// qqq import { deflateQuad, allRootsMultiWithErrBounds, RootInterval } from 'flo-poly';
-// qqq import { getTangentPolyFromPointExact, evalDeCasteljau, evaluate, getFootpointPolyExact } from 'flo-bezier3';
-import { ddDeflate, allRootsCertified, RootInterval } from 'flo-poly';
-import { evalDeCasteljau, evaluate, getFootpointPolyDd, getFootpointPolyExact } from 'flo-bezier3';
-import { Curve } from "../../curve.js";
-import { eToDd } from 'big-float-ts';
-
-
-/**
- * @hidden
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointsOnCurve(
-        curve: Curve, 
-        p: number[], 
-        [tS,tE]: number[] = [0,1], 
-        touchedCurve: Curve,
-        t: number): {
-            p: number[];
-            t: number;
-        }[] {
-
-    // qqq let poly = getTangentPolyFromPointExact(curve.ps, p);
-    const _poly = getFootpointPolyDd(curve.ps, p);
-
-    // qqq poly = deflateQuad(poly, t);
-    const poly = curve === touchedCurve
-        ? ddDeflate(_poly, t)
-        : _poly;
-
-    // let roots: Omit<RootInterval,'multiplicity'>[] = allRootsMultiWithErrBounds(
-    const roots: Omit<RootInterval,'multiplicity'>[] = allRootsCertified(poly, tS, tE);
-
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-
-    if (tS === 0) {
-        if (push0) { roots.push({ tS: 0, tE: 0 }); }
-    } else if (tS === 1) {
-        if (push1) { roots.push({ tS: 1, tE: 1 }); }
-    } else {
-        roots.push({ tS: tS, tE: tS });
-    }
-
-    if (tE === 0) {
-        if (push0) { roots.push({ tS: 0, tE: 0 }); }
-    } else if (tE === 1) {
-        if (push1) { roots.push({ tS: 1, tE: 1 }); }
-    } else {
-        roots.push({ tS: tE, tE: tE });
-    }
-
-    const ps = roots.map(
-        root => { 
-            const tS = root.tS;
-            const tE = root.tE;
-            // TODO - tS, tE should always stay within [0,1] - modify findRootsMulti
-            const t = tS < 0 
-                ? 0
-                : tE > 1 ? 1 : (tS + tE)/2;
-            // TODO - why does evalDeCasteljau not work here?
-            return { p: evaluate(curve.ps,t), t }
-            //return { p: evalDeCasteljau(curve.ps,t), t }
-        }
-    );
-
-    return ps;
-}
-
-
-export { closestPointsOnCurve }

package/src/mat/closest-boundary-point/cull-bezier-pieces.ts

@@ -1,38 +0,0 @@
-import { BezierPiece } from '../bezier-piece.js';
-import { getBestDistanceSquared } from './get-best-distance-squared.js';
-import { cullByLooseBoundingBox } from './cull-by-loose-bounding-box.js';
-import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
-
-
-/**
- * @hidden
- * @param bezierPieces 
- * @param p 
- * @param extreme
- */
-function cullBezierPieces(
-        bezierPieces: BezierPiece[],
-        p: number[]) {
-
-    const CULL_THRESHOLD = 0;
-
-    if (bezierPieces.length > CULL_THRESHOLD) {
-        const bestSquaredDistance = getBestDistanceSquared(
-            bezierPieces, p
-        );
-        bezierPieces = cullByLooseBoundingBox(
-            bezierPieces, p,
-            bestSquaredDistance
-        );
-        
-        bezierPieces = cullByTightBoundingBox(
-            bezierPieces, p,
-            bestSquaredDistance
-        );
-    }
-
-    return bezierPieces;
-}
-
-
-export { cullBezierPieces }

package/src/mat/closest-boundary-point/get-close-boundary-points.ts

@@ -1,107 +0,0 @@
-import { distanceBetween } from 'flo-vector2d';
-import { IPointOnShape, PointOnShape } from '../../point-on-shape.js';
-import { BezierPiece  } from '../bezier-piece.js';
-import { cullBezierPieces } from './cull-bezier-pieces.js';
-import { closestPointsOnCurve } from './closest-points-on-curve.js';
-  
-
-/**
- * @hidden
- * Returns the closest boundary point to the given point, limited to the given 
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param point
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-function getCloseBoundaryPoints(
-        bezierPieces: BezierPiece[], 
-        point: number[], 
-		y: IPointOnShape,
-		distance: number) {
-	
-	const touchedCurve = y.curve;
-	const t = y.t;
-	const p_ = y.p;
-
-	bezierPieces = cullBezierPieces(bezierPieces, point);
- 
-	// TODO - integrate with is-another-cp-closeby - we MUST check angle too!
-	const DISTANCE_TOLERANCE = 1e-9;
-	const posInfos: { pos: IPointOnShape; d: number }[] = [];
-	for (let i=0; i<bezierPieces.length; i++) {
-		const bezierPiece = bezierPieces[i];
-
-		// TOOD - important - should be able to return multiple points
-		const ps = closestPointsOnCurve(
-				bezierPiece.curve, 
-				point, 
-				bezierPiece.ts, 
-				touchedCurve, 
-				t
-		);
-
-		//if (ps === undefined) { continue; }
-
-		for (let j=0; j<ps.length; j++) {
-			const p = ps[j];
-			const d = distanceBetween(p.p, point);
-
-			let curve = bezierPiece.curve;
-			let t_= p.t;
-	
-			if (Math.abs(d-distance) < DISTANCE_TOLERANCE) {
-				if (t_ === 0) {
-					t_ = 1;
-					curve = bezierPiece.curve.prev;
-				}
-				
-				posInfos.push({ pos: new PointOnShape(curve, t_), d });
-			}
-		}
-	}
-
-	if (posInfos.length > 1) {
-		// Remove ones that are too close together.
-		// TODO - in future remove all these checks and join n-prongs when they
-		// are being added - much simpler and more symmetric. Remeber order when
-		// comparing closeness!
-		const indexesToCheck: number[] = [];
-		for (let i=0; i<posInfos.length; i++) {
-			const pi = posInfos[i];
-			// Only check if they are close to the edges. Why??
-			//if (pi.pos.t < 1e-2 || 1-pi.pos.t < 1e-2) {
-				indexesToCheck.push(i);
-			//}
-		}
-		const indexesToRemove: number[] = [];
-		for (let i=0; i<indexesToCheck.length; i++) {
-			for (let j=i+1; j<indexesToCheck.length; j++) {
-				if (i === j) { continue; }
-				const p1 = posInfos[indexesToCheck[i]].pos.p;
-				const p2 = posInfos[indexesToCheck[j]].pos.p;
-				// Below checks for source point too - similar to 
-				// isAnotherCpCloseBy
-				const p3 = p_;
-				if ((Math.abs(p1[0] - p2[0]) < 1e-6 && 
-					 Math.abs(p1[1] - p2[1]) < 1e-6) ||
-					
-					 (Math.abs(p1[0] - p3[0]) < 1e-6 && 
-					  Math.abs(p1[1] - p3[1]) < 1e-6)
-					) {
-
-					indexesToRemove.push(indexesToCheck[i]);
-				}
-			}
-		}
-		for (let i=indexesToRemove.length -1; i >= 0; i--) {
-		   posInfos.splice(indexesToRemove[i], 1);
-		}
-	}
-
-	return posInfos;
-}
-
-
-export { getCloseBoundaryPoints };

package/src/mat/closest-boundary-point/get-closest-boundary-point.ts

@@ -1,64 +0,0 @@
-import { distanceBetween, getObjClosestTo } from 'flo-vector2d';
-import { Curve } from '../../curve.js';
-import { PointOnShape, IPointOnShape } from '../../point-on-shape.js';
-import { BezierPiece  } from '../bezier-piece.js';
-import { cullBezierPieces } from './cull-bezier-pieces.js';
-import { closestPointsOnCurve } from './closest-points-on-curve.js';
-  
-
-/**
- * @hidden
- * Returns the closest boundary point to the given point, limited to the given 
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param point
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-function getClosestBoundaryPoint(
-        bezierPieces: BezierPiece[], 
-        point: number[], 
-		touchedCurve: Curve, 
-		t: number) {
-	
-	bezierPieces = cullBezierPieces(bezierPieces, point);
- 
-	let bestDistance = Number.POSITIVE_INFINITY;
-	let posInfo: { pos: IPointOnShape; d: number };
-	for (let i=0; i<bezierPieces.length; i++) {
-		const bezierPiece = bezierPieces[i];
-
-		const ps = closestPointsOnCurve(
-				bezierPiece.curve, 
-				point, 
-				bezierPiece.ts, 
-				touchedCurve, 
-				t
-		);
-
-		const p = getObjClosestTo(point, ps, p => p.p)
-
-		if (p === undefined) { continue; }
-
-		const d = distanceBetween(p.p, point);
-
-		let curve = bezierPiece.curve;
-		let t_= p.t;
-
-		if (d < bestDistance) {
-			if (t_ === 0) {
-				t_ = 1;
-				curve = bezierPiece.curve.prev;
-			}
-			
-			posInfo = { pos: new PointOnShape(curve, t_), d };
-			bestDistance = d;
-		}
-	}
-
-	return posInfo;
-}
-
-
-export { getClosestBoundaryPoint };

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

@@ -1,75 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../../cp-node.js';
-import { Loop } from '../../loop.js';
-import { Circle } from '../../circle.js';
-import { IPointOnShape } from '../../point-on-shape.js';
-import { addToCpGraph } from '../add-to-cp-graph.js';
-import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
-
-
-/**
- * @hidden
- * Adds a 3-prong MAT circle according to the 3 given (previously calculated) 
- * points on the shape. 
- * @param cpTrees 
- * @param orders 
- * @param threeProng 
- */
-function add3Prong(
-		cpTrees: Map<Loop,LlRbTree<CpNode>>,
-		orders: number[],
-		threeProng: { 
-    		circle: Circle, 
-			ps: IPointOnShape[],
-			δ3s: CpNode[][]
-		}) {
-	
-	const { circle, ps: poss, δ3s } = threeProng;
-
-	// Keep for possible future debugging.	
-	/*
-	if (typeof _debug_ !== 'undefined') {
-		for (let i=0; i<3; i++) {
-			let cpBef = threeProng.δ3s[i][0].cp;
-			let cpAft = threeProng.δ3s[i][1].cp;
-			//let cmpBef = PointOnShape.compareInclOrder(cpBef.pointOnShape, ps[i], cpBef.order, orders[i]);
-			//let cmpAft = PointOnShape.compareInclOrder(cpAft.pointOnShape, ps[i], cpAft.order, orders[i]); 
-
-			let cmpBef = PointOnShape.compare(cpBef.pointOnShape, ps[i]);
-			let cmpAft = PointOnShape.compare(cpAft.pointOnShape, ps[i]); 
-
-			// len is used by debug functions to reference a particular 
-			// three-prong.
-			let len = _debug_.generated.elems.threeProng.length-1; 
-			if (cmpBef > 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (bef) : i: ${i} - cmp: ${cmpBef} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(ps[i]);
-			}
-			if (cmpAft < 0) {
-				console.log('----------------------------------------');
-				console.log(`3-prong order is wrong (aft) : i: ${i} - cmp: ${cmpAft} - n: ${len}`);
-				console.log(threeProng);
-				console.log(cpBef);
-				console.log(cpAft);
-				console.log(ps[i]);
-			}
-		}
-	}
-	*/
-
-	// TODO - replace 1000 below with correct value
-	isAnotherCpCloseby(cpTrees, poss[0], circle, orders[0], 0, 1000, 'blue');
-	isAnotherCpCloseby(cpTrees, poss[1], circle, orders[1], 0, 1000, 'blue');
-	isAnotherCpCloseby(cpTrees, poss[2], circle, orders[2], 0, 1000, 'blue');
-
-	addToCpGraph(circle, orders, cpTrees, poss, δ3s); 
-
-	return circle;
-}
-
-
-export { add3Prong }

package/src/mat/find-mat/create-get-interesting-points-on-loop.ts

@@ -1,73 +0,0 @@
-import { getCurvatureExtrema, splitByCurvatureAndLength, controlPointLinesLength } from 'flo-bezier3';
-import { getContactCirclesAtInterface } from '../get-contact-circles-at-interface.js';
-import { Loop } from '../../loop.js';
-import { PointOnShape, comparePoss, IPointOnShape } from '../../point-on-shape.js';
-
-
-/**
- * @hidden
- * Get useful points on the shape - these incude points of maximum curvature and 
- * points at the bezier-bezier interfaces.  
- * @param loop
- * @param additionalPointCount 
- */
-function getInterestingPointsOnLoop(
-        minBezLength: number,
-        maxCurviness: number,
-        maxLength: number) {
-
-    return function(loop: Loop) {
-        const allPoints: IPointOnShape[] = [];
-
-        for (let i=0; i<loop.curves.length; i++) {
-            const curve = loop.curves[i];
-
-            // qqq if (lengthSquaredUpperBound(curve.ps) < minBezLength) {
-            if (controlPointLinesLength(curve.ps) < minBezLength) {
-                continue;
-            }
-            
-
-            /*
-            let { maxCurvatureTs, maxNegativeCurvatureTs } = 
-                getCurvatureExtrema(curve.ps);
-            let maxCurvatures = maxCurvatureTs.map(t => new PointOnShape(curve, t));
-            let maxNegativeCurvatures = maxNegativeCurvatureTs.map(t => new PointOnShape(curve, t));
-
-            allPoints.push(
-                ...getContactCirclesAtInterface(curve), 
-                ...maxCurvatures,
-                ...maxNegativeCurvatures
-            );
-            */
-
-            // let { maxima } = getCurvatureExtrema(curve.ps);
-            // qqq let { maxCurvatureTs, maxNegativeCurvatureTs } = getCurvatureExtrema(curve.ps);
-            const { maxima } = getCurvatureExtrema(curve.ps);
-            // let maxAbsCurvatures = maxima.map(t => new PointOnShape(curve, t));
-            // qqq let maxAbsCurvatures = [...maxCurvatureTs, ...maxNegativeCurvatureTs].map(t => new PointOnShape(curve, t));
-            const maxAbsCurvatures = [...maxima].map(t => new PointOnShape(curve, t));
-
-            allPoints.push(
-                ...getContactCirclesAtInterface(curve), 
-                ...maxAbsCurvatures,
-            );
-
-            let ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            if (ts.length === 2) {
-                ts = [0, 0.5, 1];
-            }
-
-            for (let i=1; i<ts.length-1; i++) {
-                allPoints.push( new PointOnShape(curve, ts[i]) );
-            }
-        }
-
-        allPoints.sort(comparePoss);
-
-        return allPoints;
-    }
-}
-
-
-export { getInterestingPointsOnLoop }

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

@@ -1,46 +0,0 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { Debug } from '../../../debug/debug.js';
-import { IPointOnShape } from '../../../point-on-shape.js';
-import { Circle } from '../../../circle.js';
-import { CpNode } from '../../../cp-node.js';
-import { BezierPiece } from '../../bezier-piece.js';
-import { TwoProngForDebugging } from '../../../debug/two-prong-for-debugging.js';
-import { getTwoProngType } from '../../get-two-prong-type.js';
-import { ElemType_TwoProng } from '../../elem-type-two-prong.js';
-import { TXForDebugging } from './x-for-debugging.js';
-
-
-/** @hidden */
-function addDebugInfo(
-        bezierPieces: BezierPiece[],
-        failed: boolean, 
-        pos: IPointOnShape,
-        circle: Circle, 
-        z: IPointOnShape,
-        δ: CpNode[], 
-        xs: TXForDebugging[], 
-        holeClosing: boolean) {
-
-    const twoProng: TwoProngForDebugging = {
-            generated: _debug_.generated,
-            bezierPieces,
-            pos,
-            δ,
-            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);
-}
-
-
-export { addDebugInfo }