flo-mat 3.0.15 → 4.0.2

package/src/point-on-shape/is-pos-corner.ts

@@ -1,10 +1,7 @@
-import { PointOnShape } from "./point-on-shape.js";
-
-
 /**
  * @internal
  */
-function isPosCorner(pos: PointOnShape) {
+function isPosCorner(pos: { t: number }) {
     return (pos.t === 0 || pos.t === 1);
 }
 

package/src/point-on-shape/is-pos-dull-corner.ts

@@ -1,18 +1,18 @@
-// import { memoize } from "flo-memoize";
-import { getPosCorner } from "./get-pos-corner.js";
+import type { PointOnShape } from "./point-on-shape.js";
+import { getPosCorner$ } from "./get-pos-corner.js";
 import { isPosCorner } from "./is-pos-corner.js";
-import { PointOnShape } from "./point-on-shape.js";
+
 
 /**
  * @internal
  */
-// const isPosDullCorner = memoize(
-    function isPosDullCorner(pos: PointOnShape) {
-        if (!isPosCorner(pos)) { return false; }
+function isPosDullCorner(
+        pos: PointOnShape) {
+
+    if (!isPosCorner(pos)) { return false; }
 
-        return getPosCorner(pos).isDull;
-    }
-// );
+    return getPosCorner$(pos).isDull;
+}
 
 
 export { isPosDullCorner }

package/src/point-on-shape/is-pos-quite-dull-corner.ts

@@ -1,17 +1,18 @@
-import { memoize } from 'flo-memoize';
-import { PointOnShape } from "./point-on-shape.js";
+import type { PointOnShape } from "./point-on-shape.js";
 import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner } from './get-pos-corner.js';
+import { getPosCorner$ } from './get-pos-corner.js';
 
 
 /**
  * @internal
  */
-const isPosQuiteDullCorner = memoize((pos: PointOnShape) => {
+function isPosQuiteDullCorner(
+        pos: PointOnShape) {
+
     if (!isPosCorner(pos)) { return false; }
 
-    return getPosCorner(pos).isQuiteDull;
-});
+    return getPosCorner$(pos).isQuiteDull;
+}
 
 
 export { isPosQuiteDullCorner }

package/src/point-on-shape/is-pos-quite-sharp-corner.ts

@@ -1,17 +1,18 @@
-import { memoize } from 'flo-memoize';
-import { PointOnShape } from "./point-on-shape.js";
+import type { PointOnShape } from "./point-on-shape.js";
 import { isPosCorner } from './is-pos-corner.js';
-import { getPosCorner } from './get-pos-corner.js';
+import { getPosCorner$ } from './get-pos-corner.js';
 
 
 /**
  * @internal
  */
-const isPosQuiteSharpCorner = memoize((pos: PointOnShape) => {
+function isPosQuiteSharpCorner(
+        pos: PointOnShape) {
+
     if (!isPosCorner(pos)) { return false; }
 
-    return getPosCorner(pos).isQuiteSharp;
-});
+    return getPosCorner$(pos).isQuiteSharp;
+}
 
 
 export { isPosQuiteSharpCorner }

package/src/point-on-shape/is-pos-sharp-corner.ts

@@ -1,5 +1,4 @@
-import { memoize } from "flo-memoize";
-import { getPosCorner } from "./get-pos-corner.js";
+import { getPosCorner$ } from "./get-pos-corner.js";
 import { isPosCorner } from "./is-pos-corner.js";
 import { PointOnShape } from "./point-on-shape.js";
 
@@ -7,11 +6,13 @@ import { PointOnShape } from "./point-on-shape.js";
 /**
  * @internal
  */
-const isPosSharpCorner = memoize((pos: PointOnShape) => {
+function isPosSharpCorner(
+        pos: PointOnShape) {
+
     if (!isPosCorner(pos)) { return false; }
 
-    return getPosCorner(pos).isSharp;
-});
+    return getPosCorner$(pos).isSharp;
+}
 
 
 export { isPosSharpCorner }

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

@@ -1,15 +1,53 @@
 import type { Curve } from 'flo-boolean';
+import type { Circle } from '../geometry/circle.js';
 
 
-interface PointOnShape {
-    /** The `Curve` on the shape boundary this points belong to. */
+/**
+ * Represents a point on the shape boundary, including the `curve` it belongs
+ * to, the bezier parameter `t` value on that curve, tha actual point `p` and
+ * whether it is a "source" point.
+ */
+interface PrePointOnShape {
+    /**
+     * The `Curve` on the shape boundary this points belong to.
+     */
     readonly curve: Curve;
-    /** The bezier parameter value on the curve identifying the point coordinates. */
+
+    /**
+     * The bezier parameter value on the curve identifying the point coordinates.
+     * (Considered cached if `isSource` is `false`, i.e. calculated from other
+     * (single source of truth) values)
+     */
     readonly t: number;
+
+    /**
+     * `true` if this is the source 2-prong point from which the antipode point
+     * is found, else `false`. (Also false for n-prongs with n > 2)
+     */
+    readonly isSource: boolean;
+
+    /** The (cached) point on the shape boundary. */
     readonly p: number[];
-    /** just for debugging */
-    readonly isSource?: boolean;
 }
 
 
-export type { PointOnShape }
+/**
+ * Represents a point on the shape boundary, including the `curve` it belongs
+ * to, the bezier parameter `t` value on that curve, tha actual point `p` and
+ * whether it is a "source" point.
+ */
+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).
+     */
+    readonly circle: Circle;
+    /** Internally used to order two points lying at the same planar point. */
+    readonly order: number;
+    /** Internally used to order two points lying at the same planar point. */
+    readonly order2: number;
+}
+
+
+export type { PointOnShape, PrePointOnShape }

package/src/point-on-shape/pos-to-human-string.ts

@@ -1,4 +1,4 @@
-import { PointOnShape } from "./point-on-shape.js"
+import type { PointOnShape } from "./point-on-shape.js";
 
 
 /**
@@ -6,7 +6,9 @@ import { PointOnShape } from "./point-on-shape.js"
  * For debugging only.
  * @internal
  */
-function posToHumanString(pos: PointOnShape) {
+function posToHumanString(
+        pos: PointOnShape) {
+
     return '' + pos.p[0] + ', ' + pos.p[1] + 
         ' | bz: '   + pos.curve.idx + 
         ' | t: '    + pos.t 

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

@@ -0,0 +1,19 @@
+import { evalDeCasteljauDd } from "flo-bezier3";
+
+
+/**
+ * Returns the point `p` for the bezier curve `ps` at the parameter value `t`
+ * with intermediate calculations done in double-double precision.
+ * 
+ * @param ps 
+ * @param t 
+ */
+function toP(
+        ps: number[][],
+        t: number): number[] {
+
+    return evalDeCasteljauDd(ps, [0,t]).map(c => c[0] + c[1]);
+}
+
+
+export { toP }

package/src/sat/add-debug-info.ts

@@ -1,11 +1,11 @@
 declare const _debug_: Debug; 
-
-import { Debug } from '../debug/debug.js';
+import type { Debug } from '../debug/debug.js';
 
 
 /**
- * @internal
  * @param sat 
+ * 
+ * @internal
  */
 function addDebugInfo(
         timingStart: number) {

package/src/sat/cull-non-cycles.ts

@@ -1,15 +1,17 @@
 import { getLeaves } from './get-leaves.js';
 import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
-
-const { getProngCount, isOnSameCircle, isTerminating } = CpNodeFs;
+import { Mutable } from '../utils/mutable.js';
+import { getProngCount } from '../cp-node/fs/get-prong-count.js';
+import { isOnSameCircle } from '../cp-node/fs/is-on-same-circle.js';
+import { isTerminating } from '../cp-node/fs/is-terminating.js';
 
 
 /**
- * @internal
  * Cull all edges not part of a cycle in the MAT planar graph.
  * @param cpStart The start CpNode which must reprsesent the maximal 3-prong 
  * vertex.
+ * 
+ * @internal
  */
 function cullNonCycles(cpStart: CpNode) {
 
@@ -48,8 +50,8 @@ function cullNonCycles(cpStart: CpNode) {
             }
 
             if (cut) {
-                cp1.next = cpNode;
-                cpNode.prev = cp1;
+                (cp1 as Mutable<CpNode>).next = cpNode;
+                (cpNode as Mutable<CpNode>).prev = cp1;
 
                 cpNodeKept = cpNode;
                 break;

package/src/sat/cull.ts

@@ -1,11 +1,10 @@
 import type { CpNode } from '../cp-node/cp-node.js';
 import type { DualSet } from '../utils/dual-set.js';
+import type { Mutable } from '../utils/mutable.js';
 import { getLeaves } from './get-leaves.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
 import { isTerminating } from '../cp-node/fs/is-terminating.js';
 import { DualSetFs } from '../utils/dual-set.js';
-
-const { isOnSameCircle } = CpNodeFs;
+import { isOnSameCircle } from '../cp-node/fs/is-on-same-circle.js';
 
 
 /**
@@ -51,7 +50,7 @@ function cull(
     while (leaves.length) {
         const leaf = leaves.pop()!;
 
-        const { center: c } = leaf.cp.circle;
+        const { center: c } = leaf.pointOnShape.circle;
         if (!DualSetFs.has(culls, c[0], c[1]) ||
             // Preserve topology.
             leaf.isIntersection) {
@@ -64,7 +63,7 @@ function cull(
         while (!cut) {
             cpNode = cpNode.next;
 
-            const { center: c } = cpNode.cp.circle;
+            const { center: c } = cpNode.pointOnShape.circle;
             if (!DualSetFs.has(culls, c[0], c[1])) {
                 // Cut off the edge once a non-cull has been reached.
                 while (isTerminating(cpNode.prevOnCircle)) {
@@ -85,12 +84,12 @@ function cull(
         }
 
         if (cut) {
-            const cp1 = cpNode.prevOnCircle;
+            const cp1 = cpNode.prevOnCircle as Mutable<CpNode>;
             cp1.next = cpNode;
-            cpNode.prev = cp1;
+            (cpNode as Mutable<CpNode>).prev = cp1;
 
             cp1.nextOnCircle = cpNode;
-            cpNode.prevOnCircle = cp1;
+            (cpNode as Mutable<CpNode>).prevOnCircle = cp1;
         }
     }
 }

package/src/sat/get-leaves.ts

@@ -1,8 +1,6 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { CpNodeFs } from '../cp-node/cp-node-fs.js';
+import type { CpNode } from '../cp-node/cp-node.js';
 import { isFullyTerminating } from '../cp-node/fs/is-fully-terminating.js';
-
-const { getAllOnLoop } = CpNodeFs;
+import { getAllOnLoop } from '../cp-node/fs/get-all-on-loop.js';
 
 
 /** @internal */

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

@@ -1,9 +1,10 @@
+import type { DualSet } from "../utils/dual-set.js";
+import type { CpNode } from "../cp-node/cp-node.js";
 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";
+import { DualSetFs } from "../utils/dual-set.js";
 
 
 function getSatCulls(
@@ -20,19 +21,19 @@ function getSatCulls(
 
     traverseEdges(cpNode, function(cpNode) {
         /** The occulating radius stored with this vertex. */
-        const R = rMap.get(cpNode) || (s*cpNode.cp.circle.radius);
+        const R = rMap.get(cpNode) || (s*cpNode.pointOnShape.circle.radius);
 
         const cpNode_ = cpNode.next;
 
         const l = length([0,1], getMatCurveToNext(cpNode));
 
-        const r = cpNode_.cp.circle.radius;
+        const r = cpNode_.pointOnShape.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;
+                    const { center: c } = cpNode_.pointOnShape.circle;
                     DualSetFs.add(culls, c[0], c[1]);
                 }
             }

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

@@ -1,10 +1,9 @@
 /** @internal */
 declare const _debug_: Debug;
-
-import { Debug } from '../debug/debug.js';
-import { Mat } from '../mat/mat.js';
+import type { Debug } from '../debug/debug.js';
+import type { Mat } from '../mat/mat.js';
 import { getLargestVertex } from '../mat/get-largest-vertex.js';
-import { createNewCpTree } from '../mat/create-new-cp-tree.js';
+import { createNewCpTrees } from '../mat/create-new-cp-trees.js';
 import { cull } from './cull.js';
 import { addDebugInfo } from './add-debug-info.js';
 import { clone } from '../cp-node/fs/clone.js';
@@ -42,7 +41,7 @@ function toScaleAxis(
         cpNode: cpNode,
         meta: {
             ...mat.meta,
-            cpTrees: createNewCpTree(cpNode)
+            cpTrees: createNewCpTrees(cpNode)
         }
     };
 

package/src/svg/get-loop-bounds.ts

@@ -1,108 +1,83 @@
 import type { Curve, Loop } from 'flo-boolean';
-import type { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import { memoize } from 'flo-memoize';
 import { getBounds } from 'flo-bezier3';
-import { createPos } from '../point-on-shape/create-pos.js';
+import { toP } from '../point-on-shape/to-p.js';
 
 
-/** @internal */
-const INF = Number.POSITIVE_INFINITY;
+type Extreme = {
+    curve: Curve;
+    t: number;
+    val: number;
+};
+
+
+function toPrePoint(extreme: Extreme): PrePointOnShape {
+    return {
+        curve: extreme.curve,
+        t: extreme.t,
+        isSource: true,
+        p: toP(extreme.curve.ps, extreme.t)
+    };
+}
+
+
+function updateExtreme(
+        extreme: Extreme,
+        curve: Curve,
+        t: number,
+        val: number,
+        isMax: boolean): void {
+
+    if (
+        (isMax && (val > extreme.val || (val === extreme.val && t > extreme.t))) ||
+        (!isMax && (val < extreme.val || (val === extreme.val && t > extreme.t)))
+    ) {
+        extreme.curve = curve;
+        extreme.t = t;
+        extreme.val = val;
+    }
+}
 
 
 /** 
  * @internal 
  */
-const getLoopBounds = memoize(function(loop: Loop): {
-        minX: PointOnShape;
-        minY: PointOnShape;
-        maxX: PointOnShape;
-        maxY: PointOnShape } {
-
-    const extremes: { 
-        bezier: Curve, 
-        t: number, 
-        val: number 
-    }[][] = [
-        [
-            { bezier: undefined!, t: undefined!, val: INF}, 
-            { bezier: undefined!, t: undefined!, val: INF}
-        ], 
-        [
-            { bezier: undefined!, t: undefined!, val: -INF}, 
-            { bezier: undefined!, t: undefined!, val: -INF}
-        ]
+const getLoopBounds$ = memoize(function(
+        loop: Loop): {
+        minX: PrePointOnShape;
+        minY: PrePointOnShape;
+        maxX: PrePointOnShape;
+        maxY: PrePointOnShape } {
+
+    const mins: Extreme[] = [
+        { curve: undefined!, t: undefined!, val: Infinity },
+        { curve: undefined!, t: undefined!, val: Infinity }
+    ];
+
+    const maxs: Extreme[] = [
+        { curve: undefined!, t: undefined!, val: -Infinity },
+        { curve: undefined!, t: undefined!, val: -Infinity }
     ];
-    
-    loop.curves.forEach(function(curve: Curve): void {            
+
+
+    loop.curves.forEach(function(curve: Curve): void {
         const ps = curve.ps; 
-        // const bounds = getBounds_(ps);
         const bounds = getBounds(ps);
-        
-        
-        {    
-            {
-                const v = bounds.box[0][0];
-                const x = extremes[0][0].val;
-                if (v < x || (v === x && bounds.ts[0][0] > extremes[0][0].t)) { 
-                    extremes[0][0] = { 
-                        bezier : curve, 
-                        t      : bounds.ts[0][0],
-                        val    : v
-                    };
-                }
-            }
-
-            {
-                const v = bounds.box[0][1];
-                const x = extremes[0][1].val;
-                if (v < x || (v === x && bounds.ts[0][1] > extremes[0][1].t)) { 
-                    extremes[0][1] = { 
-                        bezier : curve, 
-                        t      : bounds.ts[0][1],
-                        val    : v
-                    };
-                }
-            }
-        }
 
-        {    
-            {
-                const v = bounds.box[1][0];
-                const x = extremes[1][0].val;
-                if (v > x || (v === x && bounds.ts[1][0] > extremes[1][0].t)) { 
-                    extremes[1][0] = { 
-                        bezier : curve, 
-                        t      : bounds.ts[1][0],
-                        val    : v
-                    };
-                }
-            }
-
-            {
-                const v = bounds.box[1][1];
-                const x = extremes[1][1].val;
-                if (v > x || (v === x && bounds.ts[1][1] > extremes[1][1].t)) { 
-                    extremes[1][1] = { 
-                        bezier : curve, 
-                        t      : bounds.ts[1][1],
-                        val    : v
-                    };
-                }
-            }
+        for (let axis = 0; axis < 2; axis++) {
+            updateExtreme(mins[axis], curve, bounds.ts[0][axis], bounds.box[0][axis], false);
+            updateExtreme(maxs[axis], curve, bounds.ts[1][axis], bounds.box[1][axis], true);
         }
     });
 
     return {
-        // minX : new PointOnShape(extremes[0][0].bezier, extremes[0][0].t),
-        // minY : new PointOnShape(extremes[0][1].bezier, extremes[0][1].t),
-        // maxX : new PointOnShape(extremes[1][0].bezier, extremes[1][0].t),
-        // maxY : new PointOnShape(extremes[1][1].bezier, extremes[1][1].t)
-        minY : createPos(extremes[0][1].bezier, extremes[0][1].t, true),
-        minX : createPos(extremes[0][0].bezier, extremes[0][0].t, true),
-        maxX : createPos(extremes[1][0].bezier, extremes[1][0].t, true),
-        maxY : createPos(extremes[1][1].bezier, extremes[1][1].t, true)
+        minX: toPrePoint(mins[0]),
+        minY: toPrePoint(mins[1]),
+        maxX: toPrePoint(maxs[0]),
+        maxY: toPrePoint(maxs[1])
     };
 });
 
 
-export { getLoopBounds }
+export { getLoopBounds$ }

package/src/svg/get-min-y-pos.ts

@@ -1,6 +1,5 @@
-/** @internal */
-import { Loop } from 'flo-boolean';
-import { getLoopBounds } from './get-loop-bounds.js';
+import type { Loop } from 'flo-boolean';
+import { getLoopBounds$ } from './get-loop-bounds.js';
 
 
 /**
@@ -8,7 +7,7 @@ import { getLoopBounds } from './get-loop-bounds.js';
  * Get topmost PointOnShape of the given loop.
  */
 function getMinYPos(loop: Loop) {
-    return getLoopBounds(loop).minY;
+    return getLoopBounds$(loop).minY;
 }
 
 

package/src/svg/get-shape-bounds.ts

@@ -1,23 +1,23 @@
+import type { Loop } from 'flo-boolean';
+import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import { memoize } from 'flo-memoize';
-import { Loop } from 'flo-boolean';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { getLoopBounds } from './get-loop-bounds.js';
+import { getLoopBounds$ } from './get-loop-bounds.js';
 
 
 /** @internal */
 const getShapeBounds = memoize(function(loops: Loop[]) {
-    let minX_ = Number.POSITIVE_INFINITY;
-    let maxX_ = Number.NEGATIVE_INFINITY;
-    let minY_ = Number.POSITIVE_INFINITY;
-    let maxY_ = Number.NEGATIVE_INFINITY;
+    let minX_ = +Infinity;
+    let maxX_ = -Infinity;
+    let minY_ = +Infinity;
+    let maxY_ = -Infinity;
 
-    let minX: PointOnShape;
-    let maxX: PointOnShape;
-    let minY: PointOnShape;
-    let maxY: PointOnShape;
+    let minX: PrePointOnShape;
+    let maxX: PrePointOnShape;
+    let minY: PrePointOnShape;
+    let maxY: PrePointOnShape;
 
     for (const loop of loops) {
-        const bounds = getLoopBounds(loop);
+        const bounds = getLoopBounds$(loop);
         if (bounds.minX.p[0] < minX_) {
             minX = bounds.minX;
             minX_ = bounds.minX.p[0];

package/src/sweep-line/are-boxes-intersecting.ts

@@ -1,12 +1,13 @@
 
 /**
- * @internal
  * Returns true if the 2 given (closed) boxes intersect. At this stage we already
  * know their x-axis intersect.
  * @param a A rectangular box
  * @param a Another rectangular box
  * @param closed (defaults to true) Interpret boxes as being closed (i.e. they
  * contain their border) or open.
+ * 
+ * @internal
  */
 function areBoxesIntersecting(closed: boolean) {
     return (a: number[][], b: number[][]): boolean => {
@@ -28,7 +29,7 @@ function areBoxesIntersecting(closed: boolean) {
             : (
                 ax0 < bx1 && ax1 > bx0 && 
                 by0 < ay1 && by1 > ay0
-            )
+            );
     }
 }
 

package/src/utils/mutable.ts

@@ -0,0 +1,7 @@
+
+type Mutable<T> = {
+    -readonly [K in keyof T]: T[K]
+}
+
+
+export type { Mutable }

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

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