flo-mat 4.1.5 → 5.0.2

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

@@ -1,105 +1,83 @@
-import { beziersToSvgPathStr, simplifyPaths } from 'flo-boolean';
-import { getLoopsMetrics } from '../loop/get-max-coordinate.js';
-import { Mat } from '../mat/mat.js';
-import { simplifyMat } from '../mat/simplify-mat.js';
-import { toScaleAxis } from '../sat/to-scale-axis.js';
-import { clipOptions } from './clip-options.js';
-import { findMat  } from './find-mat.js';
-import { defaultMatOptions, MatOptions } from './mat-options.js';
-
-
-const { ceil, log2 } = Math;
-
-
-/**
- * Finds and returns the Medial Axis Transforms (MATs) from the given array of 
- * bezier loops representing shape boundaries.
- * 
- * @param bezierLoops An array of (possibly intersecting) loops with each loop 
- * representing one or more piecewise smooth closed curves (i.e. shapes). Each 
- * loop consists of an array of beziers represented by an array of control 
- * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic 
- * beziers respectively. Each point is a two-element array (ordered pair), the
- * first of which is the x-coordinate and the second the y-coordinate.
- * 
- * @param maxCurviness The maximum value the 'curviness' of a curve can have 
- * before an additional MAT point is inserted in between. Defaults to 0.4. 
- * (Curviness is measured as the total angle in radians between the consecutive 
- * vectors formed by the ordered control points of th bezier curve). The value
- * is clipped in the range `[0.01,3]`.
- * 
- * @param maxLength The maximum length a curve can have before an additional MAT 
- * point is inserted. This value is scaled to a reference 1024 x 1024 
- * grid (e.g. if the shape fits in a 512 x 512 axis-aligned box the value will be 
- * halved, e.g. from 10 to 5). Together with maxCurviness it represents a 
- * tolerance for the accuracy of the MAT. Defaults to 4. The value is clipped 
- * in [1,100].
- */
-function findMats(
-        bezierLoops: number[][][][],
-        options?: MatOptions): Mat[] {
-
-    // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
-    const { maxCoordinate } = getLoopsMetrics(bezierLoops);
-    const maxCoordPowerOf2 = ceil(log2(maxCoordinate));
-
-    const options_: Required<MatOptions> = clipOptions(
-        maxCoordPowerOf2, {
-        ...defaultMatOptions,
-        ...(options || {})
-    });
-
-    const {
-        applySat, simplify,
-        satScale, simplifyTolerance
-    } = options_;
-
-
-    const loopss = simplifyPaths(bezierLoops, {
-        forceOrientationNegative: true,
-    });
-
-    // console.log(loopsToSvgPathStr(bezierLoops));
-
-    const mats: Mat[] = [];
-    for (const loops of loopss) {
-        let mat = findMat(loops, maxCoordPowerOf2, options_);
-        if (mat === undefined) { continue; }
-
-        if (applySat) {
-            mat = toScaleAxis(mat, satScale);
-        }
-
-        if (simplify) {
-            mat = simplifyMat(mat, simplifyTolerance, 50)
-        }
-
-        mats.push(mat);
-    }
-    
-    // console.log(structuredClone(circumCenter.getStats()));
-    // circumCenter.resetStats();
-
-    return mats;
-}
-
-
-
-/**
- * Returns an SVG path string representation of the given bezier loops.
- * @param loops An array of loops having an array of bezier curves each given as 
- * an array of control points.
- */
-function loopsToSvgPathStr(
-        loops: number[][][][]) {
-
-    let str = '';
-    for (const loop of loops) {
-        str = str + beziersToSvgPathStr(loop) + '\n';
-    }
-
-    return str;
-}
-
-
-export { findMats }
+import { simplifyPaths } from 'flo-boolean';
+import { getLoopsMetrics } from '../loop/get-max-coordinate.js';
+import { Mat } from '../mat/mat.js';
+import { simplifyMat } from '../mat/simplify-mat.js';
+import { toScaleAxis } from '../sat/to-scale-axis.js';
+import { clipOptions } from './clip-options.js';
+import { findMat  } from './find-mat.js';
+import { resetDebugElems } from './get-meta.js';
+import { defaultMatOptions, MatOptions } from './mat-options.js';
+
+
+const { ceil, log2 } = Math;
+
+
+/**
+ * Finds and returns the Medial Axis Transforms (MATs) from the given array of 
+ * bezier loops representing shape boundaries.
+ * 
+ * @param bezierLoops An array of (possibly intersecting) loops with each loop 
+ * representing one or more piecewise smooth closed curves (i.e. shapes). Each 
+ * loop consists of an array of beziers represented by an array of control 
+ * points with 2,3 or 4 elements corresponding to linear, quadratic and cubic 
+ * beziers respectively. Each point is a two-element array (ordered pair), the
+ * first of which is the x-coordinate and the second the y-coordinate.
+ *
+ * @param options the `MatOptions` (see there for a description of each option
+ * and its default), e.g. `maxCurviness` and `maxLength` together determine the
+ * accuracy of the MAT, `simplify` and `simplifyTolerance` control the
+ * simplification of the result and `applySat` and `satScale` whether and how
+ * the Scale Axis Transform is applied. Missing options take their defaults
+ * (`defaultMatOptions`) and all values are clipped to their allowed ranges.
+ */
+function findMats(
+        bezierLoops: number[][][][],
+        options?: MatOptions): Mat[] {
+
+    // if (typeof _debug_ !== 'undefined') { var timingStart = performance.now(); }
+    resetDebugElems();
+    const { maxCoordinate } = getLoopsMetrics(bezierLoops);
+    const maxCoordPowerOf2 = ceil(log2(maxCoordinate));
+
+    const options_: Required<MatOptions> = clipOptions(
+        maxCoordPowerOf2, {
+        ...defaultMatOptions,
+        ...(options || {})
+    });
+
+    const {
+        applySat, simplify,
+        satScale, simplifyTolerance
+    } = options_;
+
+
+    const loopss = simplifyPaths(bezierLoops, {
+        forceOrientationNegative: true,
+    });
+
+
+    const mats: Mat[] = [];
+    for (const loops of loopss) {
+        let mat = findMat(loops, maxCoordPowerOf2, options_);
+        if (mat === undefined) { continue; }
+
+        if (applySat) {
+            mat = toScaleAxis(mat, satScale);
+        }
+
+        if (simplify) {
+            mat = simplifyMat(mat, simplifyTolerance)
+        }
+
+        mats.push(mat);
+    }
+    
+    // console.log(structuredClone(circumCenter.getStats()));
+    // circumCenter.resetStats();
+
+    return mats;
+}
+
+
+
+export { findMats }

package/src/find-mat/get-dull-corners-on-loop.ts

@@ -1,7 +1,7 @@
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { Loop } from 'flo-boolean';
 import { controlPointLinesLength } from 'flo-bezier3';
-import { getCorner } from '../corner/get-corner.js';
+import { getCorner$ } from '../corner/get-corner.js';
 
 
 /** @internal */
@@ -20,7 +20,7 @@ function getDullCornersOnLoop(
 
             const { next, ps } = curve;
 
-            if (getCorner(ps, next.ps).isQuiteDull) {
+            if (getCorner$(ps, next.ps).isQuiteDull) {
                 const p = ps[ps.length - 1];
                 const pDd = [[0,p[0]], [0,p[1]]];
 

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

@@ -1,9 +1,28 @@
 import type { Loop } from 'flo-boolean';
 import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import { getCurvatureExtremaDd, controlPointLinesLength } from 'flo-bezier3';
+import { distanceBetween } from 'flo-vector2d';
 import { toP } from '../point-on-shape/to-p.js';
 
 
+/** 
+ * @internal
+ * Curvature maxima closer than this (in parameter space) to a curve endpoint
+ * are ignored - they are handled by the corner logic.
+ */
+const EDGE_T_TOLERANCE = 2**-20;
+/** 
+ * @internal
+ * Curvature maxima closer than this fraction of the curve's control polygon
+ * length to a curve endpoint are ignored. A curve with (near) coincident
+ * control points at an end has (near) zero speed there and its curvature
+ * blows up towards that end; the resulting "maximum" (that can be well 
+ * inside the parameter tolerance above) is an artifact and not a feature of
+ * the shape.
+ */
+const EDGE_DISTANCE_TOLERANCE = 2**-20;
+
+
 /**
  * Get points of maximum curvature.
  * 
@@ -19,24 +38,37 @@ function getFor1ProngsOnLoop(
 
         for (let i=0; i<loop.curves.length; i++) {
             const curve = loop.curves[i];
+            const { ps } = curve;
 
-            if (controlPointLinesLength(curve.ps) < minBezLength) {
+            const len = controlPointLinesLength(ps);
+            if (len < minBezLength) {
                 continue;
             }
 
-            const { ps } = curve;
+            const pS = ps[0];
+            const pE = ps[ps.length-1];
+            const edgeDistanceTolerance = len * EDGE_DISTANCE_TOLERANCE;
+
+            for (const t of getCurvatureExtremaDd(ps).maxima) {
+                // keep away from edges (in parameter space)
+                if (t < EDGE_T_TOLERANCE || t > 1 - EDGE_T_TOLERANCE) {
+                    continue;
+                }
 
-            poss.push(...getCurvatureExtremaDd(ps).maxima.map(t => {
                 const pDd = toP(ps, t);
                 const p = pDd.map(c => c[0] + c[1]);
 
-                return { curve, t, isSource: true, p, pDd }
-            }));
+                // keep away from edges (in distance)
+                if (distanceBetween(p, pS) < edgeDistanceTolerance || 
+                    distanceBetween(p, pE) < edgeDistanceTolerance) {
+                    continue;
+                }
+
+                poss.push({ curve, t, isSource: true, p, pDd });
+            }
         }
 
-        return poss
-            // keep away from edges
-            .filter(pos => pos.t > 2**-20 && pos.t < 2**-20);
+        return poss;
     }
 }
 

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

@@ -1,10 +1,9 @@
 import type { Debug }   from '../debug/debug.js';
 import type { Loop } from 'flo-boolean';
-import type { Curve } from 'flo-boolean';
-import type { MatMeta } from '../mat/mat-meta.js';
-import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
-import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
+import { getBoundingHull } from 'flo-bezier3';
+import { getBoundingBox$, getBoundingBoxTight$ } from '../geometry/get-bounding-box-.js';
 import { getCorner } from '../corner/get-corner.js';
+import { createEmptyElems } from '../debug/debug.js';
 
 
 /** @internal */
@@ -14,38 +13,41 @@ declare const _debug_: Debug;
 let timingStart: number;
 
 
-/** @internal */
-function getPartialMeta(
-        loops: Loop[]): Omit<
-            MatMeta,
-            | 'cpTrees'
-            // | 'pointToCpNode'
-            | 'loops'
-            | 'maxCoordPowerOf2'
-            | 'squaredDiagonalLength'
-            | 'lastInsertId'
-        > {
-
-    const looseBoundingBoxes: number[][][] = [];
-    const tightBoundingBoxes: number[][][] = [];
-    const boundingHulls: number[][][] = [];
-    const sharpCorners: Curve[] = [];
-    const dullCorners: Curve[] = [];
+/**
+ * @internal
+ * Resets the generated debug `_debug_.elems` (if debug is enabled) so that
+ * they only reflect the current `findMats` call.
+ */
+function resetDebugElems() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    _debug_.elems = { ..._debug_.elems, ...createEmptyElems() };
+}
+
+
+/**
+ * @internal
+ * Adds (if debug is enabled) the loose and tight bounding boxes, the bounding
+ * hulls and the sharp and dull corners of the given loops' curves to
+ * `_debug_.elems` for later inspection by consumers.
+ */
+function addDebugElems(loops: Loop[]) {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    const { 
+        looseBoundingBoxes, tightBoundingBoxes, boundingHulls,
+        sharpCorners, dullCorners
+    } = _debug_.elems;
 
     for (const loop of loops) {
         for (const curve of loop.curves) {
             const ps = curve.ps;
-            const hull = getBoundingHull(ps, true)!;
-
-            boundingHulls.push(hull);
 
-            const looseBoundingBox = getBoundingBox$(ps);
-            looseBoundingBoxes.push(looseBoundingBox);
+            boundingHulls.push(getBoundingHull(ps, true)!);
+            looseBoundingBoxes.push(getBoundingBox$(ps));
+            tightBoundingBoxes.push(getBoundingBoxTight$(ps));
 
-            const tightBoundingBox = getBoundingBoxTight(ps);
-            tightBoundingBoxes.push(tightBoundingBox);
-
-            const corner = getCorner(curve.ps, curve.next.ps);
+            const corner = getCorner(ps, curve.next.ps);
             if (corner.isQuiteSharp) {
                 sharpCorners.push(curve);
             } else if (corner.isQuiteDull) {
@@ -53,14 +55,6 @@ function getPartialMeta(
             }
         }
     }
-
-    return {
-        looseBoundingBoxes,
-        tightBoundingBoxes,
-        boundingHulls,
-        sharpCorners,
-        dullCorners
-    }
 }
 
 
@@ -102,7 +96,8 @@ function addDebugInfo4() {
 
 
 export {
-    getPartialMeta,
+    resetDebugElems,
+    addDebugElems,
     addDebugInfo1,
     addDebugInfo2,
     addDebugInfo3,

package/src/find-mat/get-sharp-corners.ts

@@ -2,7 +2,7 @@ import type { PrePointOnShape } from '../point-on-shape/point-on-shape.js';
 import type { Loop } from 'flo-boolean';
 import { controlPointLinesLength } from 'flo-bezier3';
 import { toP } from '../point-on-shape/to-p.js';
-import { getCorner } from '../corner/get-corner.js';
+import { getCorner$ } from '../corner/get-corner.js';
 
 
 /** @internal */
@@ -19,7 +19,7 @@ function getSharpCornersOnLoop(
                 continue;
             }
             
-            if (getCorner(curve.ps, curve.next.ps).isQuiteSharp) {
+            if (getCorner$(curve.ps, curve.next.ps).isQuiteSharp) {
                 const { ps } = curve;
 
                 const p = ps[ps.length - 1];

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

@@ -59,7 +59,7 @@ interface MatOptions {
      * 
      * * Only applies if `simplify` is `true`
      * * Defaults to `1/16`
-     * * The value is clipped in `[2**-10,1024]`
+     * * The value is clipped in `[2**-20,2**20]`
      * * scaled to a 1024x1024 vector image size, i.e. a value of `1` on such
      * a vector image will have a `1` pixel accuracy. If the vector is, say,
      * 512x400 then the accuracy is scaled to `1/2` a pixel. This ensures
@@ -72,7 +72,7 @@ interface MatOptions {
      * 
      * * it is not recommended to change this value
      * * scaled to a 1024x1024 vector image size
-     * * Defaults to `1/16`
+     * * Defaults to `1/64`
      */
     readonly minBezLength?: number;
 

package/src/floyd-warshall/get-graph.ts

@@ -1,59 +1,66 @@
 import type { CpNode } from "../cp-node/cp-node.js";
-import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+import type { Circle } from "../geometry/circle.js";
 import { getMatDistanceToNext$ } from "../cp-node/fs/get-distance-to-next.js";
-import { isOnSameCircle } from "../cp-node/fs/is-on-same-circle.js";
 import { isVertexSpecial } from "../cp-node/fs/is-vertex-special.js";
-import { getHoleCloserPairs } from "./get-hole-closer-pairs.js";
 
 
+/**
+ * Returns the adjacency matrix (MAT edge lengths, `Infinity` if not adjacent)
+ * of the given special vertices (leaves, 3-prongs, ...) seen as the vertices of
+ * a graph with the MAT branches between them as edges.
+ *
+ * * for each vertex every MAT edge leaving it is walked once, up to the next
+ *   special vertex; if that vertex is one of the given ones the walked length
+ *   is its distance (the minimum over all such walks if there are several)
+ *
+ * @param specialVertices the special `CpNode`s (one per vertex)
+ */
 function getGraph(
-        specialVertices: CpNode[],
-        holeClosers: CpNode[]) {
-
-    const pairs = getHoleCloserPairs(holeClosers);
+        specialVertices: CpNode[]) {
 
     const V = specialVertices.length;
 
+    // the column of each given vertex, identified by its circle (all `CpNode`s
+    // on a vertex share the same `Circle` object)
+    const columnOf = new Map<Circle, number>(
+        specialVertices.map((cpNode, j) => [cpNode.pointOnShape.circle, j])
+    );
+
     const graph: number[][] = [];
     for (let i=0; i<V; i++) {
         const cpNodeA = specialVertices[i];
 
-        const row: number[] = [];
-        for (let j=0; j<V; j++) {
-            const cpNodeB = specialVertices[j];
-            if (i === j) {
-                row.push(0);
-                continue;
-            }
-
-            let minD = Infinity;
-            for (const toChild of getAllOnCircle(cpNodeA)) {
-                let d = getMatDistanceToNext$(toChild);
-                let child = toChild.next;
-                while (true) {
-                    if (isOnSameCircle(child, cpNodeB)) {
-                        break;  // Found path from A to B
-                    }
-                    if (child.isHoleClosing) {
-                        // Hole closer found - don't go around loop 
-                        child = getHoleCloserNext(pairs, child);
-                        continue;
-                    }
-                    if (isVertexSpecial(child)) {
-                        // we only find the immediate next special ones
-                        d = Infinity;
-                        break;  // Next special vertex found but it's not B
-                    }
-
-                    d += getMatDistanceToNext$(child);
-                    child = child.next;
+        const row: number[] = new Array(V).fill(Infinity);
+        row[i] = 0;
+
+        // walk each edge leaving the vertex up to the next special vertex
+        let toChild = cpNodeA;
+        do {
+            let d = getMatDistanceToNext$(toChild);
+            let child = toChild.next;
+            while (true) {
+                const j = columnOf.get(child.pointOnShape.circle);
+                if (j !== undefined) {
+                    // Found a path from A to one of the given vertices
+                    if (j !== i && d < row[j]) { row[j] = d; }
+                    break;
+                }
+                if (child.isHoleClosing) {
+                    // Hole closer found - skip it (don't go around loop)
+                    child = child.holeCloserTwin!.next;
+                    continue;
+                }
+                if (isVertexSpecial(child)) {
+                    // we only find the immediate next special ones
+                    break;  // Next special vertex found but it's not a given one
                 }
 
-                if (d < minD) { minD = d; }
+                d += getMatDistanceToNext$(child);
+                child = child.next;
             }
 
-            row.push(minD);
-        }
+            toChild = toChild.nextOnCircle;
+        } while (toChild !== cpNodeA);
 
         graph.push(row);
     }
@@ -62,12 +69,4 @@ function getGraph(
 }
 
 
-function getHoleCloserNext(
-        pairs: Map<CpNode,CpNode>,
-        holeCloser: CpNode) {
-
-    return pairs.get(holeCloser)!.next;
-}
-
-
 export { getGraph }

package/src/geometry/get-bounding-box-.ts

@@ -1,8 +1,11 @@
-import { getBoundingBox } from "flo-bezier3";
+import { getBoundingBox, getBoundingBoxTight } from "flo-bezier3";
 import { memoize } from "flo-memoize";
 
 
+/** The (loose, axis-aligned) bounding box of a bezier curve - memoized on its control points. */
 const getBoundingBox$ = memoize(getBoundingBox);
+/** The tight (rotated) bounding box of a bezier curve - memoized on its control points. */
+const getBoundingBoxTight$ = memoize(getBoundingBoxTight);
 
 
-export { getBoundingBox$ }
+export { getBoundingBox$, getBoundingBoxTight$ }

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

@@ -1,7 +1,7 @@
-import { squaredDistanceBetween } from 'flo-vector2d';
-
-
 /**
+ * Returns the closest squared distance from the point `p` to the given 
+ * axis-aligned box `[[minX, minY], [maxX, maxY]]`, i.e. `0` if `p` is inside.
+ * 
  * @internal
  */
 function getClosestSquareDistanceToRect(
@@ -18,17 +18,17 @@ function getClosestSquareDistanceToRect(
 
     if (xp < x0) {
         if (yp < y0) {
-            return squaredDistanceBetween(box[0], p);
+            return (x0 - xp)**2 + (y0 - yp)**2;
         } else if (yp > y1) {
-            return squaredDistanceBetween([x0,y1], p);
+            return (x0 - xp)**2 + (yp - y1)**2;
         } else {
             return (x0 - xp)**2;
         }
     } else if (xp > x1) {
         if (yp < y0) {
-            return squaredDistanceBetween([x1,y0], p);
+            return (xp - x1)**2 + (y0 - yp)**2;
         } else if (yp > y1) {
-            return squaredDistanceBetween(box[1], p);
+            return (xp - x1)**2 + (yp - y1)**2;
         } else {
             return (xp - x1)**2;
         }

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

@@ -4,26 +4,28 @@ const { min } = Math;
 
 
 /**
+ * Returns the closest squared distance from the point `p` to the given
+ * (rotated) rectangle given by its 4 corners in order, i.e. `0` if `p` is
+ * inside the rectangle.
+ *
  * @internal
  */
 function getClosestSquaredDistanceToRotatedRect(ps: number[][], p: number[]) {
-    const ds = [0,1,2,3]
-    .map(i => squaredDistanceBetweenPointAndLineSegment(
-            p, 
-            [ps[i], ps[(i + 1) % 4]]
-        )
-    );
-    
+    const d0 = squaredDistanceBetweenPointAndLineSegment(p, [ps[0], ps[1]]);
+    const d1 = squaredDistanceBetweenPointAndLineSegment(p, [ps[1], ps[2]]);
+    const d2 = squaredDistanceBetweenPointAndLineSegment(p, [ps[2], ps[3]]);
+    const d3 = squaredDistanceBetweenPointAndLineSegment(p, [ps[3], ps[0]]);
+
     const width  = squaredDistanceBetween(ps[0], ps[1]);
     const height = squaredDistanceBetween(ps[0], ps[3]);
 
-    if (ds[0] <= height && ds[2] <= height && 
-        ds[1] <= width  && ds[3] <= width) {
+    if (d0 <= height && d2 <= height &&
+        d1 <= width  && d3 <= width) {
 
         return 0; // Inside rotated rect
     }
 
-    return min(...ds);
+    return min(d0, d1, d2, d3);
 }
 
 

package/src/get-medial-points/double-double/dd-get-medial-point-coeffs-bez3.ts

@@ -1,7 +1,6 @@
 import { toPowerBasisDd } from 'flo-bezier3';
-import { twoDiff, ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddMultBy2, ddDiffDouble } from 'double-double';
+import { ddMultDouble2, ddAddDd, ddMultDd, ddNegativeOf, ddMultByNeg2, ddMultBy2, ddDiffDouble } from 'double-double';
 
-const td = twoDiff;
 const qmd = ddMultDouble2;
 const qaq = ddAddDd;
 const qmq = ddMultDd;