flo-mat 3.0.1 → 3.0.2

package/src/find-mat/get-half-angles.ts

@@ -0,0 +1,95 @@
+import { tangent, toPowerBasis_1stDerivative } from "flo-bezier3";
+import { allRoots } from "flo-poly";
+import { CpNode } from "../cp-node/cp-node.js";
+import { createPos } from "../point-on-shape/create-pos.js";
+import { PointOnShape } from "../point-on-shape/point-on-shape.js";
+
+const { atan2, abs, sin, cos } = Math;
+
+
+const MIN_ANGLE = 1/180*Math.PI;
+
+
+function getHalfAngle(
+        cpNodeS: CpNode) {
+
+    const cpNodeE = cpNodeS.next;
+
+    // Get half angle
+    const { curve: curveS, t: tS } = cpNodeS.cp.pointOnShape;
+    const { curve: curveE, t: tE } = cpNodeE.cp.pointOnShape;
+    const { ps: psS } = curveS;
+    const { ps: psE } = curveE;
+
+    if (psS === psE && psS.length < 3) {
+        return createPos(curveS, (tS + tE)/2);
+        // return undefined;
+    }
+
+    const tanS = tangent(psS, tS);
+    const tanE = tangent(psE, tE);
+    const angleS = atan2(tanS[1], tanS[0]);
+    const angleE = atan2(tanE[1], tanE[0]);
+    const angle = angleS + angleE;
+
+    if (abs(angle) <= MIN_ANGLE) {
+        return curveS === curveE
+            ? createPos(curveS, (tS + tE)/2)
+            : tS < 1 - tE  // start closer to endpoint than end?
+            ? createPos(curveS, (1 - tS)/2)
+            : createPos(curveE, tE/2)
+    }
+
+    const halfAngle = angle/2;
+    const x = cos(halfAngle);
+    const y = sin(halfAngle);
+    const q = x/y;
+    /////////
+    
+    {
+        const tE_ = curveS === curveE ? tE : 1;
+        const roots = getHalfAngleRoots(psS, tS, tE_, q);
+        if (roots.length > 0) {
+            return createPos(curveS, roots[0]);
+        }
+    }
+    {
+        const tS_ = curveS === curveE ? tS : 0;
+        const roots = getHalfAngleRoots(psE, tS_, tE, q);
+        if (roots.length > 0) {
+            return createPos(curveE, roots[0]);
+        }
+    }
+
+    return undefined;
+}
+
+
+function getHalfAngleRoots(
+        ps: number[][],
+        tS: number,
+        tE: number,
+        q: number): number[] {
+
+    let roots: number[] = [];
+    if (ps.length === 3) {
+        const pbS = toPowerBasis_1stDerivative(ps);
+        const [[a,b],[c,d]] = pbS;
+        // Solve: (a - cq)t + b - dq = 0
+        roots = [(-b + d*q)/(a - c*q)];
+    } else if (ps.length === 4) {
+        const pbS = toPowerBasis_1stDerivative(ps);
+        const [[a,b,c],[d,e,f]] = pbS;
+        // Solve: (a - dq)t^2 + (b - eq)t + c - fq = 0
+        const ts = [a - d*q, b - e*q, c - f*q];;
+        roots = allRoots(ts)
+    }
+    
+    return roots.filter(r =>
+        r > tS &&
+        r < tE
+    );
+}
+
+
+export { getHalfAngle }

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

@@ -0,0 +1,115 @@
+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';
+
+
+/** @internal */
+declare const _debug_: Debug; 
+
+
+let timingStart: number;
+
+
+/** @internal */
+function getMeta(
+        maxCoordinate: number,
+        squaredDiagonalLength: number,
+        loops: Loop[],
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): MatMeta {
+
+    timingStart = performance.now();
+
+    const pointToCpNode: TriMap<Loop,number,number,CpNode> = new Map();
+
+    const looseBoundingBoxes: number[][][] = [];
+    const tightBoundingBoxes: number[][][] = [];
+    const boundingHulls: number[][][] = [];
+    const sharpCorners: Curve[] = [];
+    const dullCorners: Curve[] = [];
+
+    for (const loop of loops) {
+        // Populate `posMap`
+        const cpTree = cpTrees.get(loop)!;
+        const cpNodes = cpTree.toArrayInOrder();
+        for (const cpNode of cpNodes) {
+            const { p, t } = cpNode.cp.pointOnShape;
+            TriMapFs.set(pointToCpNode,loop,p[0],p[1],cpNode);
+        }
+
+        for (let curve of loop.curves) {
+            const ps = curve.ps;
+            const hull = getBoundingHull(ps, true)!;
+
+            boundingHulls.push(hull);
+
+            const looseBoundingBox = getBoundingBox$(ps);
+            looseBoundingBoxes.push(looseBoundingBox);
+
+            const tightBoundingBox = getBoundingBoxTight(ps);
+            tightBoundingBoxes.push(tightBoundingBox);
+
+            const corner = getCorner(curve.ps, curve.next.ps);
+            if (corner.isQuiteSharp) {
+                sharpCorners.push(curve);
+            } else if (corner.isQuiteDull) {
+                dullCorners.push(curve);
+            }
+        }
+    }
+
+    return {
+        maxCoordinate,
+        squaredDiagonalLength,
+        looseBoundingBoxes,
+        tightBoundingBoxes,
+        boundingHulls,
+        sharpCorners,
+        dullCorners,
+        loops,
+        cpTrees,
+        pointToCpNode
+    }
+}
+
+
+/** @internal */
+function addDebugInfo2() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    const timing = _debug_.generated.timing;
+    const now = performance.now();
+    timing.holeClosers += now - timingStart;
+    timingStart = now;
+}
+
+
+function addDebugInfo3() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    const generated = _debug_.generated;
+    const timing = generated.timing;
+    const now = performance.now();
+
+    timing.oneAnd2Prongs += now - timingStart;
+    timingStart = now;
+}
+
+
+function addDebugInfo4() {
+    if (typeof _debug_ === 'undefined') { return; }
+
+    const generated = _debug_.generated;
+    const timing = generated.timing;
+
+    timing.threeProngs += performance.now() - timingStart;
+}
+
+
+export { getMeta, addDebugInfo2, addDebugInfo3, addDebugInfo4 }

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

@@ -1,8 +1,8 @@
 import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { Loop } from 'flo-boolean';
 import { createPos } from '../point-on-shape/create-pos.js';
-import { getCornerAtEnd } from '../curve/curve.js';
 import { controlPointLinesLength } from 'flo-bezier3';
+import { getCorner } from '../corner/get-corner.js';
 
 
 /** @internal */
@@ -19,11 +19,12 @@ function getSharpCornersOnLoop(
                 continue;
             }
             
-            if (getCornerAtEnd(curve).isQuiteSharp) {
+            if (getCorner(curve.ps, curve.next.ps).isQuiteSharp) {
                 sharpCorners.push(createPos(curve, 1, true));
             }
         }
 
+        // console.log(sharpCorners)
         return sharpCorners;
     }
 }

package/src/find-mat/get-total-by.ts

@@ -1,20 +1,20 @@
-import { Curve } from '../curve/curve.js';
-import { Loop } from 'flo-boolean';
+import type { Loop } from 'flo-boolean';
+import type { Curve } from '../curve/curve.js';
 
 
 /**
  * @internal
  * Helper function.
  * @internal
- * @param f
+ * @param totalByF
  */
-function getTotalBy(f: (curve: Curve) => number) {
+function getTotalBy(totalByF: (curve: Curve) => number) {
 	
 	return function(loop: Loop) {
 		let node = loop.curves[0];
 		let total = 0;
 		do {
-			total += f(node);
+			total += totalByF(node);
 			
 			node = node.next;
 		} while (node !== loop.curves[0]);

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

@@ -0,0 +1,140 @@
+
+interface MatOptions {
+    /** 
+     * The maximum value the 'curviness' of a curve can have 
+     * before an additional MAT point is inserted in between.
+     * (Curviness is measured as the total angle in radians between the consecutive 
+     * vectors formed by the ordered control points of th bezier curve).
+     * 
+     * * Defaults to `0.05`.
+     * * The value is clipped in the range `[0.01,3]`.
+     */
+    maxCurviness?: number;
+
+    /**
+     * 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 `40`.
+     * * The value is clipped in `[1,1024]`.
+     */
+    maxLength?: number;
+
+    /**
+     * If `true` then `toScaleAxis` will be applied to the MAT (and before
+     * inserting phatoms) that could dramatically simplify the MAT skeleton.
+     * 
+     * * Defaults to `true`
+     */
+    applySat?: boolean;
+
+    /**
+     * The higher this value, the more aggresively the
+     * Scale Axis is applied.
+     * 
+     * * Only applies if `applySat` is `true`
+     * * Defaults to 2
+     * * The value is clipped in `[1,Number.POSITIVE_INFINITY]`
+     * * Should be larger than one to have an effect
+     */
+    satScale?: number;
+
+    /**
+     * If `true` then the `simplyfiMats` will be applied which will replace
+     * multiple MAT curves with a single one to within a specified tolerance 
+     * determined by the Hausdorff distance between curves and can dramatically
+     * reduce the number of MAT curves and 2-prongs.
+     * 
+     * * Defaults to `true`
+     */
+    simplify?: boolean;
+
+    /**
+     * The tolerance, given as the Hausdorff distance between curves, to
+     * determine the accuracy of the simplification. The higher this value the
+     * more simplification will be applied but the less accurate the result.
+     * 
+     * * Only applies if `simplify` is `true`
+     * * Defaults to `1/16`
+     * * The value is clipped in `[2**-10,1024]`
+     * * 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
+     * scale invariance on the accuracy.
+     */
+    simplifyTolerance?: number;
+
+    /**
+     * Minimum bezier length before no `CpNode` will attach to it.
+     * 
+     * * it is not recommended to change this value
+     * * scaled to a 1024x1024 vector image size
+     * * Defaults to `1/16`
+     */
+    minBezLength?: number;
+
+    /**
+     * Angle (in degrees) increments around sharp obtuse corners. The lower the
+     * angle, the better the accuracy.
+     * 
+     * * Defaults to `15`
+     */
+    angleIncrement?: number;
+
+    /**
+     * If `true` then 2-prongs will be inserted apatively according to the
+     * error between the MAT implied boundary curve and the actual curve
+     */
+    // adaptiveTolerance?: boolean;
+}
+
+
+const defaultMatOptions: Required<MatOptions> = {
+    maxCurviness: 0.05,
+    maxLength: 40,
+    applySat: true,
+    satScale: 2,
+    simplify: true,
+    simplifyTolerance: 2**-4,
+    minBezLength: 2**-6,
+    angleIncrement: 15
+    // adaptiveTolerance: true,
+}
+
+
+type MatOptionMeta = {
+    range: [number,number],
+    scaleByMaxCoordinate?: boolean | undefined,
+    scaleByMaxRadius?: boolean | undefined
+}
+
+
+const matOptionRanges: Partial<{ [K in keyof MatOptions]: MatOptionMeta }> = {
+    maxCurviness: {
+        range: [0.01,3]
+    },
+    maxLength: {
+        range: [1,1024],
+        scaleByMaxRadius: true
+    },
+    angleIncrement: {
+        range: [0.1, 360]
+    },
+    satScale: {
+        range: [1, Number.POSITIVE_INFINITY],
+    },
+    simplifyTolerance: {
+        range: [2**-10,1024],
+        scaleByMaxCoordinate: true
+    },
+    minBezLength: {
+        range: [2**-20,2],
+        scaleByMaxCoordinate: true
+    }
+}
+
+
+export { MatOptions, MatOptionMeta, defaultMatOptions, matOptionRanges }

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

@@ -0,0 +1,89 @@
+// A JavaScript program for Floyd Warshall All Pairs Shortest Path algorithm.
+// From https://www.geeksforgeeks.org/floyd-warshall-algorithm-dp-16/
+// This code is contributed by rdtaank.
+
+
+/**
+ * Returns a matrix of all distances between all nodes (O(n**3))
+ *
+ * @param graph 
+ */
+function floydWarshall(graph: number[][]) {
+    const V = graph.length;
+    const dist: number[][] = Array.from(
+        Array(V),
+        () => new Array(V).fill(0)
+    );
+
+
+    // Initialize the solution matrix same as input graph matrix Or we can
+    // say the initial values of shortest distances are based on shortest
+    // paths considering no intermediate vertex
+    for (let i=0; i<V; i++) {
+        for (let j=0; j<V; j++) {
+            dist[i][j] = graph[i][j];
+        }
+    }
+
+
+    // Add all vertices one by one to the set of intermediate vertices.
+    // ---> Before start of a iteration, we have shortest distances
+    // between all pairs of vertices such that the shortest distances
+    // consider only the vertices in set {0, 1, 2, .. k-1} as
+    // intermediate vertices.
+    // ---> After the end of a iteration, vertex no. k is added to the set
+    // of intermediate vertices and the set becomes {0, 1, 2, .. k}
+
+
+    for (let k=0; k<V; k++) {
+        // Pick all vertices as source one by one
+        for (let i=0; i<V; i++) {
+            // Pick all vertices as destination for the above picked source
+            for (let j=0; j<V; j++) {
+                // If vertex k is on the shortest path from i to j, then update
+                // the value of dist[i][j]
+                if (dist[i][k] + dist[k][j] < dist[i][j]) {
+                    dist[i][j] = dist[i][k] + dist[k][j];
+                }
+            }
+        }
+    }
+
+    return dist;
+}
+
+
+export { floydWarshall }
+
+
+// floydWarshall(graph)
+
+// TESTING
+
+// Let us create the following weighted graph
+//
+//           10
+//    (0)--------->(3)
+//     |           /|\
+//   5 |            |
+//     |            | 1
+//    \|/           |
+//    (1)--------->(2)
+//           3
+
+
+// const INF = Number.POSITIVE_INFINITY;
+// const graph = [
+//     [0, 5, INF, 10],
+//     [INF, 0, 3, INF],
+//     [INF, INF, 0, 1],
+//     [INF, INF, INF, 0],
+// ];
+
+// 0   5   8   9
+// INF 0   3   4
+// INF INF 0   1
+// INF INF INF 0
+
+// floydWarshall(graph);//?
+

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

@@ -0,0 +1,73 @@
+import { CpNode } from "../cp-node/cp-node.js";
+import { getAllOnCircle } from "../cp-node/fs/get-all-on-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";
+
+
+function getGraph(
+        specialVertices: CpNode[],
+        holeClosers: CpNode[]) {
+
+    const pairs = getHoleCloserPairs(holeClosers);
+
+    const V = specialVertices.length;
+
+    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 = Number.POSITIVE_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 = holeCloserNext(pairs, child);
+                        continue;
+                    }
+                    if (isVertexSpecial(child)) {
+                        // we only find the immediate next special ones
+                        d = Number.POSITIVE_INFINITY;
+                        break;  // Next special vertex found but it's not B
+                    }
+
+                    d += getMatDistanceToNext$(child);
+                    child = child.next;
+                }
+
+                if (d < minD) { minD = d; }
+            }
+
+            row.push(minD);
+        }
+
+        graph.push(row);
+    }
+
+    return graph;
+}
+
+
+function holeCloserNext(
+        pairs: Map<CpNode,CpNode>,
+        holeCloser: CpNode) {
+
+    return pairs.get(holeCloser)!.next;
+}
+
+
+export { getGraph }

package/src/floyd-warshall/get-hole-closer-pairs.ts

@@ -0,0 +1,27 @@
+import { CpNode } from "../cp-node/cp-node.js";
+
+
+function getHoleCloserPairs(
+        holeClosers: CpNode[]): Map<CpNode,CpNode> {
+
+    const pairs: Map<CpNode,CpNode> = new Map();
+    for (let hcA of holeClosers) {
+        for (let hcB of holeClosers) {
+            const cA = hcA.cp.circle.center;
+            const cB = hcB.cp.circle.center;
+            const cpA = hcA.cp.pointOnShape.p;
+            const cpB = hcB.cp.pointOnShape.p;
+            if (hcB !== hcA &&
+                cA[0] === cB[0] && cA[1] === cB[1] &&
+                cpA[0] === cpB[0] && cpA[1] === cpB[1]) {
+
+                pairs.set(hcA,hcB);
+            }
+        }
+    }
+
+    return pairs;
+}
+
+
+export { getHoleCloserPairs }

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

@@ -1,7 +1,8 @@
 import { getBoundingBox } from "flo-bezier3";
 import { memoize } from "flo-memoize";
 
-const getBoundingBox_ = memoize(getBoundingBox);
 
+const getBoundingBox$ = memoize(getBoundingBox);
 
-export { getBoundingBox_ }
+
+export { getBoundingBox$ }

package/src/heap/heap.ts

@@ -0,0 +1,96 @@
+
+/**
+ * see [Wikipedia](https://en.wikipedia.org/wiki/Heap_(data_structure))
+ * 
+ * @internal
+ */
+class Heap<T> {
+    public heap: T[] = [];
+
+    constructor(private compare: (a: T, b: T) => number) {}
+
+    public isEmpty() {
+        return this.heap.length === 0;
+    }
+
+    public insert(t: T): void {
+        const heap = this.heap;
+
+        heap.push(t);
+
+        // Swim up
+        let i = heap.length-1;
+        while (true) {
+            const parentIdx = (i - 1 - (i+1)%2)/2;
+            if (parentIdx === -1) { return; }
+
+            const parent = heap[parentIdx];
+            if (this.compare(t, parent) < 0) { 
+                break;
+            }
+            
+            // Swap and update indexes and variables
+            heap[parentIdx] = t;
+            heap[i] = parent;
+            i = parentIdx;
+        }
+    }
+
+
+    public popMax(): T {
+        const heap = this.heap;
+        const maxT = heap[0];
+        heap[0] = heap[heap.length - 1];
+        heap.length--;
+        this.swimDown();
+
+        return maxT;
+    }
+
+
+    private swimDown() {
+        const heap = this.heap;
+
+        const len = heap.length;
+    
+        let i = 0;
+        // Swim down
+        while (true) {
+            const leftIdx = 2*i + 1;
+            if (leftIdx >= len) { 
+                break;  // there's no left or right child
+            }
+            const rightIdx = 2*i + 2;
+
+            const swapIdx = (rightIdx >= len) || (this.compare(heap[leftIdx], heap[rightIdx]) > 0)
+                ? leftIdx
+                : rightIdx;
+
+            const swapChild = heap[swapIdx];
+
+            const parent = heap[i];    
+            if (this.compare(parent, swapChild) > 0) { 
+                break;
+            }
+
+            // Swap and update indexes
+            heap[swapIdx] = parent;
+            heap[i] = swapChild;
+            i = swapIdx;
+        }
+    }
+
+
+    public swapMinOrMax(t: T): void {
+        this.heap[0] = t;
+        this.swimDown();
+    }
+
+    /* ignore coverage */
+    public static getParentIdx(i: number) { return (i - 1 - (i+1)%2)/2; }
+    public static getLeftChild(i: number) { return 2*i + 1; }
+    public static getRightChild(i: number) { return 2*i + 2; }
+}
+
+
+export { Heap }