flo-mat 4.1.4 → 4.1.5

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

@@ -4,6 +4,8 @@ import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse as re
 import { tangent } from 'flo-bezier3';
 import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
 
+const { sqrt } = Math;
+
 
 /**
  * Returns a line segment of unit length starting in the given Vertex center and
@@ -54,8 +56,8 @@ function getEdgeDirection(
         // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
         // recall the half angle formulas. Then the rotation matrix, R, can 
         // be calculated.
-        const cosθ = Math.sqrt((1 + x)/2);
-        const sinθ = Math.sqrt((1 - x)/2);
+        const cosθ = sqrt((1 + x)/2);
+        const sinθ = sqrt((1 - x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }

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

@@ -1,8 +1,8 @@
+import type { CpNode } from '../cp-node.js';
 import { tangent } from 'flo-bezier3';
-import { 
-    fromTo, dot, cross, translate, lineLineIntersection, toUnitVector
-} from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
+import { fromTo, dot, cross, translate, lineLineIntersection, toUnitVector } from 'flo-vector2d';
+
+const { abs } = Math;
 
 
 /** @internal */
@@ -56,8 +56,8 @@ function getImpliedBoundaryBezierBetween(
     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); 
+    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) {
         // not within tolerance

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

@@ -17,6 +17,7 @@ const TOLERANCE_USE_LINE = 0.0001; // else cubic
 /**
  * Returns the bezier curve from the maximal disk of one `CpNode` to another
  * `CpNode`'s maximal disk.
+ * 
  * @param cpNodeFrom 
  * @param cpNodeTo 
  */

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

@@ -5,13 +5,10 @@ import { isTrivial } from "./is-trivial.js";
 
 
 /**
- * Like isTerminating() but only returns true if all cpNodes on the circle
+ * Like `isTerminating` but only returns true if all `CpNode`s on the circle
  * (except this.prevOnCircle) is terminating.
  */
 function isFullyTerminating(cpNode: CpNode) {
-    // const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    // return otherOnCircle.every(isTerminating);
     if (!isTerminating(cpNode)) {
         return false;
     }
@@ -24,9 +21,8 @@ function isFullyTerminating(cpNode: CpNode) {
         cpNode = cpNode.prev;
     }
 
-    const otherOnCircle = getAllOnCircle(cpNode.prevOnCircle, true);
-
-    return otherOnCircle.every(isTerminating);
+    return getAllOnCircle(cpNode.prevOnCircle, true)
+        .every(isTerminating);
 }
 
 

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

@@ -1,11 +1,13 @@
 import { CpNode } from "../cp-node.js";
-import { getAllOnCircle } from "./get-all-on-circle.js";
 
 
 /**
- * Returns true if the 2 given `CpNode`s are on the same maximal disk 
+ * Returns true if the 2 given `CpNode`s are on the same maximal disk
  * circle.
- * 
+ *
+ * * O(1): all `CpNode`s on the same on-circle ring share the same `Circle`
+ *   object, and no other ring does (see `PointOnShape.circle`)
+ *
  * @param cpNode1 A `CpNode`.
  * @param cpNode2 Another `CpNode`
  */
@@ -13,10 +15,7 @@ function isOnSameCircle(
         cpNode1: CpNode,
         cpNode2: CpNode) {
 
-    // const cpNodes = getAllOnCircle(cpNode1, true);
-    const cpNodes = getAllOnCircle(cpNode1);
-
-    return cpNodes.indexOf(cpNode2) >= 0;
+    return cpNode1.pointOnShape.circle === cpNode2.pointOnShape.circle;
 }
 
 

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

@@ -1,7 +1,9 @@
 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 type { Mutable } from "../../utils/mutable.js";
 import { EDGES } from "./cp-node-stringifyable";
+import { getAllOnCircle } from "../fs/get-all-on-circle.js";
 import { loopFromStringifyable } from './loop-from-stringifyable.js';
 
 
@@ -51,6 +53,21 @@ function fromStringifyable(
         }
     }
 
+    //--------------------------------------------------------------------------
+    // Third pass: one shared `Circle` object per on-circle ring, as when the
+    // MAT was built (the JSON gave every contact point its own copy).
+    //--------------------------------------------------------------------------
+    const done = new Set<CpNode>();
+    for (const cpNode of cpNodes) {
+        if (done.has(cpNode)) { continue; }
+
+        const { circle } = cpNode.pointOnShape;
+        for (const cp of getAllOnCircle(cpNode)) {
+            done.add(cp);
+            (cp.pointOnShape as Mutable<PointOnShape>).circle = circle;
+        }
+    }
+
     return cpNodes[0];
 }
 

package/src/find-2-prong/add-2-prong.ts

@@ -83,12 +83,17 @@ function closeHole(
 
     const [cpNodeSource, cpNodeAntipode] = cpNodes as Mutable<CpNode>[];
 
+    // The twins form their own on-circle ring (a separate MAT vertex - that
+    // is what cuts the hole), so they get their own (equal) `Circle` object:
+    // one `Circle` object per ring.
+    const twinCircle: Circle = { ...cpNodeSource.pointOnShape.circle };
+
     // Antipode - create and insert twin
     const posAntipode = cpNodeAntipode.pointOnShape;
     const cpNodeAntipodeTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posAntipode.curve.loop)!,
-        { ...posAntipode, order2: +1 },
+        { ...posAntipode, circle: twinCircle, order2: +1 },
         cpNodeAntipode,
         undefined,  // unused
         meta.lastInsertId
@@ -101,7 +106,7 @@ function closeHole(
     const cpNodeSourceTwin = insertCpNode(
         true, true, false,
         cpTrees.get(posSource.curve.loop)!,
-        { ...posSource!, order2: -1 },
+        { ...posSource!, circle: twinCircle, order2: -1 },
         cpNodeSource.prev,
         undefined,  // unused
         meta.lastInsertId

package/src/find-2-prong/calc-seperation-tolerance.ts

@@ -89,10 +89,10 @@ export { calcSeperationTolerance }
 
 
 // function degToRad(degrees: number) {
-//     return degrees/360*2*Math.PI;
+//     return degrees/360*2*PI;
 // }
 // function radToDeg(rad: number) {
-//     return rad*360/2/Math.PI;
+//     return rad*360/2/PI;
 // }
 
 

package/src/find-3-prong/find-3-prong-for-delta3s.ts

@@ -174,7 +174,7 @@ function find3ProngForDelta3s(
             const v2 = toUnitVector( tangent(pos.curve.ps, pos.t) );
             
             // Cross is more numerically stable than Vector.dot at angles a
-            // multiple of `Math.PI` **and** is close to the actual angle value
+            // multiple of π **and** is close to the actual angle value
             // and can thus just be added to cone method of looking at 
             // tolerance.
             

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/get-closeby-cp-if-exist.ts

@@ -5,10 +5,12 @@ import type { MatMeta } from './mat-meta.js';
 import { distanceBetween, toUnitVector, fromTo, dot } from 'flo-vector2d';
 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));
 
 
 /**

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