flo-mat 3.0.0 → 3.0.2

package/src/sat/cull.ts

@@ -1,6 +1,34 @@
 import { Circle } from '../geometry/circle.js';
 import { getLeaves } from './get-leaves.js';
-import { CpNode, isOnSameCircle } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
+import { DualSet, DualSetFs } from '../utils/dual-set.js';
+
+const { isOnSameCircle } = CpNodeFs;
+
+
+/**
+ * 
+ * @param cpStart 
+ */
+function getNonTrivialForwardEdges(cpStart: CpNode) {
+    let cpNode = cpStart;
+    let cpEnd = cpStart.prevOnCircle;
+    while (isTerminating(cpEnd)) {
+        cpEnd = cpEnd.prevOnCircle;
+    }
+    
+    const cps: CpNode[] = [];
+    do {
+        if (!isTerminating(cpNode)) {
+            cps.push(cpNode);
+        }
+        cpNode = cpNode.nextOnCircle;
+    } while (cpNode !== cpEnd)
+
+    return cps;
+}
 
 
 /**
@@ -12,136 +40,57 @@ import { CpNode, isOnSameCircle } from '../cp-node/cp-node.js';
  * @param maxCpNode The start CpNode which must reprsesent the maximal vertex.
  */
 function cull(
-        culls: Set<Circle>, 
+        culls: DualSet<number, number>,
         maxCpNode: CpNode) {
 
     const leaves = getLeaves(maxCpNode);
 
-    function getNonTrivialEdges(cpStart: CpNode) {
-		let cp = cpStart;
-		
-        const cps: CpNode[] = [];
-		do {
-            if (cp.next !== cp.nextOnCircle) {
-                cps.push(cp);
-            }
-			cp = cp.nextOnCircle;
-		} while (cp !== cpStart.prevOnCircle)
-
-		return cps;
-    }
-
     while (leaves.length) {
         const leaf = leaves.pop()!;
 
-        // Preserve topology.
-        if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
+        const { center: c } = leaf.cp.circle;
+        if (!DualSetFs.has(culls, c[0], c[1]) ||
+            // Preserve topology.
+            leaf.isIntersection) {
 
-        if (!culls.has(leaf.cp.circle)) {
             continue;
         }
 
-        let cpNode = leaf.next; // Turn around
-
-        while (true) {
+        let cpNode = leaf.prevOnCircle; // Turn around
+        let cut = false;
+        while (!cut) {
             cpNode = cpNode.next;
-            let cut = false;
-            const cp1 = cpNode.prevOnCircle;
 
-            if (!culls.has(cpNode.cp.circle)) {
+            const { center: c } = cpNode.cp.circle;
+            if (!DualSetFs.has(culls, c[0], c[1])) {
                 // Cut off the edge once a non-cull has been reached.
+                while (isTerminating(cpNode.prevOnCircle)) {
+                    cpNode = cpNode.prevOnCircle;
+                }
                 cut = true;
             } else if (isOnSameCircle(cpNode, maxCpNode)) {
                 cut = true; // We are at the max disk - cut whole edge
             } else {
-                const cps = getNonTrivialEdges(cpNode);
+                const cps = getNonTrivialForwardEdges(cpNode);
 
                 if (cps.length === 1) { 
-                    cpNode = cps[0];
+                    continue;
                 } else {
                     cut = true;
                 }
-            } 
-
-            if (cut) {
-                cp1.next = cpNode;
-                cpNode.prev = cp1;
-                break;
             }
         }
-    }
-}
-
-/*
-function cull(
-    culls: Set<Circle>, 
-    maxCpNode: CpNode) {
-
-let leaves = getLeaves(maxCpNode);
-
-function getNonTrivialBranches(cpStart: CpNode) {
-    let cp = cpStart.next;
-    
-    let cps: CpNode[] = [];
-    do {
-        if (cp.next !== cp.nextOnCircle) {
-            cps.push(cp);
-        }
-        cp = cp.nextOnCircle;
-    } while (cp !== cpStart)
-
-    return cps;
-}
-
-while (leaves.length) {
-    let leaf = leaves.pop();
-
-    // Preserve topology.
-    if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
-
-    if (!culls.has(leaf.cp.circle)) {
-        continue;
-    }
-
-    let cpNode = leaf.next; // Turn around
-
-    while (true) {
-        cpNode = cpNode.next;
-        let cut = false;
-        let cp1 = cpNode.prevOnCircle;
-
-        if (!culls.has(cpNode.cp.circle)) {
-            // Cut the branch once a non-cull has been reached.
-            cut = true;
-        } else {
-            //let cp2 = cp1.prevOnCircle;
-            let cp2 = cpNode.nextOnCircle;
-
-            //if (maxCpNode === cpNode || maxCpNode === cp1 || maxCpNode === cp2) {
-            if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
-                cut = true; // We are at the max disk - cut whole edge
-            } else if (cpNode.next === cp2) {
-                // Continue but starting from cp2
-                cpNode = cp2;
-            } else if (cp2.next === cp1) {
-                // Do nothing - ignore the branch starting from cp2 since it
-                // is terminating.
-            } else if (cp2.next !== cp1) {
-                // At this stage (cpNode.next !== cp2 && cp2.next !== cp1) 
-                // so it is a bifurcation point - cut the edge.
-                cut = true; 
-            }
-        } 
 
         if (cut) {
+            const cp1 = cpNode.prevOnCircle;
             cp1.next = cpNode;
             cpNode.prev = cp1;
-            break;
+
+            cp1.nextOnCircle = cpNode;
+            cpNode.prevOnCircle = cp1;
         }
     }
 }
-}
-*/
 
 
 export { cull }

package/src/sat/get-leaves.ts

@@ -1,4 +1,9 @@
-import { CpNode, getAllOnLoop, isTerminating } from '../cp-node/cp-node.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import { isFullyTerminating } from '../cp-node/fs/is-fully-terminating.js';
+import { getRealProngCount } from '../cp-node/fs/get-real-prong-count.js';
+
+const { getAllOnLoop } = CpNodeFs;
 
 
 /** @internal */
@@ -6,11 +11,11 @@ function getLeaves(cpNode: CpNode) {
     const leaves: CpNode[] = [];
 
     const cps = getAllOnLoop(cpNode);
-    cps.forEach(function(cp) {
-        if (isTerminating(cp)) { 
+    for (const cp of cps) {
+        if (isFullyTerminating(cp) && !cp.isHoleClosing) { 
             leaves.push(cp);
         }
-    });
+    }
 
     return leaves;
 }

package/src/sat/get-sat-culls.ts

@@ -0,0 +1,46 @@
+import { length } from "flo-bezier3";
+import { CpNode } from "../cp-node/cp-node.js";
+import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
+import { traverseEdges } from "../cp-node/fs/traverse-edges.js";
+import { DualSet, DualSetFs } from "../utils/dual-set.js";
+
+
+function getSatCulls(
+        cpNode: CpNode, 
+        s: number) {
+
+    /** 
+     * All vertices that are set to be culled initially. This may change later 
+     * in order to preserve topology. 
+     */
+    const culls: DualSet<number,number> = new Map();
+
+    const rMap: Map<CpNode,number> = new Map();
+
+    traverseEdges(cpNode, function(cpNode) {
+        /** The occulating radius stored with this vertex. */
+        const R = rMap.get(cpNode) || (s*cpNode.cp.circle.radius);
+
+        const cpNode_ = cpNode.next;
+
+        const l = length([0,1], getMatCurveToNext(cpNode));
+
+        const r = cpNode_.cp.circle.radius;
+        const r_ = s*r;
+        if (R - l > r_) {
+            for (const cpNode of getAllOnCircle(cpNode_)) {
+                rMap.set(cpNode, R - l); // Update osculating radii
+                if (!cpNode_.isHoleClosing) {
+                    const { center: c } = cpNode_.cp.circle;
+                    DualSetFs.add(culls, c[0], c[1]);
+                }
+            }
+        }
+    });
+
+    return culls;
+}
+
+
+export { getSatCulls }

package/src/sat/to-scale-axis.ts

@@ -1,31 +1,14 @@
 /** @internal */
 declare const _debug_: Debug;
 
-import { length } from 'flo-bezier3';
 import { Debug } from '../debug/debug.js';
-import { CpNode, getCpNodesOnCircle } from '../cp-node/cp-node.js';
-import { Circle } from '../geometry/circle.js';
 import { Mat } from '../mat/mat.js';
-import { traverseEdges } from '../cp-node/traverse-edges.js';
-import { traverseVertices } from '../cp-node/traverse-vertices.js';
 import { getLargestVertex } from '../mat/get-largest-vertex.js';
 import { createNewCpTree } from '../mat/create-new-cp-tree.js';
-import { getLeaves } from './get-leaves.js';
 import { cull } from './cull.js';
 import { addDebugInfo } from './add-debug-info.js';
-import { clone } from '../cp-node/clone.js';
-import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
-
-
-function linearScale(s: number) {
-	return function(r: number) {
-		return s*r;
-	}
-}
-
-
-/** @internal */
-//let len = length([0,1]);
+import { clone } from '../cp-node/fs/clone.js';
+import { getSatCulls } from './get-sat-culls.js';
 
 
 /**
@@ -42,67 +25,28 @@ function linearScale(s: number) {
  */
 function toScaleAxis(
 		mat: Mat, 
-		s: number, 
-		f: (s: number) => (r: number) => number = linearScale): Mat {
+		s: number): Mat {
 
 	let timingStart = 0;
 	if (typeof _debug_ !== 'undefined') {
 		timingStart = performance.now();
-		const leaves = getLeaves(mat.cpNode);
-		_debug_.generated.elems.leaves.push(leaves);
-	}
-
-	/** The largest vertex (as measured by its inscribed disk) */
-	const cpNodes: CpNode[] = [];
-	traverseVertices(
-		clone(mat.cpNode), 
-		cpNode => { cpNodes.push(cpNode); }
-	);
-
-	const cpNode = getLargestVertex(cpNodes);
-	const f_ = f(s);
-
-	if (typeof _debug_ !== 'undefined') {
-		_debug_.generated.elems.maxVertex.push(cpNode);
 	}
 
-	/** 
-	 * All vertices that are set to be culled initially. This may change later 
-	 * in order to preserve topology. 
-	 */
-	const culls: Set<Circle> = new Set();
-
-	const rMap: Map<CpNode,number> = new Map();
-
-	traverseEdges(cpNode, function(cpNode) {
-		/** The occulating radius stored with this vertex. */
-		const R = rMap.get(cpNode) || f_(cpNode.cp.circle.radius);
-
-		const cpNode_ = cpNode.next;
-
-		const l = length([0,1], getCurveToNext(cpNode));
-
-		const r = cpNode_.cp.circle.radius;
-		const r_ = f_(r);
-		if (R - l > r_) {
-			for (const cpNode of getCpNodesOnCircle(cpNode_)) {
-				rMap.set(cpNode, R - l); // Update osculating radii
-			}
-			culls.add(cpNode_.cp.circle);
-		}
-	});
+	const cpNode = getLargestVertex(clone(mat.cpNode));
+	const culls = getSatCulls(cpNode, s);
 
 	cull(culls, cpNode);
 
-	if (typeof _debug_ !== 'undefined') {
-		_debug_.generated.elems.culls.push(Array.from(culls));
-	}
-	 
-	// TODO - put line below back - goes into infinite loop
-	//const sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
-	const sat: Mat = { cpNode, cpTrees: undefined! };
+	const sat: Mat = {
+        cpNode: cpNode,
+        meta: {
+            ...mat.meta,
+			cpTrees: createNewCpTree(cpNode)
+        }
+    };
+
 
-	addDebugInfo(sat, timingStart);
+	addDebugInfo(timingStart);
 
 	return sat;
 }

package/src/svg/get-extreme.ts

@@ -1,4 +1,4 @@
-import { Loop } from '../loop.js';
+import { Loop } from 'flo-boolean';
 import { getShapeBounds } from './get-shape-bounds.js';
 
 

package/src/utils/bezier-piece-to-bezier.ts

@@ -0,0 +1,13 @@
+import { BezierPiece, fromTo } from "flo-bezier3";
+
+
+function bezierPieceToBezier(
+        piece: BezierPiece) {
+
+    const { ps, ts } = piece;
+
+    return fromTo(ps, ts[0], ts[1]);
+}
+
+
+export { bezierPieceToBezier }

package/src/utils/deg-to-rad.ts

@@ -0,0 +1,7 @@
+
+function degToRad(degrees: number) {
+    return degrees/360*2*Math.PI;
+}
+
+
+export { degToRad };

package/src/utils/dual-map.ts

@@ -0,0 +1,55 @@
+
+/**
+ * A 'dual-map' in the sense that it needs two ordered keys to return one 
+ * value.
+ */
+type DualMap<K,L,V> = Map<K,Map<L,V>>;
+
+
+/**
+ * Get a value from the dual-map.
+ * @param map 
+ * @param k 
+ * @param l 
+ */
+function get<K,L,V>(
+        map: DualMap<K,L,V>,
+        k: K,
+        l: L): V | undefined {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) { return undefined; }
+
+    return lMap.get(l);
+}
+
+
+/**
+ * Set a value in the dual-map.
+ * * destructively sets the value
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param v 
+ */
+function set<K,L,V>(
+        map: DualMap<K,L,V>,
+        k: K,
+        l: L,
+        v: V): void {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) {
+        lMap = new Map();
+        map.set(k, lMap);
+    }
+    lMap.set(l, v);
+}
+
+
+const DualMapFs = {
+    get, set
+}
+
+
+export { DualMap, DualMapFs }

package/src/utils/dual-set.ts

@@ -0,0 +1,82 @@
+
+/**
+ * A 'dual-set' in the sense that it needs two ordered keys.
+ */
+type DualSet<K,L> = Map<K,Set<L>>;
+
+
+/**
+ * Get a value from the dual-set.
+ * @param set 
+ * @param k 
+ */
+function has<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): boolean {
+
+    const lSet = set.get(k);
+    if (lSet === undefined) { return false; }
+
+    return lSet.has(l);
+}
+
+
+/**
+ * Adds a value to the dual-set.
+ * 
+ * * destructively sets the value
+ * 
+ * @param set 
+ * @param k 
+ * @param l 
+ */
+function add<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): void {
+
+    let lSet = set.get(k);
+    if (lSet === undefined) {
+        lSet = new Set();
+        set.set(k, lSet);
+    }
+    lSet.add(l);
+}
+
+
+function remove<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): boolean {
+
+    let lSet = set.get(k);
+    if (lSet === undefined) {
+        return false;
+    }
+    const r = lSet.delete(l);
+    if (!r) { return false; }
+
+    if (lSet.size === 0) {
+        set.delete(k);
+    }
+
+    return true;
+}
+
+
+const DualSetFs = { has, add, remove };
+
+
+export { DualSet, DualSetFs }
+
+
+// TESTING
+// const s: DualSet<number,number> = new Map();
+// add(s,1,2);
+// has(s,1,2);//?
+// has(s,2,1);//?
+// has(s,1,1);//?
+// add(s,1,1);
+// has(s,1,1);//?
+// has(s,1,2);//?

package/src/utils/rad-to-deg.ts

@@ -0,0 +1,7 @@
+
+function radToDeg(rad: number) {
+    return rad*360/2/Math.PI;
+}
+
+
+export { radToDeg };

package/src/utils/rotate.ts

@@ -0,0 +1,17 @@
+import { rotate } from "flo-vector2d";
+import { degToRad } from "./deg-to-rad.js";
+
+const { sin, cos } = Math;
+
+
+function rotateRad(v: number[], θ: number) {
+    return rotate(sin(θ), cos(θ))(v);
+}
+
+
+function rotateDeg(v: number[], θ: number) {
+    return rotate(sin(degToRad(θ)), cos(degToRad(θ)))(v);
+}
+
+
+export { rotateRad, rotateDeg }

package/src/utils/sleep.ts

@@ -0,0 +1,7 @@
+
+function sleep(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+export { sleep }

package/src/utils/sum.ts

@@ -0,0 +1,12 @@
+
+function sum(ns: number[]) {
+    let total = 0;
+    for (let n of ns) {
+        total += n;
+    }
+
+    return total;
+}
+
+
+export { sum }

package/src/utils/tri-map.ts

@@ -0,0 +1,76 @@
+
+/**
+ * A 'tri-map' in the sense that it needs two ordered keys to return one 
+ * value.
+ */
+type TriMap<K,L,M,V> = Map<K,Map<L,Map<M,V>>>;
+
+
+/**
+ * Get a value from the tri-map.
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param m 
+ */
+function get<K,L,M,V>(
+        map: TriMap<K,L,M,V>,
+        k: K,
+        l: L,
+        m: M): V | undefined {
+
+    const lMap = map.get(k);
+    if (lMap === undefined) { return undefined; }
+
+    const mMap = lMap.get(l);
+    if (mMap === undefined) { return undefined; }
+
+    return mMap.get(m);
+}
+
+
+/**
+ * Set a value in the tri-map.
+ * * destructively sets the value
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param v 
+ */
+function set<K,L,M,V>(
+        map: TriMap<K,L,M,V>,
+        k: K,
+        l: L,
+        m: M,
+        v: V): void {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) {
+        lMap = new Map();
+        map.set(k, lMap);
+    }
+
+    let mMap = lMap.get(l);
+    if (mMap === undefined) {
+        mMap = new Map();
+        lMap.set(l, mMap);
+    }
+
+    mMap.set(m, v);
+}
+
+
+const TriMapFs = {
+    get, set
+}
+
+
+export { TriMap, TriMapFs }
+
+
+// Test
+// const triMap = new Map<number,Map<number,Map<number,number>>>();
+// set(triMap, 1,2,3, 4);
+// set(triMap, 4,3,2, 1);
+// get(triMap, 4,2,3); //?
+

package/src/vertex/remove-vertex.ts

@@ -0,0 +1,22 @@
+import { Loop } from 'flo-boolean';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from "../cp-node/cp-node.js";
+import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
+import { getProngCount } from '../cp-node/fs/get-prong-count.js';
+import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
+
+
+function removeVertex(
+        cpNode: CpNode,
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+
+    const prongCount = getProngCount(cpNode);
+    if (prongCount !== 2) {
+        throw new Error(`Cannot delete \`CpNode\` on ${prongCount}-prong`)
+    }
+
+    getAllOnCircle(cpNode).forEach(cpNode => removeCpNode(cpNode, cpTrees));
+}
+
+
+export { removeVertex }