flo-mat 3.0.13 → 3.0.15

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

@@ -0,0 +1,57 @@
+import type { ContactPoint } from "../../contact-point/contact-point";
+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, cp, isHoleClosing, isIntersection } = cpNode_;
+        const { circle, pointOnShape, order, order2 } = cp;
+        const { curveIdx, loopIdx, p, t, isSource } = pointOnShape;
+
+        const curve = loops[loopIdx].curves[curveIdx];
+
+        const cp_: ContactPoint = {
+            circle,
+            pointOnShape: { curve, p, t, isSource },
+            order, order2
+        };
+
+        return {
+            ...cpNode_,
+            id, isHoleClosing, isIntersection,
+            cp: cp_
+        } 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,71 @@
+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,
+            cp,
+            prev, next, nextOnCircle, prevOnCircle, holeCloserTwin,
+        } = cpNode
+
+        const { pointOnShape, circle, order, order2 } = cp;
+        const { curve, p, t, isSource } = 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
+        };
+
+        cpNodes_.push({
+            id, isHoleClosing, isIntersection,
+            cp: {
+                circle,
+                pointOnShape: posSimplified,
+                order, order2
+            },
+            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/curve/curve.ts

@@ -1,37 +1,35 @@
-import { Loop } from 'flo-boolean';
+// import type { Loop } from 'flo-boolean';
 
 
-/**
- * Represents a bezier curve on the shape boundary / loop.
- */
-interface Curve {
-    /**
-     * The closed loop of bezier curves representing the shape 
-     * boundary this curve belongs to.
-     */
-    loop: Loop;
-    /**
-     * The bezier control points.
-     */
-    ps: number[][];
-    /**
-     * The previous curve (when going in a negative direction around
-     * the shape boundary, i.e. clockwise for the outer shape and anti-clockwise
-     * for the holes (if any))
-     */
-    prev: Curve; 
-    /**
-     * The next curve (when going in a positive direction around
-     * the shape boundary, i.e. anti-clockwise for the outer shape and clockwise
-     * for the holes (if any))
-     */
-    next: Curve;
-    /**
-     * The curve's ordered index in the loop. This imposes a cycling
-     * ordering of the curves in the loop
-     */
-    idx: number;
-}
+// /**
+//  * Represents a bezier curve on the shape boundary / loop.
+//  */
+// interface Curve {
+//     /**
+//      * The curve's ordered index in the loop. This imposes a cycling
+//      * ordering of the curves in the loop
+//      */
+//     readonly idx: number;
+//     /** The bezier control points. */
+//     readonly ps: number[][];
+//     /**
+//      * The closed loop of bezier curves representing the shape 
+//      * boundary this curve belongs to.
+//      */
+//     readonly loop: Loop;
+//     /**
+//      * The previous curve (when going in a negative direction around
+//      * the shape boundary, i.e. clockwise for the outer shape and anti-clockwise
+//      * for the holes (if any))
+//      */
+//     readonly prev: Curve; 
+//     /**
+//      * The next curve (when going in a positive direction around
+//      * the shape boundary, i.e. anti-clockwise for the outer shape and clockwise
+//      * for the holes (if any))
+//      */
+//     readonly next: Curve;
+// }
 
 
-export { Curve }
+// export { Curve }

package/src/debug/functions/draw-elem/draw-dull-corner.ts

@@ -1,5 +1,5 @@
+import type { Curve } from 'flo-boolean';
 import { drawFs } from 'flo-draw';
-import { Curve } from '../../../curve/curve.js';
 
 
 /** @internal */
@@ -11,7 +11,7 @@ function dullCorner(
         scaleFactor = 1) {
 
     const ps = curve.ps; 
-    const p = curve.ps[ps.length-1];
+    const p = ps[ps.length-1];
     const $pos = drawFs.dot(g, p, 0.1*0.5*scaleFactor, classes, delay);
     
     return $pos;

package/src/debug/functions/draw-elem/draw-sharp-corner.ts

@@ -1,5 +1,5 @@
+import type { Curve } from 'flo-boolean';
 import { drawFs } from 'flo-draw';
-import { Curve } from '../../../curve/curve.js';
 
 
 /** @internal */
@@ -10,9 +10,10 @@ function sharpCorner(
         delay = 0,
         scaleFactor = 1) {
 
-    const p = curve.ps[curve.ps.length-1];
+    const { ps } = curve;
+    const p = ps[ps.length-1];
     const $pos = drawFs.dot(g, p, 0.6*scaleFactor, 'green', delay);
-        
+
     return $pos;
 }
 

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

@@ -52,10 +52,16 @@ function findMats(
     } = options_;
 
 
-    const loopss = simplifyPaths(bezierLoops);
+    const loopss = simplifyPaths(bezierLoops, undefined, { forceOrientationNegative: true });
+
     // console.log(loopsToSvgPathStr(bezierLoops));
+    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1)/1))))));
+    // console.log(loopsToSvgPathStr(loopss[1].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1)/1))))));
+    // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1000)/1000))))));
+    // console.log(loopsToSvgPathStr(loopss[1].map(loop => loop.beziers.map(ps => ps.map(p => p.map(c => Math.round(c*1000)/1000))))));
+    // console.log(loopss.map(loops => loops.map(loop => loop.beziers)));
+    // console.log(loopss.map(loops => loopsToSvgPathStr(loops.map(loop => loop.beziers))));
     // const loopss = [bezierLoops.map(loop => loopFromBeziers(loop,0))];
-    // console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => v.map(v => v*2**4))))));
     // console.log(loopsToSvgPathStr(bezierLoops.map(v => v.map(v => v.map(v => [-v[0],v[1]])))));
     // console.log(loopsToSvgPathStr(loopss[0].map(loop => loop.beziers)));
 

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

@@ -1,12 +1,13 @@
+import type { Debug }   from '../debug/debug.js';
+import type { Loop } from 'flo-boolean';
+import type { Curve } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { TriMap } from '../utils/tri-map.js';
+import type { MatMeta } from '../mat/mat-meta.js';
+import { TriMapFs } from '../utils/tri-map.js';
 import { getBoundingHull, getBoundingBoxTight } from 'flo-bezier3';
-import { Debug }   from '../debug/debug.js';
-import { Loop } from 'flo-boolean';
-import { Curve } from '../curve/curve.js';
 import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { CpNode } from '../cp-node/cp-node.js';
-import { TriMap, TriMapFs } from '../utils/tri-map.js';
-import { MatMeta } from '../mat/mat-meta.js';
 import { getCorner } from '../corner/get-corner.js';
 
 

package/src/geometry/circle.ts

@@ -5,8 +5,8 @@ import { squaredDistanceBetween } from 'flo-vector2d';
  * Canonical circle representation.
  */
 interface Circle {
-    center: number[];
-    radius: number;
+    readonly center: number[];
+    readonly radius: number;
 }
 
 
@@ -29,7 +29,7 @@ function engulfsCircle(c1: Circle, c2: Circle) {
     if (c1.radius <= c2.radius) { 
         return false; 
     }
-    
+
     const d = squaredDistanceBetween(c1.center, c2.center);
     const dr = c1.radius - c2.radius; 
     const δ = dr*dr;
@@ -38,12 +38,5 @@ function engulfsCircle(c1: Circle, c2: Circle) {
 }
 
 
-/**
- * Returns a human-readable string description of the given circle.
- * @param circle
- */
-function toString(circle: Circle): string {
-    return 'c: ' + circle.center + ' r: ' + circle.radius;
-}
-
-export { Circle, scaleCircle, engulfsCircle }
+export type { Circle }
+export { scaleCircle, engulfsCircle }

package/src/index.ts

@@ -1,10 +1,8 @@
-
+export type { Curve, Loop } from 'flo-boolean';
 export { loopFromBeziers, beziersToSvgPathStr, getPathsFromStr } from 'flo-boolean';
 
 export type { MatMeta } from './mat/mat-meta.js';
-export type { Loop } from 'flo-boolean';    
 export type { Mat } from './mat/mat.js';
-export type { Curve } from './curve/curve.js';
 export type { CpNode  } from './cp-node/cp-node.js';
 export type { PointOnShape } from './point-on-shape/point-on-shape.js';
 export type { Circle } from './geometry/circle.js';
@@ -87,4 +85,5 @@ export { getHoleClosers } from './cp-node/fs/get-hole-closers.js';
 export { getSpeed } from './cp-node/fs/get-speed.js';
 export { getSmoothedSpeed$ } from './cp-node/fs/get-smoothed-speed.js';
 export { getInitialDegAngleBetweenMatCurves } from './cp-node/fs/get-angle-between-mat-curves.js';
-export { getAllVertices } from './cp-node/fs/get-all-vertices.js';
+export { getAllVertices } from './cp-node/fs/get-all-vertices.js';
+export { isTrivial } from './cp-node/fs/is-trivial.js';

package/src/mat/curve-piece.ts

@@ -1,4 +1,4 @@
-import { Curve } from '../curve/curve.js';
+import type { Curve } from 'flo-boolean';
 
 
 /**
@@ -7,9 +7,9 @@ import { Curve } from '../curve/curve.js';
  */
 interface CurvePiece {
     /** A bezier curve within the shape boundary. */
-    curve: Curve;
+    readonly curve: Curve;
     /** The start and end t parameter values of the bezier curve. */
-    ts: number[];
+    readonly ts: number[];
 }
 
 

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

@@ -1,6 +1,6 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { Curve } from '../curve/curve.js';
-import { CurvePiece } from './curve-piece.js';
+import type { Curve } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { CurvePiece } from './curve-piece.js';
 import { isPosQuiteSharpCorner } from '../point-on-shape/is-pos-quite-sharp-corner.js';
 import { compareCps } from '../contact-point/contact-point.js';
 

package/src/mat/mat-meta.ts

@@ -1,8 +1,8 @@
+import type { Loop } from 'flo-boolean';
+import type { CpNode } from '../cp-node/cp-node.js';
+import type { Curve } from 'flo-boolean';
+import type { TriMap } from '../utils/tri-map.js';
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { Curve } from '../curve/curve.js';
-import { TriMap } from '../utils/tri-map.js';
 
 
 interface MatMeta {

package/src/mat/simplify-mat-map-only.ts

@@ -1,110 +1,110 @@
-import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
-import { CpNode, isTerminating } from '../cp-node/cp-node.js';
-import { getBranches } from './get-branches.js';
-import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
-import { getCurveBetween } from '../get-curve/get-curve-between.js';
-
-
-/**
- * Simplifies the given MAT by replacing the piecewise quad beziers composing 
- * the MAT with fewer ones to within a given tolerance. Returns the map of
- * to be deleted nodes only - does not actually delete them. Use simplifyMat
- * instead if you want to delete the nodes.
- * @param cpNode A representation of the MAT
- * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
- * direction vectors at the interface between curves. A tolerance of zero means
- * perfect smoothness is required - defaults to 15.
- * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
- * defaults to 0.1
- * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
- * Distance - defaults to 1
- */
-function simplifyMatMapOnly(
-        cpNode: CpNode,
-        anlgeTolerance = 15,
-        hausdorffTolerance = 1e-1,
-        hausdorffSpacing = 1e0) {
-
-    const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
-
-    // Start from a leaf
-    while (!isTerminating(cpNode)) {
-        cpNode = cpNode.next;
-    }
-
-    const branches = getBranches(cpNode, anlgeTolerance);
-
-    const canDeletes: CpNode[] = [];
-    for (let k=0; k<branches.length; k++) {
-        const branch = branches[k];
-
-        // Try to remove some
-        let j = 0;
-        while (j < branch.length) {
-            const i = j;
-            while (true) {
-                j++;
-
-                if (j === branch.length) { break; }
-
-                const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
-
-                if (hd > hausdorffTolerance) {
-                    break;
-                } else {
-                    canDeletes.push(branch[j]);
-                }
-            }
-
-            if (i + 1 === j) { 
-                // no simplification occured
-            } else {
-                const branStart = branch[i];
-                const branEnd = branch[j-1];
-
-                const medial = toCubic(getCurveBetween(branStart, branEnd.next));
-                const rev = medial.slice().reverse();
-                let curCpNode = branStart;
-                let prevT = 0;
-                while (curCpNode !== branEnd) {
-                    const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
-                    simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
-                    const oppositeCpNode = curCpNode.nextOnCircle.prev;
-                    simpleMap.set(oppositeCpNode, { ps: rev, ts: [1-t, 1-prevT] });
-
-                    prevT = t;
-                    curCpNode = curCpNode.next;
-                }
-                simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
-
-                const oppositeCpNode = curCpNode.nextOnCircle.prev;
-                simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1-prevT] });
-            }
-        }
-    }
-
-    return { simpleMap, cpNode };
-}
-
-
-function getTotalHausdorffDistance(
-        i: number, 
-        j: number, 
-        branch: CpNode[],
-        hausdorffSpacing: number) {
-
-    const hds: number[] = [];
-    const longCurve = getCurveBetween(branch[i], branch[j].next);
-    for (let m=i; m<j+1; m++) {
-        hds.push(hausdorffDistance(
-            getCurveToNext(branch[m]), 
-            longCurve,
-            hausdorffSpacing
-        ));
-    }
-
-    return Math.max(...hds);
-}
-
-
-export { simplifyMatMapOnly }
+// import { closestPointOnBezier, hausdorffDistance, toCubic } from 'flo-bezier3';
+// import { CpNode, isTerminating } from '../cp-node/cp-node.js';
+// import { getBranches } from './get-branches.js';
+// import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
+// import { getCurveBetween } from '../get-curve/get-curve-between.js';
+
+
+// /**
+//  * Simplifies the given MAT by replacing the piecewise quad beziers composing 
+//  * the MAT with fewer ones to within a given tolerance. Returns the map of
+//  * to be deleted nodes only - does not actually delete them. Use simplifyMat
+//  * instead if you want to delete the nodes.
+//  * @param cpNode A representation of the MAT
+//  * @param anlgeTolerance Tolerance given as the degrees difference of the unit 
+//  * direction vectors at the interface between curves. A tolerance of zero means
+//  * perfect smoothness is required - defaults to 15.
+//  * @param hausdorffTolerance The approximate maximum Hausdorff Distance tolerance -
+//  * defaults to 0.1
+//  * @param hausdorffSpacing The spacing on the curves used to calculate the Hausdorff
+//  * Distance - defaults to 1
+//  */
+// function simplifyMatMapOnly(
+//         cpNode: CpNode,
+//         anlgeTolerance = 15,
+//         hausdorffTolerance = 1e-1,
+//         hausdorffSpacing = 1e0) {
+
+//     const simpleMap: Map<CpNode, { ps: number[][], ts: number[] }> = new Map();
+
+//     // Start from a leaf
+//     while (!isTerminating(cpNode)) {
+//         cpNode = cpNode.next;
+//     }
+
+//     const branches = getBranches(cpNode, anlgeTolerance);
+
+//     const canDeletes: CpNode[] = [];
+//     for (let k=0; k<branches.length; k++) {
+//         const branch = branches[k];
+
+//         // Try to remove some
+//         let j = 0;
+//         while (j < branch.length) {
+//             const i = j;
+//             while (true) {
+//                 j++;
+
+//                 if (j === branch.length) { break; }
+
+//                 const hd = getTotalHausdorffDistance(i, j, branch, hausdorffSpacing);
+
+//                 if (hd > hausdorffTolerance) {
+//                     break;
+//                 } else {
+//                     canDeletes.push(branch[j]);
+//                 }
+//             }
+
+//             if (i + 1 === j) { 
+//                 // no simplification occured
+//             } else {
+//                 const branStart = branch[i];
+//                 const branEnd = branch[j-1];
+
+//                 const medial = toCubic(getCurveBetween(branStart, branEnd.next));
+//                 const rev = medial.slice().reverse();
+//                 let curCpNode = branStart;
+//                 let prevT = 0;
+//                 while (curCpNode !== branEnd) {
+//                     const t = closestPointOnBezier(medial, curCpNode.next.cp.circle.center).t;
+//                     simpleMap.set(curCpNode, { ps: medial, ts: [prevT, t] });
+//                     const oppositeCpNode = curCpNode.nextOnCircle.prev;
+//                     simpleMap.set(oppositeCpNode, { ps: rev, ts: [1-t, 1-prevT] });
+
+//                     prevT = t;
+//                     curCpNode = curCpNode.next;
+//                 }
+//                 simpleMap.set(curCpNode, { ps: medial, ts: [prevT, 1] });
+
+//                 const oppositeCpNode = curCpNode.nextOnCircle.prev;
+//                 simpleMap.set(oppositeCpNode, { ps: rev, ts: [0, 1-prevT] });
+//             }
+//         }
+//     }
+
+//     return { simpleMap, cpNode };
+// }
+
+
+// function getTotalHausdorffDistance(
+//         i: number, 
+//         j: number, 
+//         branch: CpNode[],
+//         hausdorffSpacing: number) {
+
+//     const hds: number[] = [];
+//     const longCurve = getCurveBetween(branch[i], branch[j].next);
+//     for (let m=i; m<j+1; m++) {
+//         hds.push(hausdorffDistance(
+//             getCurveToNext(branch[m]), 
+//             longCurve,
+//             hausdorffSpacing
+//         ));
+//     }
+
+//     return Math.max(...hds);
+// }
+
+
+// export { simplifyMatMapOnly }