flo-mat 2.0.5 → 3.0.0

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,103 +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++) {
-			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-dd.ts

@@ -1,62 +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 getClosestBoundaryPointDd(
-        bezierPieces: BezierPiece[], 
-        point: number[], 
-		touchedCurve: Curve, 
-		t: number) {
-	
-	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 { getClosestBoundaryPointDd };

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/create-get-interesting-points-on-loop.ts

@@ -1,74 +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,
-            );
-
-            const ts = splitByCurvatureAndLength(curve.ps, maxCurviness, maxLength);
-            // if (ts.length > 10) { console.log(ts); }
-            // 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 }