flo-mat 2.0.4 → 3.0.0

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

@@ -0,0 +1,70 @@
+import { getObjClosestTo } from 'flo-vector2d';
+import { Curve } from '../curve/curve.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { createPos } from '../point-on-shape/create-pos.js';
+import { BezierPiece  } from '../mat/bezier-piece.js';
+import { cullBezierPieces1 } from './cull-bezier-pieces.js';
+import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
+import { squaredDistanceBetweenDd } from '../find-2-prong/squared-distance-between-dd.js';
+
+
+/**
+ * @internal
+ * 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 x
+ * @param touchedCurve
+ * @param t
+ * @param extreme
+ */
+function getClosestBoundaryPointCertified(
+		angle: number,
+        bezierPieces: BezierPiece[], 
+        x: number[], 
+		touchedCurve: Curve, 
+		t: number,
+		for1Prong: boolean) {
+	
+	bezierPieces = cullBezierPieces1(bezierPieces, x);
+ 
+	let bestDistance = Number.POSITIVE_INFINITY;
+	let pos: PointOnShape;
+	for (let i=0; i<bezierPieces.length; i++) {
+		const bezierPiece = bezierPieces[i];
+
+        const ps = getPotentialClosestPointsOnCurveCertified(
+            bezierPiece.curve, 
+            x, 
+            bezierPiece.ts, 
+            touchedCurve, 
+            t,
+			for1Prong,
+			angle
+        );
+
+		const p = getObjClosestTo(x, ps, p => p.p)
+
+		if (p === undefined) { continue; }
+
+		const d = squaredDistanceBetweenDd(p.p, x);
+
+		let curve = bezierPiece.curve;
+		let t_= p.t;
+
+		if (d < bestDistance) {
+			if (t_ === 0) {
+				t_ = 1;
+				curve = bezierPiece.curve.prev;
+			}
+			
+			pos = createPos(curve, t_, false);
+			bestDistance = d;
+		}
+	}
+
+	return pos!;
+}
+
+
+export { getClosestBoundaryPointCertified };

package/src/closest-boundary-point/get-p-from-box.ts

@@ -0,0 +1,14 @@
+
+/** @internal */
+function getPFromBox(box: number[][]) {
+    const tl = box[0];
+    const br = box[1];
+
+    return [
+        (tl[0] + br[0])/2,
+        (tl[1] + br[1])/2,
+    ];
+}
+
+
+export { getPFromBox }

package/src/closest-boundary-point/get-potential-closest-points-on-curve-certified.ts

@@ -0,0 +1,122 @@
+import { allRootsCertified } from 'flo-poly';
+import { getFootPointsOnBezierPolysCertified, getIntervalBox } from 'flo-bezier3';
+import { Curve } from "../curve/curve.js";
+import { ddDeflateWithRunningError } from './dd-deflate-with-running-error.js';
+import { eDeflate } from 'flo-poly';
+import { γγ } from '../error-analysis/gamma.js';
+import { rootIntervalToDistanceSquaredInterval } from './root-interval-to-distance-squared-interval.js';
+import { getPFromBox } from './get-p-from-box.js';
+import { FootAndEndpointInfo } from './foot-and-endpoint-info.js';
+
+
+const γγ3 = γγ(3);
+
+const { sqrt } = Math;
+
+
+/**
+ * @internal
+ * @param curve The curve
+ * @param x 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 getPotentialClosestPointsOnCurveCertified(
+        curve: Curve, 
+        x: number[], 
+        [tS,tE]: number[] = [0,1], 
+        touchedCurve: Curve | undefined = undefined,
+        t: number | undefined = undefined,
+        for1Prong = false,
+        angle = 0): FootAndEndpointInfo[] {
+
+    const ps = curve.ps;
+
+    const shouldDeflate = angle === 0 && curve === touchedCurve;
+
+    let { polyDd: polyDdO, polyE: polyEO, getPolyExact: getPolyExactO } =
+        getFootPointsOnBezierPolysCertified(ps, x);
+    
+    const def = shouldDeflate
+            ? ddDeflateWithRunningError(polyDdO, polyEO.map(e => e/γγ3), t!)
+            : undefined;
+    
+    const def2 = for1Prong && shouldDeflate
+            ? ddDeflateWithRunningError(def!.coeffs, def!.errBound.map(e => e/γγ3), t!)
+            : undefined;
+
+    const def3 = for1Prong && shouldDeflate
+            ? ddDeflateWithRunningError(def2!.coeffs, def2!.errBound.map(e => e/γγ3), t!)
+            : undefined;
+    
+    const { polyDd, polyE, getPolyExact } = 
+              def3 !== undefined
+            ? { polyDd: def3.coeffs, polyE: def3.errBound.map(e => e/γγ3), getPolyExact:  () => eDeflate(eDeflate(eDeflate(getPolyExactO(), t!), t!), t!) }
+            : def !== undefined
+            ? { polyDd: def.coeffs, polyE: def.errBound.map(e => e/γγ3), getPolyExact: () => eDeflate(getPolyExactO(), t!) }
+            : { polyDd: polyDdO, polyE: polyEO, getPolyExact: getPolyExactO };
+    
+    const ris = allRootsCertified(polyDd, tS, tE, polyE, getPolyExact);
+
+    const dontPush0 = (
+        (t === 1 && curve === touchedCurve!.next) ||
+        (t === 0 && curve === touchedCurve)
+    );
+    const dontPush1 = (
+        (t === 0 && curve === touchedCurve!.prev) ||
+        (t === 1 && curve === touchedCurve)
+    );
+
+    if (tS === 0) {
+        if (!dontPush0) { ris.push({ tS: 0, tE: 0, multiplicity: 1 }); }
+    } else if (tS === 1) {
+        if (!dontPush1) { ris.push({ tS: 1, tE: 1, multiplicity: 1 }); }
+    } else {
+        ris.push({ tS: tS, tE: tS, multiplicity: 1 });
+    }
+
+    if (tE === 0) {
+        if (!dontPush0) { ris.push({ tS: 0, tE: 0, multiplicity: 1 }); }
+    } else if (tE === 1) {
+        if (!dontPush1) { ris.push({ tS: 1, tE: 1, multiplicity: 1 }); }
+    } else {
+        ris.push({ tS: tE, tE: tE, multiplicity: 1 });
+    }
+
+    const infos = ris
+    .map(ri => {
+        const { tS: ts, tE: te } = ri;
+
+        if (te < tS || ts > tE) {
+            return undefined;
+        }
+
+        const _t = (ts + te)/2;
+        const t = _t < 0 ? 0 : _t > 1 ? 1 : _t;
+
+        const box = getIntervalBox(ps, [ts, te]);
+        const p_ = getPFromBox(box);
+        
+        const dSquaredI = rootIntervalToDistanceSquaredInterval(box, x);
+
+        const t_ = t === 0 ? 1 : t;
+        const curve_ = t === 0 ? curve.prev : curve;
+
+        return {
+            curve: curve_,
+            p: p_,
+            t: t_,
+            d: (sqrt(dSquaredI[0]) + sqrt(dSquaredI[1]))/2,
+            dSquaredI,
+            box,
+        }
+    });
+
+    const infos_ = infos.filter(info => info !== undefined) as FootAndEndpointInfo[];
+
+    return infos_;
+}
+
+
+export { getPotentialClosestPointsOnCurveCertified }

package/src/closest-boundary-point/root-interval-to-distance-squared-interval.ts

@@ -0,0 +1,75 @@
+import { twoDiff, eEstimate, eMult, eAdd } from 'big-float-ts';
+
+
+// We *have* to do the below to improve performance with bundlers❗ The assignee is a getter❗ The assigned is a pure function❗
+const estimate = eEstimate;
+const td = twoDiff;
+const emult = eMult;
+const eadd = eAdd;
+
+const eps = Number.EPSILON;
+
+
+/**
+ * Returns the distance interval squared given the root interval (currently
+ * ignoring multiplicity). 
+ * 
+ * * the result is returned as `[minPossibleSquared, maxPossibleSquared]` distance.
+ * 
+ * @param box
+ * @param p
+ * 
+ * @internal
+ */
+function rootIntervalToDistanceSquaredInterval(
+        box: number[][], 
+        p: number[]) {
+
+    const bl = box[0];
+    const tr = box[1];
+    const minX = bl[0];
+    const minY = bl[1];
+    const maxX = tr[0];
+    const maxY = tr[1];
+
+    const x = p[0];  // <0>
+    const y = p[1];  // <0>
+
+    let minDSquared = Number.POSITIVE_INFINITY;
+    let maxDSquared = Number.NEGATIVE_INFINITY;
+
+    // for each corner of the interval box
+    for (const [a,b] of [[minX,minY],[minX,maxY],[maxX,minY],[maxX,maxY]]) {
+        /*
+        // distance to 1st corner of interval box - `distance² = x² + y²`
+        const dc1 = (a - x)**2 + (b - y)**2;
+        // max absolute roundoff error of `dc1`
+        // <4>dc1 <-- <4>(<3>(<1>(a - x)**2) + <3>(<1>((b - y)**2))
+        const dc1E = 4*γ1*((a + x)**2 + (b + y)**2);
+        const dc1Min = dc1 - dc1E;  // distance minus max error
+        const dc1Max = dc1 + dc1E;  // distance plus max error
+        */
+
+        /** distance to 1st corner of interval box - `distance² = x² + y²` */
+        const ax = td(a,x);  // a - x
+        const by = td(b,y);  // b - y
+        const dc1Exact = eadd(emult(ax,ax),emult(by,by));  // ax**2 + bx**2
+        const dc1 = estimate(dc1Exact);
+
+        const dc1Min = dc1*(1 - eps);  // distance minus max error
+        const dc1Max = dc1*(1 + eps);  // distance plus max error
+        
+        if (dc1Min <= minDSquared) {
+            minDSquared = dc1Min;
+        }
+
+        if (dc1Max >= maxDSquared) {
+            maxDSquared = dc1Max;
+        }
+    }
+
+    return [minDSquared,maxDSquared];
+}
+
+
+export { rootIntervalToDistanceSquaredInterval }

package/src/{contact-point.ts → contact-point/contact-point.ts}

@@ -1,5 +1,6 @@
-import { comparePoss, IPointOnShape } from './point-on-shape.js';
-import { Circle } from './circle.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { comparePoss } from '../point-on-shape/compare-poss.js';
+import { Circle } from '../geometry/circle.js';
 
 
 /**
@@ -8,7 +9,7 @@ import { Circle } from './circle.js';
  */
 interface ContactPoint {
 	/** Identifies the point on the shape boundary. */
-	pointOnShape: IPointOnShape;
+	pointOnShape: PointOnShape;
 	/** The maximal disk circle touching this point. */
 	circle: Circle;
 	/** Internally used to order two points lying at the same planar point. */
@@ -27,11 +28,8 @@ interface ContactPoint {
  * @param b The second contact point.
  */
 function compareCps(a: ContactPoint, b: ContactPoint) {
-	//let res = PointOnShape.compare(a.pointOnShape, b.pointOnShape);
 	let res = comparePoss(a.pointOnShape, b.pointOnShape);
 
-	if (res === undefined) { return undefined; }
-	
 	if (res !== 0) { return res; }
 
 	res = a.order - b.order;

package/src/{compare-curvatures-at-interface.ts → corner/compare-curvatures-at-interface.ts}

@@ -125,8 +125,8 @@ function compareCurvaturesAtInterface(
     // <=> i²b⁵ > j²d⁵
 
     // Get x′′′ and y′′′ for incoming curve evaluated at 1
-    const [dddxI, dddyI] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
-    const [dddxO, dddyO] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
+    const [[dddxI], [dddyI]] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
+    const [[dddxO], [dddyO]] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
 
     const e = eDiff(
         twoProduct(dxI, dddyI),

package/src/{mat → corner}/corner.ts

@@ -1,6 +1,6 @@
 
 /**
- * @hidden
+ * @internal
  * Represents a corner on the shape boundary, i.e. a point where two bezier
  * curves meet. Typically used internally only.
  */

package/src/{curve.ts → corner/get-corner.ts}

@@ -1,39 +1,10 @@
-import { memoize } from 'flo-memoize';
-import { cross, dot, toUnitVector } from 'flo-vector2d';
+import { cross, dot, toUnitVector } from "flo-vector2d";
+import { Corner } from "./corner";
 import { getInterfaceCcw } from './get-interface-ccw.js';
-import { Loop } from './loop.js';
-import { Corner } from './mat/corner.js';
-
-
-/**
- * Represents a bezier curve on the shape boundary / loop.
- */
-interface Curve {
-
-	/** 
-	 * Primarily for internal use.
-	 * @param loop The closed loop of bezier curves representing the shape 
-	 * boundary this curve belongs to.
-	 * @param ps The bezier control points.
-	 * @param prev The previous curve (when going in a negative direction around
-	 * the shape boundary, i.e. clockwise for the outer shape and anti-clockwise
-	 * for the holes (if any)).
-	 * @param next The next curve (when going in a positive direction around
-	 * the shape boundary, i.e. anti-clockwise for the outer shape and clockwise
-	 * for the holes (if any)).
-	 * @param idx The curve's ordered index in the loop. This imposes a cycling
-	 * ordering of the curves in the loop.
-	 */
-	loop : Loop;
-	ps   : number[][];
-	prev : Curve; 
-	next : Curve;
-	idx  : number;
-}
 
 
 /** 
- * @hidden
+ * @internal
  * Angle in degrees to radians.
  */
 const DEGREES = {
@@ -45,14 +16,14 @@ const DEGREES = {
 };
 
 
-/** @hidden */
+/** @internal */
 //const DEGREE_LIMIT = DEGREES[1];
 const DEGREE_LIMIT = DEGREES[4]; 
 //const DEGREE_LIMIT = DEGREES[16]; 
 
 
 /**
- * @hidden
+ * @internal
  * Returns a new corner with properties.
  * 
  * PRECONDITION: The beziers has control points with max bit-length of 26 and
@@ -63,7 +34,10 @@ const DEGREE_LIMIT = DEGREES[4];
  * @param psI The incoming bezier that ends in the corner
  * @param psO The outgoing bezier that starts at the corner
  */
-function getCorner(psI: number[][], psO: number[][]): Corner {
+function getCorner(
+		psI: number[][],
+		psO: number[][]): Corner {
+
 	// getInterfaceCcw must return a number !== 0 if psI and psO are not the
 	// same as seen as a curve extension with t ∈ [-∞,+∞]
 	const ccw = getInterfaceCcw(psI, psO);
@@ -117,17 +91,4 @@ function getCorner(psI: number[][], psO: number[][]): Corner {
 }
 
 
-/**
- * @hidden
- * Returns information about the corner created at the end of this curve 
- * (at t === 1) and the start of the next curve (at t === 0).
- */
-const getCornerAtEnd = memoize(function(curve: Curve) {
-	const psE = curve.ps;
-	const psS = curve.next.ps;
-
-	return getCorner(psE, psS);
-});
-
-
-export { Curve, getCorner, getCornerAtEnd }
+export { getCorner }

package/src/{get-interface-ccw.ts → corner/get-interface-ccw.ts}

@@ -1,4 +1,4 @@
-import { orient2d } from 'big-float-ts';
+import { eAdd, eEstimate, eMult, eNegativeOf, eProduct, orient2d, twoDiff } from 'big-float-ts';
 import { dot } from "flo-vector2d";
 import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
 
@@ -36,32 +36,6 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     // second control point of outgoing curve
     const p2 = psO[1];
 
-    /*
-    if (typeof _bez_debug_ !== 'undefined') {
-        let maxBitLength = 25;
-        let p1_ = psI[lenI-1];
-        // ---- precondition: does endpoints coincide
-        if (p1_[0] !== p1[0] || p1_[1] !== p1[1]) {
-            throw new Error('Curve endpoints must coincide.');
-        }
-        // ---- precondition: are coordinates grid-aligned
-        // Get all coordinate values into an array
-        let xs: number[] = [];
-        [psI, psO].forEach(ps => ps.forEach(p => p.forEach(x => {
-            xs.push(x); 
-        })));
-        
-        let msb = xs.reduce((prevX, x) => Math.max(prevX, msbExponent(x)), Number.NEGATIVE_INFINITY);
-        let lsb = xs.reduce((prevX, x) => Math.min(prevX, lsbExponent(x)), Number.POSITIVE_INFINITY);
-        let bitlengthAll = msb - lsb + 1;
-        if (bitlengthAll > maxBitLength) {
-            throw new Error(
-                `Curve control point coordinates must be bit-aligned and <= ${maxBitLength}. bitlength === ${bitlengthAll}, coordinates: ${xs}`
-            );
-        }
-    }
-    */
-
     // Max one bit can be added in the calculations below due to bit-alignment
     const xE = p1[0] - p0[0];  // tangent x-coordinate
 	const yE = p1[1] - p0[1];  // tangent y-coordinate
@@ -76,20 +50,15 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
     // (non-normalized) tangent of outgoing curve at t === 0
 	const tangentAtStart = [xS,yS];
 
-    // The cross calculated below will have a max bitlength of 
-    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
-    // If the preconditions are met it is exact
-    //let crossTangents = cross(tangentAtEnd, tangentAtStart);
-    
-    // The cross below is exact by adaptive infinite precision
-    const crossTangents = orient2d(p0, p1, p2);
+    // const crossTangents = orient2d(p0, p1, p2);
+    const crossTangents = orient2dPrecise(p0, p1, p2);
 
 	if (crossTangents !== 0) {
 		return crossTangents;
     } 
     
     // The dot calculated below will have a max bitlength of 
-    // (2*(maxBitLength+1))+1 === e.g. (2*(25+1)) + 1 === 53
+    // (2*(maxBitLength + 1)) + 1 === e.g. (2*(25 + 1)) + 1 === 53
     // If the preconditions are met it is exact
     const dotTangents = dot(tangentAtEnd, tangentAtStart);
     if (dotTangents > 0) {
@@ -109,4 +78,28 @@ function getInterfaceCcw(psI: number[][], psO: number[][]) {
 }
 
 
+/** Returns the cross from A to B to C */
+function orient2dPrecise(
+        A: number[],
+        B: number[],
+        C: number[]) {
+
+    // const detleft  = (A[0] - C[0]) * (B[1] - C[1]);
+    // const detright = (A[1] - C[1]) * (B[0] - C[0]);
+    // const det = detleft - detright;
+
+    const a = twoDiff(A[0],C[0]);
+    const b = twoDiff(B[1],C[1]);
+    const c = twoDiff(A[1],C[1]);
+    const d = twoDiff(B[0],C[0]);
+
+    const e = eMult(a,b);
+    const f = eMult(c,d);
+
+    const g = eAdd(e,eNegativeOf(f));
+
+    return eEstimate(g);
+}
+
+
 export { getInterfaceCcw }

package/src/cp-node/clone.ts

@@ -1,14 +1,15 @@
-import { CpNode } from "../cp-node.js";
+import { CpNode } from "./cp-node.js";
+import { createCpNode } from "./create-cp-node.js";
 
 
-/** @hidden */
+/** @internal */
 type Edge =
     | 'prev'
 	| 'next'
 	| 'prevOnCircle'
 	| 'nextOnCircle';
 
-/** @hidden */
+/** @internal */
 const EDGES: Edge[] = ['prev', 'next', 'prevOnCircle', 'nextOnCircle'];
 
 
@@ -23,19 +24,29 @@ function clone(cpNode: CpNode): CpNode {
 
     const nodeMap: Map<CpNode, CpNode> = new Map();
 
-    const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
+    // const newCpNode = new CpNode(cpNode.cp, cpNode.isHoleClosing, cpNode.isIntersection);
+    const newCpNode = createCpNode(
+        cpNode.cp,
+        cpNode.isHoleClosing,
+        cpNode.isIntersection
+    );
 
     nodeMap.set(cpNode, newCpNode);
     const cpStack = [{ cpNode, newCpNode }];
 
     while (cpStack.length) {
-        const { cpNode, newCpNode } = cpStack.pop();
+        const { cpNode, newCpNode } = cpStack.pop()!;
 
         for (const edge of EDGES) {
             const node = cpNode[edge];
             let newNode = nodeMap.get(node);
             if (!newNode) {	
-                newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);
+                // newNode = new CpNode(node.cp, node.isHoleClosing, node.isIntersection);
+                newNode = createCpNode(
+                    node.cp,
+                    node.isHoleClosing,
+                    node.isIntersection,
+                );
                 nodeMap.set(node, newNode);
                 cpStack.push({cpNode: node, newCpNode: newNode });
             }