flo-mat 4.1.3 → 4.1.5

package/src/find-3-prong/find-and-add-3-prong.ts

@@ -25,7 +25,6 @@ function findAndAdd3Prong(
         δs.push([visitedCp, visitedCp.next]);
     }
 
-
     const threeProngInfo = find3Prong(δs, meta.maxCoordPowerOf2);
 
     const { circle, poss, δ3s } = threeProngInfo;
@@ -49,9 +48,7 @@ function findAndAdd3Prong(
     }
 
     const cpNodes = closeBysFor3Prong.length === 0
-        ? addToCpTree(
-            true, false, circle, orders, meta, poss, δ3s.map(v => v[0])
-        ).cpNodes
+        ? addToCpTree(true, false, circle, orders, meta, poss, δ3s).cpNodes
         : [];
 
     return { closeBysFor3Prong, cpNodes: cpNodes as CpNode[] };

package/src/find-3-prong/find-and-add-3-prongs-on-loop.ts

@@ -12,7 +12,7 @@ import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
  *
  * @param meta
  * @param cpStart The CpNode to start traversing from. 
-  */
+ */
 function findAndAdd3ProngsOnLoop(
         meta: MatMeta,
         cpStart: CpNode | undefined): CpNode | undefined {
@@ -25,8 +25,11 @@ function findAndAdd3ProngsOnLoop(
         reLoop = false;
         const cpNodeSet = new Set(getAllOnLoop(cpStart));
         for (const cpNode of cpNodeSet) {
-            const { closeBysFor3Prong, addedCpNodes } = 
-                findAndAdd3Prongs(meta, cpNode);
+            const threeProngs = findAndAdd3Prongs(meta, cpNode);
+            if (threeProngs === undefined) {
+                return getFirstItemOfSet(cpNodeGoodSet)!; 
+            }
+            const { closeBysFor3Prong, addedCpNodes } = threeProngs;
 
             if (addedCpNodes.length > 0) { reLoop = true; }
 

package/src/find-3-prong/three-prong-info.ts

@@ -6,7 +6,7 @@ import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 interface ThreeProngInfo {
     readonly circle: Circle;
     readonly poss: PrePointOnShape[];
-    readonly δ3s: CpNode[][];
+    readonly δ3s: [[CpNode, CpNode], [CpNode, CpNode], [CpNode, CpNode]];
 }
 
 

package/src/find-mat/create-initial-cp-tree.ts

@@ -41,8 +41,8 @@ function createInitialCpTree(
             const pos1: PointOnShape = { ...ppos, curve,             t: 1, circle, order: -1, order2: 0 };
             const pos2: PointOnShape = { ...ppos, curve: curve.next, t: 0, circle, order: +1, order2: 0 };
 
-            cpNode1 = insertCpNode(true, false, false, cpTree, pos1, cpNode2, lastInsertId)!;
-            cpNode2 = insertCpNode(true, false, false, cpTree, pos2, cpNode1, lastInsertId)!;
+            cpNode1 = insertCpNode(true, false, false, cpTree, pos1, cpNode2, undefined, /* unused */ lastInsertId)!;
+            cpNode2 = insertCpNode(true, false, false, cpTree, pos2, cpNode1, undefined, /* unused */ lastInsertId)!;
             
             cpNode1.prevOnCircle = cpNode2;
             cpNode2.prevOnCircle = cpNode1;

package/src/find-mat/find-mat.ts

@@ -16,6 +16,7 @@ import { getFor2ProngsOnLoop } from './get-for-2-prongs-on-loop.js';
 import { getFor1ProngsOnLoop } from './get-for-1-prongs-on-loop.js';
 import { findAndAddHoleClosing2Prongs } from '../find-2-prong/find-and-add-hole-closing-2-prongs.js';
 import { getShapeBounds } from '../svg/get-shape-bounds.js';
+import { checkOrdering } from '../debug/functions/check-ordering.js';
 
 
 /**
@@ -85,10 +86,10 @@ function findMat(
     if (cpNode === undefined) { return undefined!; }
 
     if (typeof _debug_ !== 'undefined') {
-        if (_debug_.directives.stopAfterThreeProngs) { return { cpNode: cpNode!, meta }; }
+        if (_debug_.directives.stopAfterThreeProngs) { return { cpNode, meta }; }
     }
 
-    // if (cpNode !== undefined) { checkOrdering(cpTrees, cpNode); }
+    // if (cpNode !== undefined) { checkOrdering(meta, cpNode); }
 
     const mat = { cpNode, meta };
 

package/src/find-mat/get-for-1-prongs-on-loop.ts

@@ -34,7 +34,9 @@ function getFor1ProngsOnLoop(
             }));
         }
 
-        return poss;
+        return poss
+            // keep away from edges
+            .filter(pos => pos.t > 2**-20 && pos.t < 2**-20);
     }
 }
 

package/src/geometry/get-closest-squared-distance-to-rotated-rect.ts

@@ -1,6 +1,6 @@
-import { 
-    squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween 
-} from 'flo-vector2d';
+import { squaredDistanceBetweenPointAndLineSegment, squaredDistanceBetween } from 'flo-vector2d';
+
+const { min } = Math;
 
 
 /**
@@ -23,7 +23,7 @@ function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]) {
         return 0; // Inside rotated rect
     }
 
-    return Math.min(...ds);
+    return min(...ds);
 }
 
 

package/src/mat/add-to-cp-tree copy.ts

@@ -0,0 +1,71 @@
+import type { Circle } from '../geometry/circle.js';
+import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { MatMeta } from '../mat/mat-meta.js';
+import { getCpNodeNeighbors } from './get-cp-node-neighbors.js';
+import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
+import { joinSpokes } from '../add-n-prong.ts/join-spokes.js';
+
+
+/**
+ * Insert the given `poss` into the `cpTree` (within `meta`) and returns the
+ * newly inserted `CpNode`s.
+ * 
+ * @param circle 
+ * @param orders 
+ * @param cpTrees 
+ * @param poss 
+ * @param neighbors 
+ * 
+ * @internal
+ */
+function addToCpTree(
+        insertIfOrderIsWrong: boolean,
+        isHoleClosing: boolean,
+        circle: Circle, 
+        orders: number[],
+        meta: MatMeta,
+        poss: PrePointOnShape[],
+        neighbors?: [CpNode,CpNode][]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
+
+    const { cpTrees } = meta;
+
+    let anyFailed = false;
+    const cpNodes = poss.map((ppos,i) => {
+        const order = orders[i];
+        const cpTree = cpTrees.get(ppos.curve.loop)!;
+        const pos: PointOnShape = { ...ppos, circle, order, order2: 0 };
+
+        const r = neighbors === undefined
+            ? getCpNodeNeighbors(cpTree, ppos, order, 0)
+            : neighbors[i];
+
+        const pred = r?.[0];
+        // const succ = r?.[1];
+        const succ = pred?.next;
+
+        const cpNode = insertCpNode(
+            insertIfOrderIsWrong,
+            isHoleClosing,
+            false,
+            cpTree,
+            pos,
+            pred,
+            succ,
+            meta.lastInsertId
+        );
+
+        if (cpNode === undefined) { anyFailed = true; }
+
+        return cpNode;
+    });
+
+    if (!anyFailed) {
+        joinSpokes(circle, cpNodes as CpNode[]);
+    }
+
+    return { anyFailed, cpNodes };
+}
+
+
+export { addToCpTree }

package/src/mat/add-to-cp-tree.ts

@@ -2,12 +2,15 @@ import type { Circle } from '../geometry/circle.js';
 import type { PointOnShape, PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { CpNode } from '../cp-node/cp-node.js';
 import type { MatMeta } from '../mat/mat-meta.js';
-import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
+import { getCpNodeNeighbors } from './get-cp-node-neighbors.js';
 import { insertCpNode } from '../cp-node/fs/insert-cp-node.js';
 import { joinSpokes } from '../add-n-prong.ts/join-spokes.js';
 
 
 /**
+ * Insert the given `poss` into the `cpTree` (within `meta`) and returns the
+ * newly inserted `CpNode`s.
+ * 
  * @param circle 
  * @param orders 
  * @param cpTrees 
@@ -23,7 +26,7 @@ function addToCpTree(
         orders: number[],
         meta: MatMeta,
         poss: PrePointOnShape[],
-        neighbors?: CpNode[]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
+        neighbors?: [CpNode,CpNode][]): { anyFailed: boolean, cpNodes: (CpNode | undefined) [] } {
 
     const { cpTrees } = meta;
 
@@ -33,10 +36,13 @@ function addToCpTree(
         const cpTree = cpTrees.get(ppos.curve.loop)!;
         const pos: PointOnShape = { ...ppos, circle, order, order2: 0 };
 
-        const pred = neighbors === undefined
-            ? getCpNodeToLeftOrSame(cpTree, ppos, order, 0)
+        const r = neighbors === undefined
+            ? getCpNodeNeighbors(cpTree, ppos, order, 0)
             : neighbors[i];
 
+        const pred = r?.[0];
+        const succ = r?.[1];
+
         const cpNode = insertCpNode(
             insertIfOrderIsWrong,
             isHoleClosing,
@@ -44,6 +50,8 @@ function addToCpTree(
             cpTree,
             pos,
             pred,
+            // pred?.next,
+            succ,
             meta.lastInsertId
         );
 

package/src/mat/get-boundary-piece-beziers.ts

@@ -5,7 +5,7 @@ import { comparePoss } from '../point-on-shape/compare-poss.js';
 
 
 /**
- * Returns the ordered bezier pieces between from the given boundary piece.
+ * Returns the ordered bezier pieces between the two given `CpNode`s.
  * 
  * @param cpNodes - An ordered pair that represents the start and end points of 
  * the boundary piece
@@ -13,7 +13,7 @@ import { comparePoss } from '../point-on-shape/compare-poss.js';
  * @internal
  */
 function getBoundaryPieceBeziers(
-        cpNodes: CpNode[]): CurvePiece[] {
+        cpNodes: [CpNode,CpNode]): CurvePiece[] {
 
     let cpThis = cpNodes[0]; 
     const cpEnd  = cpNodes[1];

package/src/mat/get-closeby-cp-if-exist.ts

@@ -3,12 +3,14 @@ import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { Circle } from '../geometry/circle.js';
 import type { MatMeta } from './mat-meta.js';
 import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
-import { getCpNodeToLeftOrSame } from './get-cp-node-to-left-or-same.js';
+import { getCpNodeNeighbors } from './get-cp-node-neighbors.js';
+
+const { cos, PI: π } = Math;
 
 
 /** @internal */
 const DEGREES = 1;
-const ANGLE_THRESHOLD = Math.cos(DEGREES * (Math.PI / 180));
+const ANGLE_THRESHOLD = cos(DEGREES * (π/180));
 
 
 /**
@@ -36,7 +38,7 @@ function getCloseByCpIfExist(
     const DISTANCE_THRESHOLD_2 = 2**(maxCoordPowerOf2 - 46);
 
     const cpTree = cpTrees.get(pos.curve.loop)!;
-    const cur = getCpNodeToLeftOrSame(cpTree, pos, order, order2);
+    const cur = getCpNodeNeighbors(cpTree, pos, order, order2)?.[0];
     if (!cur) { return undefined; }
     const cpNodes = [cur, cur.next];
 

package/src/mat/{get-cp-node-to-left-or-same.ts → get-cp-node-neighbors.ts}

@@ -16,29 +16,31 @@ import { RbTree } from 'flo-ll-rb-tree';
  * @param order 
  * @param order2 
  */
-function getCpNodeToLeftOrSame(
+function getCpNodeNeighbors(
         cpTree: RbTree<CpNode>,
         pos: PrePointOnShape,
         order: number,
-        order2: number): CpNode | undefined {
+        order2: number): [CpNode,CpNode] | undefined {
 
     const pointOnShape = { ...pos, order, order2 };
     const cps = cpTree.findBounds({ pointOnShape } as CpNode);
+    const [cp0,cp1] = cps;
 
-    if (cps[0] === undefined && cps[1] === undefined) { 
+    if (cp0 === undefined && cp1 === undefined) { 
         // The tree is still empty
         return undefined;
     }
 
-    if (cps[0] === undefined || cps[1] === undefined) { 
-        // Smaller than all -> cptree.min() === cps[1].data OR
-        // Larger  than all -> cptree.max() === cps[0].data
-        // return cpTree.max(cpTree.root);
-        return cpTree.getMaxNode()?.datum;
+    if (cp0 === undefined || cp1 === undefined) { 
+        // Smaller than all OR larger than all
+        const minNode = cpTree.getMinNode()?.datum!;
+        const maxNode = cpTree.getMaxNode()?.datum!;
+
+        return [maxNode,minNode];
     }
 
-    return cps[0].datum;
+    return [cp0.datum, cp1.datum];
 }
 
 
-export { getCpNodeToLeftOrSame }
+export { getCpNodeNeighbors }

package/src/point-on-shape/point-on-shape.ts

@@ -44,6 +44,11 @@ interface PointOnShape extends PrePointOnShape {
      * The (cached) maximal disk circle touching this point.
      * Calculated from `curve` and `t` (if 2-prong source point, else
      * from `curve` and `t` of the antipodal 2-prong point).
+     *
+     * * the same `Circle` object is shared by all `CpNode`s on the same
+     *   on-circle ring (`nextOnCircle`), and only by them - so object
+     *   identity identifies the MAT vertex (hole-closer twins form their own
+     *   ring, with their own equal circle)
      */
     readonly circle: Circle;
     /** Internally used to order two points lying at the same planar point. */

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

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

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

@@ -1,6 +1,9 @@
 
+const { PI: π } = Math;
+
+
 function radToDeg(rad: number) {
-    return rad*180/Math.PI;
+    return rad*180/π;
 }
 
 

package/webpack.config.cjs

@@ -38,8 +38,13 @@ const config_Basic = (env, argv) => {
             rules: [{
                 test: /\.tsx?$/,
                 use: [{
-                    loader: 'ts-loader',
-                    options: { silent: true }
+                    loader: 'swc-loader',
+                    options: {
+                        jsc: {
+                            parser: { syntax: 'typescript' },
+                            target: 'esnext'
+                        }
+                    }
                 }],
                 exclude: /node_modules/,
                 sideEffects: false

package/node/mat/get-cp-node-to-left-or-same.js

@@ -1,30 +0,0 @@
-/**
- * @internal
- *
- * Returns the predecessor `CpNode` in the `CpTree` or the same one if they fall
- * on top of each other.
- *
- * * returns `undefined` if the tree is still empty
- *
- * @param cpTree
- * @param pos
- * @param order
- * @param order2
- */
-function getCpNodeToLeftOrSame(cpTree, pos, order, order2) {
-    const pointOnShape = { ...pos, order, order2 };
-    const cps = cpTree.findBounds({ pointOnShape });
-    if (cps[0] === undefined && cps[1] === undefined) {
-        // The tree is still empty
-        return undefined;
-    }
-    if (cps[0] === undefined || cps[1] === undefined) {
-        // Smaller than all -> cptree.min() === cps[1].data OR
-        // Larger  than all -> cptree.max() === cps[0].data
-        // return cpTree.max(cpTree.root);
-        return cpTree.getMaxNode()?.datum;
-    }
-    return cps[0].datum;
-}
-export { getCpNodeToLeftOrSame };
-//# sourceMappingURL=get-cp-node-to-left-or-same.js.map

package/node/mat/get-cp-node-to-left-or-same.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-cp-node-to-left-or-same.js","sourceRoot":"","sources":["../../src/mat/get-cp-node-to-left-or-same.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,SAAS,qBAAqB,CACtB,MAAsB,EACtB,GAAoB,EACpB,KAAa,EACb,MAAc;IAElB,MAAM,YAAY,GAAG,EAAE,GAAG,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAC/C,MAAM,GAAG,GAAG,MAAM,CAAC,UAAU,CAAC,EAAE,YAAY,EAAY,CAAC,CAAC;IAE1D,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAC/C,0BAA0B;QAC1B,OAAO,SAAS,CAAC;IACrB,CAAC;IAED,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QAC/C,sDAAsD;QACtD,mDAAmD;QACnD,kCAAkC;QAClC,OAAO,MAAM,CAAC,UAAU,EAAE,EAAE,KAAK,CAAC;IACtC,CAAC;IAED,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACxB,CAAC;AAGD,OAAO,EAAE,qBAAqB,EAAE,CAAA"}