flo-mat 3.0.0 → 3.0.2

package/src/cp-node/fs/get-implied-boundary-bezier-between.ts

@@ -0,0 +1,78 @@
+import { tangent } from 'flo-bezier3';
+import { drawFs } from 'flo-draw';
+import { 
+    fromTo, dot, cross, translate, lineLineIntersection, toUnitVector
+} from 'flo-vector2d';
+import { CpNode } from '../cp-node.js';
+
+
+/** @internal */
+const TOLERANCE_ADD_2PRONG = 0.01;
+/** @internal */
+const TOLERANCE_USE_LINE = 0.0001; // else cubic
+
+
+function getImpliedBoundaryBezierBetween(
+        cpNodeA: CpNode,
+        cpNodeB: CpNode): number[][] | undefined {
+
+    const posA = cpNodeA.cp.pointOnShape;
+    const posB = cpNodeB.cp.pointOnShape;
+
+    let { curve: curveA, p: pA, t: tA } = posA;
+    let { curve: curveB, p: pB, t: tB } = posB;
+
+    if (pA[0] === pB[0] && pA[1] === pB[1]) {
+        return [pA];
+    }
+
+    if (tA === 1) { tA = 0; curveA = curveA.next; }
+    if (tB === 0) { tB = 1; curveB = curveB.prev; }
+    
+    const { ps: psA } = curveA;
+    const { ps: psB } = curveB;
+
+    const lA = [pA,translate(pA)(toUnitVector(tangent(psA, tA)))];
+    const lB = [pB,translate(pB)(toUnitVector(tangent(psB, tB)))];
+
+    const mid = lineLineIntersection(lA, lB);
+
+    const c = fromTo(pA,pB);
+
+    let twisted: boolean;
+    if (!mid) {
+        twisted = true;
+    } else {
+        const a = fromTo(pA, mid);
+        const b = fromTo(pB, mid);
+        
+        twisted = dot(a,c) < 0 || dot(b,c) > 0;
+    }
+    
+    if (!twisted) {
+        // drawFs.bezier(g, [pA, mid!, pB], 'thin10 pink nofill', 0)
+        return [pA, mid!, pB];
+    } 
+        
+    const w1 = fromTo(lA[0], lA[1]);  // This is a unit vector
+    const w2 = fromTo(lB[0], lB[1]);  // This is a unit vector
+
+    const d1 = Math.abs(cross(c, w1)) / (3*3); 
+    const d2 = Math.abs(cross(c, w2)) / (3*3); 
+
+    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
+        // not within tolerance
+        return undefined;
+    } 
+
+    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
+        // approximate with cubic bezier?
+        return undefined;  // add 2-prong
+    } 
+
+    // Within tolerance - approximate with a straight line.
+    return [pA, pB];
+}
+
+
+export { getImpliedBoundaryBezierBetween }

package/src/cp-node/fs/get-mat-curve-between.ts

@@ -0,0 +1,74 @@
+import { 
+    fromTo, dot, cross, rotate90Degrees, interpolate, translate,
+    lineLineIntersection
+} from 'flo-vector2d';
+import { CpNode } from '../cp-node.js';
+import { getEdgeDirection } from './get-edge-direction.js';
+
+
+/** @internal */
+const TOLERANCE_ADD_2PRONG = 0.01;
+/** @internal */
+const TOLERANCE_USE_LINE = 0.0001; // else cubic
+
+
+function getMatCurveBetween(
+        cpNodeFrom: CpNode, 
+        cpNodeTo: CpNode): number[][] {
+
+    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromL = getEdgeDirection(cpNodeFrom);
+
+    const toCc = cpNodeTo.cp.circle.center;
+    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
+
+    const mid = lineLineIntersection(fromL, toL);
+
+    const c = fromTo(fromCc,toCc);
+
+    let twisted: boolean;
+    if (!mid) {
+        twisted = true;
+    } else {
+        const a = fromTo(fromCc, mid);
+        const b = fromTo(toCc,   mid);
+        
+        twisted = dot(a,c) < 0 || dot(b,c) > 0;
+    }
+    
+    if (!twisted) {
+        return [fromCc, mid!, toCc];
+    } 
+        
+    const r = rotate90Degrees(c);
+    const w1 = fromTo(fromL[0], fromL[1]); // This is a unit vector
+    const w2 = fromTo(toL[0],  toL[1]);  // This is a unit vector
+
+    const d1 = Math.abs(cross(c, w1)) / (3*3); 
+    const d2 = Math.abs(cross(c, w2)) / (3*3); 
+
+    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
+        // TODO - not within tolerance - must add additional 2-prong
+        return [fromCc, toCc];
+    } 
+
+    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
+        // approximate with cubic bezier
+        const m1 = interpolate(fromCc,toCc,1/3);
+        const m2 = interpolate(fromCc,toCc,2/3);
+        const v1 = translate(r, m1);
+        const v2 = translate(r, m2);
+        const l1 = [m1,v1];
+        const l2 = [m2,v2];
+        const mid1 = lineLineIntersection(fromL, l1)!;
+        const mid2 = lineLineIntersection(toL,   l2)!;
+
+        return [fromCc, mid1, mid2, toCc];
+    } 
+
+    // Within tolerance - approximate with a straight line.
+    return [fromCc, toCc];
+}
+
+
+export { getMatCurveBetween }

package/src/cp-node/fs/get-mat-curve-to-next.ts

@@ -0,0 +1,13 @@
+import { memoize } from 'flo-memoize';
+import { CpNode } from '../cp-node.js';
+import { getMatCurveBetween } from './get-mat-curve-between.js';
+
+
+function getMatCurveToNext(cpNode: CpNode) {
+	return getMatCurveBetween(cpNode, cpNode.next);
+}
+
+
+const getMatCurveToNext$ = memoize(getMatCurveToNext);
+
+export { getMatCurveToNext, getMatCurveToNext$ }

package/src/cp-node/fs/get-mat-curves-between.ts

@@ -0,0 +1,22 @@
+import { CpNode } from '../cp-node.js';
+import { getMatCurveBetween } from './get-mat-curve-between.js';
+
+
+function getMatCurvesBetween(
+        cpNodeS: CpNode,
+        cpNodeE: CpNode) {
+
+    let cpNode = cpNodeS;
+    const pss: number[][][] = [];
+    while (cpNode !== cpNodeE) {
+	    const ps = getMatCurveBetween(cpNode, cpNode.next);
+        pss.push(ps);
+
+        cpNode = cpNode.next;
+    }
+
+    return pss;
+}
+
+
+export { getMatCurvesBetween }

package/src/cp-node/fs/get-non-terminating-on-circle.ts

@@ -0,0 +1,24 @@
+import { CpNode } from "../cp-node.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+function getNonTerminatingOnCircle(
+        cpNode: CpNode,
+        exclThis = false) {
+
+    const startCpNode = cpNode;
+    let cpNode_ = startCpNode;
+
+    const cpNodes: CpNode[] = [];
+    do {
+        if (!(exclThis && cpNode_ === startCpNode) && !isTerminating(cpNode_)) {
+            cpNodes.push(cpNode_);
+        }
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== startCpNode)
+
+    return cpNodes;
+}
+
+
+export { getNonTerminatingOnCircle }

package/src/cp-node/fs/get-prong-count.ts

@@ -0,0 +1,18 @@
+import { CpNode } from "../cp-node.js";
+
+
+function getProngCount(cpNode: CpNode) {
+	const startCpNode = cpNode;
+	let cpNode_ = startCpNode;
+
+	let i = 0;
+	do {
+		i++;
+		cpNode_ = cpNode_.nextOnCircle;
+	} while (cpNode_ !== startCpNode)
+
+	return i;
+}
+
+
+export { getProngCount }

package/src/cp-node/fs/get-real-prong-count.ts

@@ -0,0 +1,14 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnCircle } from "./get-all-on-circle.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+function getRealProngCount(cpNode: CpNode) {
+	const nonTerminatingCpNodes = getAllOnCircle(cpNode)
+	.filter(cpNode => !isTerminating(cpNode));
+
+	return nonTerminatingCpNodes.length;
+}
+
+
+export { getRealProngCount }

package/src/cp-node/fs/get-salience.ts

@@ -0,0 +1,28 @@
+import { distanceBetween } from "flo-vector2d";
+import { totalLength } from "flo-bezier3";
+import { CpNode } from "../cp-node.js";
+import { getBoundaryBeziersBetween } from "./get-boundary-beziers-between.js";
+import { sum } from '../../utils/sum.js';
+
+
+/**
+ * See https://research.gold.ac.uk/id/eprint/31944/
+ * @param cpNode 
+ */
+function getSalience(cpNode: CpNode) {
+    const cpNode1 = cpNode;
+    const cpNode2 = cpNode.nextOnCircle;
+    const bp1 = cpNode1.cp.pointOnShape.p;
+    const bp2 = cpNode2.cp.pointOnShape.p;
+
+    const d = distanceBetween(bp1, bp2);
+
+    const { pss: bps, hasHoleCloser } = getBoundaryBeziersBetween(cpNode1, cpNode2);
+
+    const s = sum(bps.map(ps => totalLength(ps)));
+
+    return hasHoleCloser ? Number.POSITIVE_INFINITY : s/d;
+}
+
+
+export { getSalience }

package/src/cp-node/fs/get-smoothed-speed.ts

@@ -0,0 +1,97 @@
+import { memoize } from "flo-memoize";
+import { totalCurvature$ } from "../../bezier/total-curvature.js";
+import { totalLength$ } from "../../bezier/total-length.js";
+import { memoizePrimitive } from "../../memoize-primitive.js";
+import { CpNode } from "../cp-node.js";
+import { getMatCurveToNext$ } from "./get-mat-curve-to-next.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
+import { isFullyTerminating } from "./is-fully-terminating.js";
+
+
+const RLen = 40;
+
+const getSmoothedSpeed$ = memoizePrimitive(
+    function (L: number) {
+        return memoize(
+            function getSmoothedSpeed(
+                    cpNode: CpNode): number | undefined {
+
+                let cpStart = cpNode;
+
+                let cumLB = 0;
+                let cumLF = 0;
+                let curB = cpStart.prev;
+                let curF = cpStart;
+                let cumKB = 0;
+                let cumKF = 0;
+                let cumLRB = 0;
+                let cumLRF = 0;
+                while (cumLRF < L/2/RLen &&
+                       curF !== cpStart.prev &&
+                       !isFullyTerminating(curF) &&
+                       getRealProngCount(curF) <= 2) {
+                    const { radius: r } = curF.cp.circle;
+                    const ps = getMatCurveToNext$(curF);
+                    const turn = totalCurvature$(ps);
+
+                    let rot = 0;
+                    // if (getProngCount(curF) >= 3) {
+                    //     rot = -getInterfaceRotation(
+                    //         tangentAt0(ps),
+                    //         tangentAt1(curF.prev.cp.pointOnShape.curve.ps)
+                    //     );
+                    // }
+
+                    const l = totalLength$(getMatCurveToNext$(curF));
+                    cumKF += r*(turn + rot);
+                    cumLF += l;
+                    cumLRF += l/r;
+
+                    curF = curF.next;
+                }
+                while (cumLRB < L/2/RLen &&
+                       curB !== cpStart &&
+                       !isFullyTerminating(curB) &&
+                       getRealProngCount(curB) <= 2) {
+                    const { radius: r } = curB.cp.circle;
+                    const ps = getMatCurveToNext$(curB);
+                    const turn = totalCurvature$(ps);
+
+                    let rot = 0;
+                    // if (getProngCount(curB) >= 3) {
+                    //     rot = -getInterfaceRotation(
+                    //         tangentAt0(ps),
+                    //         tangentAt1(curB.prev.cp.pointOnShape.curve.ps)
+                    //     )
+                    // }
+
+                    const l = totalLength$(getMatCurveToNext$(curB));
+                    cumKB += r*(turn + rot);
+                    cumLB += l;
+                    cumLRB += l/r;
+
+                    curB = curB.prev;
+                }
+                const cumL = cumLB + cumLF;
+                const cumK = cumKB + cumKF;
+
+                if (cumL === 0) {
+                    return undefined;
+                }
+
+                const x = -cumK/cumL;
+
+                // f(x) = 1 - exp(-x)
+                // f(x) = 1 - 1/(1 + x)
+                // f(x) = x/(a + x)
+                // f(x) = tanh(x)
+
+                // return 1 - Math.E**(-x)
+                return x;
+            }
+        )
+    }
+);
+
+
+export { getSmoothedSpeed$ }

package/src/cp-node/fs/get-smoothed.ts

@@ -0,0 +1,62 @@
+import { totalAbsoluteCurvature, totalCurvature, totalLength } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+import { totalCurvature$ } from "../../bezier/total-curvature.js";
+import { totalLength$ } from "../../bezier/total-length.js";
+import { memoizePrimitive } from "../../memoize-primitive.js";
+import { CpNode } from "../cp-node.js";
+import { getAvgSpeed, getAvgSpeed$ } from "./get-avg-speed.js";
+import { getMatCurveToNext, getMatCurveToNext$ } from "./get-mat-curve-to-next.js";
+import { getSpeed } from "./get-speed.js";
+
+
+const getSmoothed$ = memoizePrimitive(
+    function (L: number) {
+        return memoize(
+            function getSmoothed(
+                    cpNode: CpNode) {
+
+                // return getAvg$(cpNode)
+                // return getAvgCurvature(cpNode)
+                let cpStart = cpNode;
+
+                let cumLB = 0;
+                let cumLF = 0;
+                let curB = cpStart.prev;
+                let curF = cpStart;
+                let cumRTurnB = 0;
+                let cumRTurnF = 0;
+                while (cumLB < L/2 && curB !== cpStart) {
+                    const { radius: r } = curB.cp.circle;
+                    const ps = getMatCurveToNext$(curB);
+                    const absK = totalCurvature$(ps);
+                    const l = totalLength$(getMatCurveToNext$(curB));
+                    cumRTurnB += r*absK;
+                    cumLB += l;
+
+                    curB = curB.prev;
+                }
+                while (cumLF < L/2 && curF !== cpStart.prev) {
+                    const { radius: r } = curF.cp.circle;
+                    const ps = getMatCurveToNext$(curF);
+                    const absK = totalCurvature$(ps);
+                    const l = totalLength$(getMatCurveToNext$(curF));
+                    cumRTurnF += r*absK;
+                    cumLF += l;
+
+                    curF = curF.next;
+                }
+                const cumL = cumLB + cumLF;
+                const cumRTurn = cumRTurnB + cumRTurnF;
+
+                if (cumL === 0) {
+                    return undefined;
+                }
+
+                return { cumRTurn, cumL };
+            }
+        )
+    }
+);
+
+
+export { getSmoothed$ }

package/src/cp-node/fs/get-speed.ts

@@ -0,0 +1,61 @@
+import { curvature, totalAbsoluteCurvature, totalLength } from "flo-bezier3";
+import { memoize } from "flo-memoize";
+import { sum } from "../../utils/sum.js";
+import { CpNode } from "../cp-node.js";
+import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
+import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
+
+const { min, abs } = Math;
+
+
+const getSpeed$ = memoize(getSpeed);
+
+
+function getSpeed(cpNode: CpNode): number | undefined {
+    if (getRealProngCount(cpNode) !== 2) {
+        return 0;
+    }
+
+    const { radius: r } = cpNode.cp.circle;
+    const matPs = getMatCurveToNext(cpNode);
+    const absK = totalAbsoluteCurvature(matPs, [0,1]);
+    const l = totalLength(matPs);
+    if (l === 0) {
+        return undefined;  // TODO2
+    }
+    // const avgK = absK/l;
+    const avgK = absK;
+
+    return avgK*r;
+}
+
+
+
+
+// function getSpeed() {
+    // const cpNodeF = cpNode;
+    // const cpNodeB = cpNode.next.prevOnCircle;
+    // const matPs = getMatCurveToNext(cpNodeF);
+    // const boundaryPsF = getBoundaryBeziersToNext(cpNodeF);
+    // const boundaryPsB = getBoundaryBeziersToNext(cpNodeB);
+
+    // const lF = sum(boundaryPsF.map(ps => totalLength(ps)));
+    // const lB = sum(boundaryPsB.map(ps => totalLength(ps)));
+
+    // const l = totalLength(matPs);
+    // const ll = l === 0 ? 0.001 : l;
+
+    // const _speedF = lF/ll;
+    // const _speedB = lB/ll;
+
+    // const speedF = _speedF < 1 ? _speedF : 1;
+    // const speedB = _speedB < 1 ? _speedB : 1;
+
+
+    // const speed = min(speedF, speedB);
+
+    // return speed;
+// }
+
+export { getSpeed, getSpeed$ }

package/src/cp-node/fs/get-terminating-on-circle.ts

@@ -0,0 +1,24 @@
+import { CpNode } from "../cp-node.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+function getTerminatingOnCircle(
+        cpNode: CpNode,
+        exclThis = false) {
+
+    const startCpNode = cpNode;
+    let cpNode_ = startCpNode;
+
+    const cpNodes: CpNode[] = [];
+    do {
+        if (!(exclThis && cpNode_ === startCpNode) && isTerminating(cpNode_)) {
+            cpNodes.push(cpNode_);
+        }
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== startCpNode)
+
+    return cpNodes;
+}
+
+
+export { getTerminatingOnCircle }

package/src/cp-node/fs/get-vertex-forward-children.ts

@@ -0,0 +1,22 @@
+import { CpNode } from "../cp-node.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+function getVertexForwardChildren(cpNode: CpNode) {
+	const children: CpNode[] = [];
+
+	const cpStart = cpNode;
+
+	let cpNode_ = cpStart;
+	while (cpNode_ !== cpStart.prevOnCircle) {
+		if (!isTerminating(cpNode_)) {
+			children.push(cpNode_.next);
+		}
+		cpNode_ = cpNode_.nextOnCircle;
+	}
+
+	return children;
+}
+
+
+export { getVertexForwardChildren }

package/src/cp-node/fs/insert-cp-node.ts

@@ -0,0 +1,40 @@
+import { LlRbTree } from "flo-ll-rb-tree";
+import { compareCps, ContactPoint } from "../../contact-point/contact-point.js";
+import { CpNode } from "../cp-node.js";
+import { isOrderCorrect } from "./is-order-correct.js";
+
+
+function insertCpNode(
+        insertIfOrderWrong: boolean,
+        isHoleClosing: boolean,
+        isIntersection: boolean,
+        cpTree: LlRbTree<CpNode>,
+        cp: ContactPoint, 
+        _prev: CpNode | undefined) {
+
+    if (_prev !== undefined &&
+        !isOrderCorrect(cpTree, cp, _prev.next)) {
+
+        // console.log(compareCps(cp,_prev!.next.cp))
+        if (!insertIfOrderWrong) {
+            return undefined;
+        }
+    }
+
+    const cpNode = { cp, isHoleClosing, isIntersection } as CpNode;
+
+    const prev = _prev === undefined ? cpNode : _prev;
+    const next = _prev === undefined ? cpNode : prev.next;
+
+    next.prev = cpNode;
+    prev.next = cpNode;
+    cpNode.prev = prev;
+    cpNode.next = next;
+
+    cpTree.insert(cpNode);
+
+    return cpNode;
+}
+
+
+export { insertCpNode }

package/src/cp-node/fs/is-fully-terminating.ts

@@ -0,0 +1,13 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnCircle } from "./get-all-on-circle.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+function isFullyTerminating(cpNode: CpNode) {
+	const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
+
+	return otherOnCircle.every(isTerminating);
+}
+
+
+export { isFullyTerminating }

package/src/cp-node/fs/is-on-same-circle.ts

@@ -0,0 +1,16 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnCircle } from "./get-all-on-circle.js";
+
+
+function isOnSameCircle(
+        cpNode1: CpNode,
+        cpNode2: CpNode) {
+
+    // const cpNodes = getAllOnCircle(cpNode1, true);
+    const cpNodes = getAllOnCircle(cpNode1);
+
+    return cpNodes.indexOf(cpNode2) >= 0;
+}
+
+
+export { isOnSameCircle }

package/src/cp-node/fs/is-one-prong.ts

@@ -0,0 +1,21 @@
+import { CpNode } from "../cp-node.js";
+
+
+// TODO2 - remove - or replace with `getRealProngCount === 1`
+function isOneProng(cpNode: CpNode) {
+	const cp1 = cpNode;
+
+	if (cp1.cp.circle.radius === 0) {
+		return true;
+	}
+
+	const cp2 = cp1.nextOnCircle;
+
+	const p1 = cp1.cp.pointOnShape.p;
+	const p2 = cp2.cp.pointOnShape.p;
+
+	return (p1[0] === p2[0] && p1[1] === p2[1]);
+}
+
+
+export { isOneProng }

package/src/cp-node/fs/is-order-correct.ts

@@ -0,0 +1,36 @@
+import { LlRbTree } from "flo-ll-rb-tree";
+import { compareCps, ContactPoint } from "../../contact-point/contact-point.js";
+import { CpNode } from "../cp-node.js";
+
+
+function isOrderCorrect(
+        // isHoleClosing: boolean,
+        cpTree: LlRbTree<CpNode>,
+        cp: ContactPoint,
+        next: CpNode): boolean {
+
+    // if (isHoleClosing) { return true; }
+
+    // TODO2
+    const c = compareCps(cp,next.cp);
+    if (c < 0) { return true; }
+    if (c === 0) {
+        // TODO2
+        // console.log('c === 0');
+        return true;
+    }
+
+    const minNode = cpTree.getMinNode();
+    if (minNode === undefined) {  // if tree not empty
+        return true;
+    }
+
+    const min = minNode.datum;
+    const max = cpTree.getMaxNode()!.datum;
+
+    // larger than all -> crossing zero on loop
+    return (compareCps(max.cp,cp) < 0 && min === next);
+}
+
+
+export { isOrderCorrect }

package/src/cp-node/fs/is-sharp.ts

@@ -0,0 +1,9 @@
+import { CpNode } from "../cp-node.js";
+
+
+function isSharp(cpNode: CpNode) {
+	return cpNode.cp.circle.radius === 0;
+}
+
+
+export { isSharp }