flo-mat 3.0.14 → 4.0.1

package/src/cp-node/fs/find-first.ts

@@ -1,22 +1,25 @@
-import { CpNode } from "../cp-node.js";
-import { CpNodeFs } from "../cp-node-fs.js";
+import type { CpNode } from "../cp-node.js";
 
 
+/**
+ * Finds the first `CpNode` in the same MAT tree for which `f` returns a
+ * truthy value. Returns `undefined` if no such `CpNode` exists.
+ * 
+ * @param f a function that takes a `CpNode` and returns a `CpNode` or `undefined`
+ * @param cpNode a `CpNode` on the MAT tree to search from
+ */
 function findFirst(
-        f: (cpNode: CpNode) => CpNode | undefined,
+        f: (cpNode: CpNode) => boolean,
         cpNode: CpNode): CpNode | undefined { 
 
     const cpStart = cpNode;
 
-    if (f(cpStart)) { return cpStart; }
-
-    let cpNode_ = cpNode.next;
-    while (cpNode_ !== cpStart) {
-        if (f(cpNode_)) {
-            return cpNode_;
+    do {
+        if (f(cpNode)) {
+            return cpNode;
         }
-        cpNode_ = cpNode_.next;
-    }
+        cpNode = cpNode.next;
+    } while (cpNode !== cpStart);
 
     return undefined;
 }

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

@@ -9,13 +9,12 @@ function getAllOnLoop(
         cpNode: CpNode) {
 
     const cpStart = cpNode;
-    const cpNodes = [cpStart];
-    let cpNode_ = cpNode.next;
+    const cpNodes: CpNode[] = [];
 
-    while (cpNode_ !== cpStart) {
-        cpNodes.push(cpNode_);
-        cpNode_ = cpNode_.next;
-    }
+    do {
+        cpNodes.push(cpNode);
+        cpNode = cpNode.next;
+    } while (cpNode !== cpStart);
 
     return cpNodes;
 }

package/src/cp-node/fs/get-boundary-bezier-parts-to-next.ts

@@ -1,6 +1,6 @@
 import type { BezierPiece } from 'flo-bezier3';
+import type { Curve } from 'flo-boolean';
 import type { CpNode } from '../cp-node.js';
-import type { Curve  } from '../../curve/curve.js';
 
 
 /**
@@ -19,8 +19,8 @@ function getBoundaryBezierPartsToNext(
     const cpThis = cpNode; 
     const cpNext = cpNode.next;
 
-    const posThis = cpThis.cp.pointOnShape;
-    const posNext = cpNext.cp.pointOnShape;
+    const posThis = cpThis.pointOnShape;
+    const posNext = cpNext.pointOnShape;
 
     const curveThis = posThis.curve;
     const curveNext = posNext.curve;

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

@@ -6,14 +6,14 @@ import { CpNode } from '../cp-node.js';
  * @param cpNode 
  */
 function getCpNodeOrdering(cpNode: CpNode) {
-    const cp = cpNode.cp;
-    const pos = cp.pointOnShape;
+    // const cp = cpNode.cp;
+    const pos = cpNode.pointOnShape;
 
     return {
         'idx': pos.curve.idx,
         't': pos.t,
-        'order': cp.order,
-        'order2': cp.order2
+        'order': pos.order,
+        'order2': pos.order2
     };
 }
 

package/src/cp-node/fs/get-edge-direction.ts

@@ -1,10 +1,8 @@
-import { 
-    toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot
-} from 'flo-vector2d';
+import type { Curve } from 'flo-boolean';
+import type { CpNode } from '../cp-node.js';
+import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse, dot } from 'flo-vector2d';
 import { tangent } from 'flo-bezier3';
-import { CpNode } from '../cp-node.js';
 import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
-import { Curve } from '../../curve/curve.js';
 
 
 /**
@@ -14,13 +12,13 @@ import { Curve } from '../../curve/curve.js';
  * @param cpNode 
  */
 function getEdgeDirection(cpNode: CpNode) {
-    const circleCenter = cpNode.cp.circle.center;
+    const circleCenter = cpNode.pointOnShape.circle.center;
 
     const cp1 = cpNode;
     const cp2 = cpNode.nextOnCircle;
 
-    const pos1 = cp1.cp.pointOnShape;
-    const pos2 = cp2.cp.pointOnShape;
+    const pos1 = cp1.pointOnShape;
+    const pos2 = cp2.pointOnShape;
 
     const p1 = pos1.p;
     const p2 = pos2.p;

package/src/cp-node/fs/get-hole-closers.ts

@@ -1,4 +1,4 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
 import { getAllOnLoop } from "./get-all-on-loop.js";
 
 

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

@@ -16,8 +16,8 @@ function getImpliedBoundaryBezierBetween(
         cpNodeA: CpNode,
         cpNodeB: CpNode): number[][] | undefined {
 
-    const posA = cpNodeA.cp.pointOnShape;
-    const posB = cpNodeB.cp.pointOnShape;
+    const posA = cpNodeA.pointOnShape;
+    const posB = cpNodeB.pointOnShape;
 
     let { curve: curveA, p: pA, t: tA } = posA;
     let { curve: curveB, p: pB, t: tB } = posB;

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

@@ -1,10 +1,12 @@
+import type { CpNode } from '../cp-node.js';
 import { 
     fromTo, dot, cross, rotate90Degrees, interpolate, translate,
     lineLineIntersection
 } from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
 import { getEdgeDirection } from './get-edge-direction.js';
 
+const { abs } = Math;
+
 
 /** @internal */
 const TOLERANCE_ADD_2PRONG = 0.01;
@@ -22,10 +24,10 @@ function getMatCurveBetween(
         cpNodeFrom: CpNode, 
         cpNodeTo: CpNode): number[][] {
 
-    const fromCc = cpNodeFrom.cp.circle.center;
+    const fromCc = cpNodeFrom.pointOnShape.circle.center;
     const fromL = getEdgeDirection(cpNodeFrom);
 
-    const toCc = cpNodeTo.cp.circle.center;
+    const toCc = cpNodeTo.pointOnShape.circle.center;
     const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
 
     const mid = lineLineIntersection(fromL, toL);
@@ -50,11 +52,11 @@ function getMatCurveBetween(
     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); 
+    const d1 = abs(cross(c, w1)) / (3*3); 
+    const d2 = abs(cross(c, w2)) / (3*3); 
 
     if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // TODO - not within tolerance - must add additional 2-prong
+        // FUTURE - not within tolerance - must add additional 2-prong
         return [fromCc, toCc];
     } 
 

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

@@ -1,6 +1,6 @@
+import type { CpNode } from "../cp-node.js";
 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';
 
@@ -12,8 +12,8 @@ import { sum } from '../../utils/sum.js';
 function getSalience(cpNode: CpNode) {
     const cpNode1 = cpNode;
     const cpNode2 = cpNode.nextOnCircle;
-    const bp1 = cpNode1.cp.pointOnShape.p;
-    const bp2 = cpNode2.cp.pointOnShape.p;
+    const bp1 = cpNode1.pointOnShape.p;
+    const bp2 = cpNode2.pointOnShape.p;
 
     const d = distanceBetween(bp1, bp2);
 
@@ -21,7 +21,7 @@ function getSalience(cpNode: CpNode) {
 
     const s = sum(pss.map(ps => totalLength(ps)));
 
-    return hasHoleCloser ? Number.POSITIVE_INFINITY : s/d;
+    return hasHoleCloser ? Infinity : s/d;
 }
 
 

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

@@ -1,6 +1,7 @@
+import type { CpNode } from "../cp-node.js";
+import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import type { Mutable } from "../../utils/mutable.js";
 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";
 
 
@@ -9,21 +10,20 @@ function insertCpNode(
         isHoleClosing: boolean,
         isIntersection: boolean,
         cpTree: LlRbTree<CpNode>,
-        cp: ContactPoint, 
+        pos: PointOnShape,
         _prev: CpNode | undefined,
         lastInsertId: { id: number }): CpNode | undefined {
 
     if (_prev !== undefined &&
-        !isOrderCorrect(cpTree, cp, _prev.next)) {
+        !isOrderCorrect(cpTree, pos, _prev.next)) {
 
-        // console.log(compareCps(cp,_prev!.next.cp))
         if (!insertIfOrderWrong) {
             return undefined;
         }
     }
 
-    const cpNode: CpNode = {
-        cp,
+    const cpNode: Mutable<CpNode> = {
+        pointOnShape: pos,
         isHoleClosing,
         isIntersection,
         id: lastInsertId.id,
@@ -37,14 +37,14 @@ function insertCpNode(
     const prev = _prev === undefined ? cpNode : _prev;
     const next = _prev === undefined ? cpNode : prev.next;
 
-    next.prev = cpNode;
-    prev.next = cpNode;
+    (next as Mutable<CpNode>).prev = cpNode;
+    (prev as Mutable<CpNode>).next = cpNode;
     cpNode.prev = prev;
     cpNode.next = next;
 
     cpTree.insert(cpNode);
 
-    return cpNode;
+    return cpNode as CpNode;
 }
 
 

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

@@ -5,6 +5,7 @@ import { getAllOnCircle } from "./get-all-on-circle.js";
 /**
  * Returns true if the 2 given `CpNode`s are on the same maximal disk 
  * circle.
+ * 
  * @param cpNode1 A `CpNode`.
  * @param cpNode2 Another `CpNode`
  */

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

@@ -1,4 +1,5 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
+import { getRealProngCount } from "./get-real-prong-count.js";
 
 
 /**
@@ -9,20 +10,8 @@ import { CpNode } from "../cp-node.js";
  * Note, however, that two `CpNode`s are stored for each such point to
  * preserve symmetry - see `isTerminating` for more details.
  */
-// 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]);
+    return getRealProngCount(cpNode) === 1 && !cpNode.isHoleClosing;
 }
 
 

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

@@ -1,20 +1,18 @@
 import type { CpNode } from "../cp-node.js";
 import { LlRbTree } from "flo-ll-rb-tree";
-import { compareCps, ContactPoint } from "../../contact-point/contact-point.js";
+import { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import { comparePoss } from "../../point-on-shape/compare-poss.js";
 
 
 function isOrderCorrect(
         cpTree: LlRbTree<CpNode>,
-        cp: ContactPoint,
+        pos: PointOnShape,
         next: CpNode): boolean {
 
-    // TODO2
-    const c = compareCps(cp,next.cp);
+    const c = comparePoss(pos, next.pointOnShape);
     if (c < 0) { return true; }
     if (c === 0) {
-        // TODO2
-        // console.log('c === 0');
-        return true;
+        return false;
     }
 
     const minNode = cpTree.getMinNode();
@@ -26,7 +24,7 @@ function isOrderCorrect(
     const max = cpTree.getMaxNode()!.datum;
 
     // larger than all -> crossing zero on loop
-    return (compareCps(max.cp,cp) < 0 && min === next);
+    return (comparePoss(max.pointOnShape!, pos) < 0 && min === next);
 }
 
 

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

@@ -9,7 +9,7 @@ import { CpNode } from "../cp-node.js";
  * terminating and one not. See `isTerminating` for more details.
  */
 function isSharp(cpNode: CpNode) {
-    return cpNode.cp.circle.radius === 0;
+    return cpNode.pointOnShape.circle.radius === 0;
 }
 
 

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

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

package/src/cp-node/stringification/cp-node-stringifyable.ts

@@ -0,0 +1,59 @@
+import type { Circle } from "../../geometry/circle";
+import type { PointOnShape } from "../../point-on-shape/point-on-shape";
+import type { CpNode } from "../cp-node";
+import type { LoopStringifyable } from "./loop-stringifyable";
+
+
+/** @internal */
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
+/** @internal */
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
+
+/** @internal */
+type Edge =
+    | 'prev' | 'next'
+    | 'prevOnCircle' | 'nextOnCircle'
+    | 'holeCloserTwin';
+
+
+/** @internal */
+type PointOnShapeSimplified = Omit<PointOnShape, 'curve'> & {
+    readonly loopIdx: number;
+    readonly curveIdx: number;
+}
+
+/** @internal */
+type CpNodeSimplified = Omit<CpNode, 'pointOnShape'> & {
+    readonly pointOnShape: PointOnShapeSimplified;
+}
+
+/** @internal */
+type CpNodeSimplifiedEdgeless = Omit<CpNodeSimplified, Edge>;
+
+/** @internal */
+type CpNodeWithAnyEdges = PartialBy<
+    CpNodeSimplifiedEdgeless & Record<Edge, CpNode | number>,
+    'holeCloserTwin'
+>
+
+
+interface CpNodeStringifyable {
+    readonly cpNodes: CpNodeWithAnyEdges[];
+    readonly loops: LoopStringifyable[];
+}
+
+
+const EDGES: Edge[] = [
+    'prev', 'next',
+    'prevOnCircle', 'nextOnCircle',
+    'holeCloserTwin'
+];
+
+
+export { EDGES }
+export type {
+    PointOnShapeSimplified,
+    CpNodeSimplified, CpNodeSimplifiedEdgeless,
+    CpNodeStringifyable, CpNodeWithAnyEdges,
+}

package/src/cp-node/stringification/from-stringifyable.ts

@@ -0,0 +1,57 @@
+import type { PointOnShape } from "../../point-on-shape/point-on-shape.js";
+import type { CpNode } from "../cp-node";
+import type { CpNodeStringifyable } from "./cp-node-stringifyable";
+import { EDGES } from "./cp-node-stringifyable";
+import { loopFromStringifyable } from './loop-from-stringifyable.js';
+
+
+function fromStringifyable(
+        cpNodesStringifyable: CpNodeStringifyable) {
+
+    const { cpNodes: _cpNodes, loops: _loops } = cpNodesStringifyable;
+    const loops = _loops.map(loopFromStringifyable);
+
+    //--------------------------------------------------------------------------
+    // First pass: build all CpNode objects with proper `cp`.
+    // Edges still hold number ids at this point.
+    //--------------------------------------------------------------------------
+    const cpNodes: CpNode[] = _cpNodes.map(cpNode_ => {
+        const { id, pointOnShape, isHoleClosing, isIntersection } = cpNode_;
+        const { circle, order, order2 } = pointOnShape;
+        const { curveIdx, loopIdx, p, t, isSource } = pointOnShape;
+
+        const curve = loops[loopIdx].curves[curveIdx];
+
+        const pointOnShape_: PointOnShape = {
+            circle,
+            curve, p, t, isSource,
+            order, order2
+        };
+
+        return {
+            ...cpNode_,
+            id, isHoleClosing, isIntersection,
+            pointOnShape: pointOnShape_
+        } as CpNode;
+    });
+
+    //--------------------------------------------------------------------------
+    // Second pass: replace number id edges with real CpNode references.
+    //--------------------------------------------------------------------------
+    const nodeMap = new Map<number, CpNode>(cpNodes.map(n => [n.id, n]));
+
+    for (const cpNode of cpNodes) {
+        for (const edge of EDGES) {
+            const id = cpNode[edge] as unknown as number | undefined;
+            if (id === undefined) { continue; }
+
+            // @ts-ignore
+            cpNode[edge] = nodeMap.get(id)!;
+        }
+    }
+
+    return cpNodes[0];
+}
+
+
+export { fromStringifyable }

package/src/cp-node/stringification/loop-from-stringifyable.ts

@@ -0,0 +1,15 @@
+import type { Loop } from "flo-boolean";
+import type { LoopStringifyable } from "./loop-stringifyable";
+import { loopFromBeziers } from "flo-boolean";
+
+
+function loopFromStringifyable(
+        loopStringifyable: LoopStringifyable): Loop {
+
+    const { idx, beziers } = loopStringifyable;
+
+    return loopFromBeziers(beziers, idx);
+}
+
+
+export { loopFromStringifyable }

package/src/cp-node/stringification/loop-stringifyable.ts

@@ -0,0 +1,8 @@
+
+interface LoopStringifyable {
+    readonly idx: number;
+    readonly beziers: number[][][];
+}
+
+
+export type { LoopStringifyable }

package/src/cp-node/stringification/loop-to-stringifyable.ts

@@ -0,0 +1,14 @@
+import type { Loop } from "flo-boolean";
+import type { LoopStringifyable } from "./loop-stringifyable";
+
+
+function loopToStringifyable(
+        loop: Loop): LoopStringifyable {
+
+    const { idx, beziers } = loop;
+
+    return { idx: idx!, beziers };
+}
+
+
+export { loopToStringifyable }

package/src/cp-node/stringification/to-stringifyable.ts

@@ -0,0 +1,67 @@
+import type { Loop } from "flo-boolean";
+import type { CpNodeStringifyable, CpNodeWithAnyEdges, PointOnShapeSimplified } from "./cp-node-stringifyable.js";
+import type { CpNode } from "../cp-node.js";
+import { loopToStringifyable } from "./loop-to-stringifyable.js";
+
+
+/**
+ * Returns a deep clone of this `CpNode`. Can be used to copy the MAT 
+ * since cloning a single `CpNode` necessarily implies cloning all 
+ * `CpNode`s on the same MAT tree.
+ */
+function toStringifyable(
+        cpNode: CpNode): CpNodeStringifyable {
+
+    const cpNodes_: CpNodeWithAnyEdges[] = [];
+    const loopSet = new Set<Loop>();
+
+    //--------------------------------------------------------------------------
+    // Clone `CpNode`s with edges replaced with ids AND
+    // set the `nodeMap` to map original `CpNode`s to their ids.
+    //--------------------------------------------------------------------------
+    const cpStart = cpNode;
+    do {
+        const {
+            id, isHoleClosing, isIntersection,
+            pointOnShape,
+            prev, next, nextOnCircle, prevOnCircle, holeCloserTwin,
+        } = cpNode
+
+        const { curve, p, t, isSource, circle, order, order2 } = pointOnShape;
+        const { idx: curveIdx, loop, ps, prev: prevCurve, next: nextCurve } = curve;
+
+        if (!loopSet.has(loop)) {
+            loopSet.add(loop);
+        }
+
+        const posSimplified: PointOnShapeSimplified = {
+            curveIdx, loopIdx: loop.idx!, p, t, isSource,
+            circle, order, order2
+        };
+
+        cpNodes_.push({
+            id, isHoleClosing, isIntersection,
+            pointOnShape: posSimplified,
+            prev: prev.id,
+            next: next.id,
+            prevOnCircle: prevOnCircle.id,
+            nextOnCircle: nextOnCircle.id,
+            holeCloserTwin: holeCloserTwin?.id
+        });
+
+        cpNode = cpNode.next;
+    } while (cpNode !== cpStart);
+    //--------------------------------------------------------------------------
+
+    const loops = Array.from(loopSet).sort((a, b) => a.idx! - b.idx!);
+    const loops_ = loops.map(loopToStringifyable);
+
+    return {
+        cpNodes: cpNodes_,
+        loops: loops_
+    };
+}
+
+
+export { toStringifyable }
+

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

@@ -6,7 +6,7 @@ type DebugElemKey = keyof typeof emptyDebugElems;
 
 
 const emptyDebugElems = {
-    oneProng: [] as CpNode[][],
+    oneProng: [] as CpNode[],
     // oneProngAtDullCorner: [] as PointOnShape[],
     twoProng: [] as CpNode[],
     threeProng: [] as CpNode[],
@@ -22,8 +22,7 @@ const emptyDebugElems = {
     cull: [] as number[][],
     cpNode: [] as CpNode[],
     branch: [] as CpNode[][],
-    holeCloser: [] as CpNode[],
-    speed: [] as CpNode[]
+    holeCloser: [] as CpNode[]
 } as const;
 
 

package/src/{mat → debug}/elem-type-two-prong.ts

@@ -5,4 +5,4 @@ type ElemType_TwoProng =
     | 'twoProng_holeClosing';
 
 
-export { ElemType_TwoProng }
+export type { ElemType_TwoProng }