flo-mat 3.0.0 → 3.0.2

package/src/cp-node/fs/is-single-3-prong.ts

@@ -0,0 +1,15 @@
+import { CpNode } from "../cp-node.js";
+
+
+function isSingle3Prong(
+        cpNode: CpNode) {
+
+    return (
+        cpNode.next === cpNode.nextOnCircle &&
+        cpNode.next.next === cpNode.next.nextOnCircle &&
+        cpNode.prev.next === cpNode.prev.nextOnCircle
+    );
+}
+
+
+export { isSingle3Prong }

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

@@ -0,0 +1,16 @@
+import { CpNode } from "../cp-node.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
+
+
+function isSpecial(
+        cpNode: CpNode) {
+
+    return (
+        (getRealProngCount(cpNode) !== 2) &&
+        !cpNode.isHoleClosing/* && cpNode.cp.circle.radius !== 0*/
+        // !cpNode.isHoleClosing && cpNode.cp.circle.radius !== 0 // TODO2
+    )
+}
+
+
+export { isSpecial }

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

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

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

@@ -0,0 +1,16 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnCircle } from "./get-all-on-circle.js";
+import { isTerminating } from "./is-terminating.js";
+
+
+/**
+ * Returns `true` if the `CpNode` has all branches terminating
+ */
+function isTrivial(
+        cpNode: CpNode) {
+
+    return getAllOnCircle(cpNode).every(isTerminating);
+}
+
+
+export { isTrivial }

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

@@ -0,0 +1,10 @@
+import { CpNode } from "../cp-node.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
+
+
+function isTwoProng(cpNode: CpNode) {
+    return getRealProngCount(cpNode) === 2;
+}
+
+
+export { isTwoProng }

package/src/cp-node/fs/is-vertex-special.ts

@@ -0,0 +1,8 @@
+import { isSpecial } from "./is-special.js";
+import { isVertex } from "./is-vertex.js";
+
+
+const isVertexSpecial = isVertex(isSpecial);
+
+
+export { isVertexSpecial }

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

@@ -0,0 +1,12 @@
+import { CpNode } from "../cp-node.js";
+import { getAllOnCircle } from "./get-all-on-circle.js";
+
+
+function isVertex(
+        f: (cpNode: CpNode) => boolean) {
+
+    return (cpNode: CpNode) => getAllOnCircle(cpNode).some(f);
+}
+
+
+export { isVertex }

package/src/cp-node/fs/iterate-all-on-loop.ts

@@ -0,0 +1,15 @@
+import { CpNode } from "../cp-node.js";
+
+
+function* iterateAllOnLoop(cpNode: CpNode) {
+	yield cpNode;
+
+	let cpNode_ = cpNode.next;
+	while (cpNode_ !== cpNode) {
+		yield cpNode_;
+		cpNode_ = cpNode_.next;
+	}
+}
+
+
+export { iterateAllOnLoop }

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

@@ -0,0 +1,20 @@
+import { Loop } from 'flo-boolean';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from "../cp-node.js";
+
+
+function removeCpNode(
+        cpNode: CpNode,
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+
+    const prev = cpNode.prev;
+    const next = cpNode.next;
+    prev.next = next;
+    next.prev = prev;
+
+    const cpTree = cpTrees.get(cpNode.cp.pointOnShape.curve.loop)!;
+    cpTree.remove(cpNode, false); 
+}
+
+
+export { removeCpNode }

package/src/cp-node/fs/traverse-all-forward.ts

@@ -0,0 +1,24 @@
+import { CpNode } from '../cp-node.js';
+import { isTerminating } from './is-terminating.js';
+import { getChildren } from './get-children.js';
+
+
+function traverseAllForward(
+		cpNode: CpNode,
+		traverseEdgesCallback: (cpNode: CpNode) => void) {
+
+	// Since the tree is unrooted we must iterate in all directions from the
+	// given vertex.
+	const cps = [cpNode];
+
+	while (cps.length) {
+		const cp = cps.pop()!;
+		traverseEdgesCallback(cp);
+
+		if (isTerminating(cp)) { continue; }
+		cps.push(...getChildren(cp));
+	}
+}
+
+
+export { traverseAllForward }

package/src/cp-node/{traverse-cp.ts → fs/traverse-cp.ts}

@@ -1,19 +1,11 @@
-import { CpNode } from "./cp-node";
+import { CpNode } from "../cp-node.js";
+import { isTerminating } from "./is-terminating.js";
 
 
-/**
- * @internal
- * 
- * Traverses the shape from the given `CpNode` going around the shortest path
- * so that only a piece of the shape is traversed and returns the visited 
- * `CpNode`s (starting from the given `CpNode`).
- * 
- * @param cpStart The `CpNode` from where to start the traversal.
- */
 function traverseCp(cpStart: CpNode) {
 	let cpNode = cpStart;
 
-	if (cpNode === cpNode.next.prevOnCircle) {
+	if (isTerminating(cpNode)) {
 		return [cpNode];  // one-sharp corner
 	}
 

package/src/cp-node/fs/traverse-edges.ts

@@ -0,0 +1,71 @@
+import { CpNode } from '../cp-node.js';
+import { getAllOnCircle } from './get-all-on-circle.js';
+import { isTerminating } from './is-terminating.js';
+import { getChildren } from './get-children.js';
+import { getAllOnLoop } from './get-all-on-loop.js';
+
+
+// function traverseEdges2(
+// 		cpNode: CpNode,
+// 		traverseEdgesCallback: (cpNode: CpNode) => void) {
+
+// 	// Since the tree is unrooted we must iterate in all directions from the
+// 	// given vertex.
+// 	const cps = getAllOnCircle(cpNode);
+
+// 	while (cps.length) {
+// 		const cp = cps.pop()!;
+// 		traverseEdgesCallback(cp);
+
+// 		if (isTerminating(cp)) { continue; }
+// 		cps.push(...getChildren(cp));
+// 	}
+// }
+
+
+async function traverseEdges$$(
+		cpNode: CpNode,
+		traverseEdgesCallback: (cpNode: CpNode) => Promise<void>) {
+
+	const cpNodes = getAllOnLoop(cpNode);
+	const seen = new Set<CpNode>();
+
+	for (cpNode of cpNodes) {
+		if (!isTerminating(cpNode) && !seen.has(cpNode.next.prevOnCircle)) {
+			await traverseEdgesCallback(cpNode);
+		}
+		seen.add(cpNode);
+	}
+}
+
+
+function traverseEdges(
+		cpNode: CpNode,
+		traverseEdgesCallback: (cpNode: CpNode) => void) {
+
+	const cpNodes = getAllOnLoop(cpNode);
+	const seen = new Set<CpNode>();
+
+	for (cpNode of cpNodes) {
+		if (!isTerminating(cpNode) && !seen.has(cpNode.next.prevOnCircle)) {
+			traverseEdgesCallback(cpNode);
+		}
+		seen.add(cpNode);
+	}
+}
+
+
+function* $traverseEdges(cpNode: CpNode) {
+	const cpNodes = getAllOnLoop(cpNode);
+	const seen = new Set<CpNode>();
+
+	for (cpNode of cpNodes) {
+		if (!isTerminating(cpNode) && !seen.has(cpNode.next.prevOnCircle)) {
+			yield cpNode;
+		}
+		seen.add(cpNode);
+	}
+}
+
+
+export { traverseEdges, $traverseEdges, traverseEdges$$ }

package/src/cp-node/fs/traverse-vertices.ts

@@ -0,0 +1,32 @@
+import { CpNode } from '../cp-node.js';
+import { CpNodeFs } from '../cp-node-fs.js';
+import { getAllOnCircle } from './get-all-on-circle.js';
+import { isTerminating } from './is-terminating.js';
+import { getVertexForwardChildren } from './get-vertex-forward-children.js';
+
+
+function traverseVertices(
+		cpStart: CpNode, 
+		traverseVerticesCallback: (cpNode: CpNode) => void) {
+
+	traverseVerticesCallback(cpStart);
+
+	// Since the tree is unrooted we must iterate in all directions from the
+	// given cpNode.
+	const cpNodes = 
+		getAllOnCircle(cpStart)
+		.filter(cpNode => !isTerminating(cpNode))
+		.map(cpNode => cpNode.next);
+
+	for (const cpNode of cpNodes) {
+		const cps = [cpNode];
+		while (cps.length) {
+			const cp = cps.pop()!;
+			traverseVerticesCallback(cp);
+			cps.push(...getVertexForwardChildren(cp));
+		}
+	}
+}
+
+
+export { traverseVertices }

package/src/curve/curve.ts

@@ -1,6 +1,4 @@
-import { memoize } from 'flo-memoize';
 import { Loop } from 'flo-boolean';
-import { getCorner } from '../corner/get-corner.js';
 
 
 /**
@@ -30,17 +28,4 @@ interface Curve {
 }
 
 
-/**
- * @internal
- * 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 { Curve }

package/src/dbscan/dbscan.ts

@@ -0,0 +1,91 @@
+
+/**
+ * DBSCAN Clustering Algorithm
+ * 
+ * @param DB 
+ * @param distFunc 
+ * @param eps 
+ * @param minPts 
+ */
+function DBSCAN<T>(
+        DB: T[],
+        distFunc: (a: T, b: T) => number,
+        eps: number,
+        minPts: number) {
+
+    const labelMap = new Map<T,number>();
+    let C = 0;                                                  /* Cluster counter */
+    for (const P of DB) {
+        if (labelMap.has(P)) { continue; }                      /* Previously processed in inner loop */
+
+        const N = RangeQuery(DB, distFunc, P, eps);             /* Find neighbors */
+        if (N.size < minPts) {                                  /* Density check */
+            labelMap.set(P,-1);                                 /* Label as Noise */
+            continue;
+        }
+
+        C++;                                                    /* next cluster label */
+        labelMap.set(P,C);                                      /* Label initial point */
+        const S: Set<T> = new Set(N); S.delete(P);              /* Neighbors to expand */
+        const Ss = Array.from(S);
+
+        for (let i=0; i<Ss.length; i++) {                       /* Process every seed point Q */
+            const Q = Ss[i];
+            if (labelMap.get(Q) === -1) { labelMap.set(Q,C); }  /* Change Noise to border point */
+            if (labelMap.get(Q) !== undefined) { continue; }    /* Previously processed (e.g., border point) */
+            labelMap.set(Q,C);                                  /* Label neighbor */
+            const N = RangeQuery(DB, distFunc, Q, eps);         /* Find neighbors */
+            if (N.size >= minPts) {                             /* Density check (if Q is a core point) */
+                Ss.push(...N);                                  /* Add new neighbors to seed set */
+            }
+        }
+    }
+
+    return labelMap;
+}
+
+
+function RangeQuery<T>(
+        DB: T[],
+        distFunc: (a: T, b: T) => number,
+        Q: T,
+        eps: number) {
+
+    let N = new Set<T>();
+    for (const P of DB) {              /* Scan all points in the database */
+        if (distFunc(Q, P) <= eps) {   /* Compute distance and check epsilon */
+            N.add(P);                  /* Add to result */
+        }
+    }
+
+    return N;
+}
+
+
+export { DBSCAN }
+
+
+// function makeMore(p: number[]) {
+//     const ps: number[][] = [];
+//     for (let i=0; i<5; i++) {
+//         const [x,y] = p;
+//         ps.push([
+//             x + 5*(Math.random() - 0.5),
+//             y + 5*(Math.random() - 0.5),
+//         ]);
+//     }
+
+//     return ps;
+// }
+// const ps = [
+//     [10,10],[10,30],[20,50],[10,40],[70,50],[30,30]
+// ]
+// .flatMap(makeMore);
+// function d(a: number[], b: number[]) {
+//     const x = a[0] - b[0];
+//     const y = a[1] - b[1];
+
+//     return Math.sqrt(x**2 + y**2);
+// }
+// DBSCAN(ps, d, 5, 3);
+

package/src/debug/debug-elem-types.ts

@@ -1,36 +1,44 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { TwoProngForDebugging } from './two-prong-for-debugging.js';
-import { ThreeProngForDebugging } from './three-prong-for-debugging.js';
-import { Curve } from '../curve/curve.js';
 import { Mat } from '../mat/mat.js';
 import { CpNode } from '../cp-node/cp-node.js';
-import { Circle } from '../geometry/circle.js';
-import { ICpNodeForDebugging } from './cp-node-for-debugging.js';
+
+
+type DebugElemKey = keyof typeof emptyDebugElems;
+
+
+const emptyDebugElems = {
+    oneProng: [] as CpNode[][],
+    // oneProngAtDullCorner: [] as PointOnShape[],
+    twoProng: [] as CpNode[],
+    threeProng: [] as CpNode[],
+    looseBoundingBox: [] as number[][][],
+    tightBoundingBox: [] as number[][][],
+    boundingHull: [] as number[][][],
+    // sharpCorner: [] as Curve[],
+    // dullCorner: [] as Curve[],
+    vertex: [] as CpNode[],
+    mat: [] as Mat[],
+    maxVertex: [] as CpNode[],
+    leaves: [] as CpNode[][],
+    cull: [] as number[][],
+    cpNode: [] as CpNode[],
+    branch: [] as CpNode[][],
+    holeCloser: [] as CpNode[],
+    speed: [] as CpNode[]
+} as const;
+
+
+const debugElemNames = 
+    Object.keys(emptyDebugElems) as Array<keyof typeof emptyDebugElems>;
 
 
 /** @internal */
-interface IDebugElems {
-    oneProng: CpNode[];
-    oneProngAtDullCorner: PointOnShape;    
-    twoProng_regular: TwoProngForDebugging;
-	twoProng_failed: TwoProngForDebugging;
-	twoProng_notAdded: TwoProngForDebugging;
-	twoProng_deleted: TwoProngForDebugging;
-    twoProng_holeClosing: TwoProngForDebugging;
-    threeProng: ThreeProngForDebugging;
-    looseBoundingBox: number[][];
-    tightBoundingBox: number[][];
-    boundingHull: number[][];
-    sharpCorner: Curve
-    dullCorner: Curve;
-    vertex: CpNode;
-    mat: Mat;
-    sat: Mat;
-    maxVertex: CpNode;
-    leaves: CpNode[];
-    culls: Circle[];
-    cpNode: ICpNodeForDebugging;
-}
+type DebugElems = typeof emptyDebugElems;
+
+type DebugElem = { [T in keyof DebugElems]: DebugElems[T][number]; }
 
 
-export { IDebugElems }
+export {
+    DebugElems, DebugElemKey, DebugElem,
+    emptyDebugElems, debugElemNames,
+}
+

package/src/debug/debug.ts

@@ -1,11 +1,8 @@
 import { generalDebugFunctions } from './functions/general.js';
 import { IGeneralDebugFunctions } from './functions/general.js'; 
-import { twoProngDebugFunctions } from './functions/two-prong.js';
-import { ITwoProngDebugFunctions } from './functions/two-prong.js';
-import { threeProngDebugFunctions } from './functions/three-prong.js';
-import { IThreeProngDebugFunctions } from './functions/three-prong.js';
-import { drawElemFunctions, TDrawElemFunctions } from './functions/draw-elem/draw-elem.js';
-import { IDebugElems } from './debug-elem-types.js';
+import { DrawElemFunctions } from './functions/draw-elem/draw-elem.js';
+import { DebugElems } from './debug-elem-types.js';
+import { drawElemFs } from './functions/draw-elem/draw-elem.js';
 
 
 /** @internal */
@@ -22,7 +19,7 @@ interface Debug {
 
 
 /** @internal */
-type GeneratedElems = { [T in keyof IDebugElems]: IDebugElems[T][] };
+type GeneratedElems = { [T in keyof DebugElems]: DebugElems[T][] };
 
 
 /** @internal */
@@ -46,10 +43,7 @@ interface Generated {
 
 /** @internal */
 interface IDebugFunctions extends IGeneralDebugFunctions {
-    //draw       : IDrawFunctions,
-    twoProng   : ITwoProngDebugFunctions,
-    threeProng : IThreeProngDebugFunctions,
-    drawElem   : TDrawElemFunctions,
+    drawElem   : DrawElemFunctions,
 }
 
 
@@ -77,29 +71,31 @@ function enableDebugForMat(debugOn: boolean) {
         generated: { 
             //...debug?.generated,
             ...(!debug ? {} : !debug.generated ? {} : debug.generated),
+            // @ts-ignore
             elems: { 
                 //...debug?.generated?.elems,
                 ...(!debug ? {} : !debug.generated ? {} : !debug.generated.elems ? {} : debug.generated.elems),
                 oneProng             : [],
-                oneProngAtDullCorner : [],
-                twoProng_regular     : [],
-                twoProng_failed      : [],
-                twoProng_notAdded    : [],
-                twoProng_deleted     : [],
-                twoProng_holeClosing : [],
+                // oneProngAtDullCorner : [],
+                twoProng             : [],
+                // twoProng_regular     : [],
+                // twoProng_failed      : [],
+                // twoProng_notAdded    : [],
+                // twoProng_deleted     : [],
+                // twoProng_holeClosing : [],
                 looseBoundingBox     : [],
                 tightBoundingBox     : [],
-                sharpCorner          : [],
-                dullCorner           : [],
+                // sharpCorner          : [],
+                // dullCorner           : [],
                 vertex               : [],
                 threeProng           : [],
                 boundingHull         : [],
                 mat                  : [],
-                sat                  : [],
+                // sat                  : [],
                 cpNode               : [],
                 maxVertex            : [],
                 leaves               : [],
-                culls                : [],
+                // culls                : [],
             },
             timing: {
                 //...debug?.generated?.timing,
@@ -114,14 +110,13 @@ function enableDebugForMat(debugOn: boolean) {
         fs: {
             //...debug?.fs,
             ...(!debug ? {} : !debug.fs ? {} : debug.fs),
+            // @ts-ignore
             drawElem: {
                 //...debug?.fs?.drawElem,
                 ...(!debug ? {} : !debug.fs ? {} : !debug.fs.drawElem ? {} : debug.fs.drawElem),
-                ...drawElemFunctions
+                ...drawElemFs
             },
-            ...generalDebugFunctions,
-            twoProng: twoProngDebugFunctions,
-            threeProng: threeProngDebugFunctions, 
+            ...generalDebugFunctions
         },
         directives: {
             //...debug?.directives,

package/src/debug/functions/check-ordering.ts

@@ -0,0 +1,97 @@
+import { Loop } from "flo-boolean";
+import { LlRbTree } from "flo-ll-rb-tree";
+import { compareCps } from "../../contact-point/contact-point.js";
+import { CpNode } from "../../cp-node/cp-node.js";
+import { getAllOnLoop } from "../../cp-node/fs/get-all-on-loop.js";
+import { getProngCount } from "../../cp-node/fs/get-prong-count.js";
+import { isOrderCorrect } from "../../cp-node/fs/is-order-correct.js";
+
+
+function checkOrdering(
+        cpTrees: Map<Loop,LlRbTree<CpNode>>,
+        cpStart: CpNode) {
+
+    const cpNodes = getAllOnLoop(cpStart);
+
+    const wrongsPerLoop: Map<Loop,[Order,Order][]> = new Map();
+    for (const cpNodeA of cpNodes) {
+        const cpNodeB = cpNodeA.next;
+
+        const cpA = cpNodeA.cp;
+        const posA = cpA.pointOnShape;
+        const idxA = posA.curve.idx;
+        const pA = posA.p;
+        const loopA = posA.curve.loop;
+        const cpTreeA = cpTrees.get(loopA)!;
+
+        const cpB = cpNodeB.cp;
+        const posB = cpB.pointOnShape;
+        const idxB = posB.curve.idx;
+        const pB = posB.p;
+        // const loopB = posB.curve.loop;
+        // const cpTreeB = cpTrees.get(loopB)!;
+        
+        const orderCorrect = isOrderCorrect(
+            cpTreeA, cpA, cpNodeB
+        )
+        if (!orderCorrect) {
+            const A: Order = {
+                prongCount: getProngCount(cpNodeA),
+                p: pA,
+                cpNode: cpNodeA,
+                curveIdx: idxA,
+                t: cpA.pointOnShape.t,
+                order: cpA.order,
+                order2: cpA.order2
+            }
+            const B: Order = {
+                prongCount: getProngCount(cpNodeB),
+                p: pB,
+                cpNode: cpNodeB,
+                curveIdx: idxB,
+                t: cpB.pointOnShape.t,
+                order: cpB.order,
+                order2: cpB.order2
+            }
+            const loopA = A.cpNode.cp.pointOnShape.curve.loop;
+            let wrongs = wrongsPerLoop.get(loopA);
+            if (wrongs === undefined) {
+                wrongs = [];
+                wrongsPerLoop.set(loopA, wrongs);
+            }
+            wrongs.push([A,B]);
+        }
+    }
+
+    for (const [loop,wrongs] of wrongsPerLoop) {
+        let maxOrder = Number.NEGATIVE_INFINITY;
+        let max: Order | undefined = undefined;
+        for (const wrong of wrongs) {
+            const A = wrong[0];
+            const B = wrong[1];
+            const c = compareCps(A.cpNode.cp,B.cpNode.cp);
+            if (c > maxOrder) { 
+                
+            }
+            // console.log(wrong[0]);
+            // console.log(wrong[1]);
+            // console.log('---------');
+        }
+    }
+    // }
+}
+
+
+interface Order {
+    prongCount: number;
+    cpNode: CpNode;
+    p: number[];
+    /** From highest to lowest significance */
+    curveIdx: number;
+    t: number;
+    order: number;
+    order2: number;
+}
+
+
+export { checkOrdering }