flo-mat 3.0.15 → 4.0.2

package/src/dbscan/dbscan.ts

@@ -1,91 +0,0 @@
-
-/**
- * DBSCAN Clustering Algorithm
- * 
- * @param DB 
- * @param distFunc 
- * @param eps 
- * @param minPts 
- */
-function DBSCAN<T>(
-        DB: T[],
-        distFunc: (a: T, b: T) => number,
-        eps: number,
-        minPts: number) {
-
-    const labelMap = new Map<T,number>();
-    let C = 0;                                                  /* Cluster counter */
-    for (const P of DB) {
-        if (labelMap.has(P)) { continue; }                      /* Previously processed in inner loop */
-
-        const N = RangeQuery(DB, distFunc, P, eps);             /* Find neighbors */
-        if (N.size < minPts) {                                  /* Density check */
-            labelMap.set(P,-1);                                 /* Label as Noise */
-            continue;
-        }
-
-        C++;                                                    /* next cluster label */
-        labelMap.set(P,C);                                      /* Label initial point */
-        const S: Set<T> = new Set(N); S.delete(P);              /* Neighbors to expand */
-        const Ss = Array.from(S);
-
-        for (let i=0; i<Ss.length; i++) {                       /* Process every seed point Q */
-            const Q = Ss[i];
-            if (labelMap.get(Q) === -1) { labelMap.set(Q,C); }  /* Change Noise to border point */
-            if (labelMap.get(Q) !== undefined) { continue; }    /* Previously processed (e.g., border point) */
-            labelMap.set(Q,C);                                  /* Label neighbor */
-            const N = RangeQuery(DB, distFunc, Q, eps);         /* Find neighbors */
-            if (N.size >= minPts) {                             /* Density check (if Q is a core point) */
-                Ss.push(...N);                                  /* Add new neighbors to seed set */
-            }
-        }
-    }
-
-    return labelMap;
-}
-
-
-function RangeQuery<T>(
-        DB: T[],
-        distFunc: (a: T, b: T) => number,
-        Q: T,
-        eps: number) {
-
-    let N = new Set<T>();
-    for (const P of DB) {              /* Scan all points in the database */
-        if (distFunc(Q, P) <= eps) {   /* Compute distance and check epsilon */
-            N.add(P);                  /* Add to result */
-        }
-    }
-
-    return N;
-}
-
-
-export { DBSCAN }
-
-
-// function makeMore(p: number[]) {
-//     const ps: number[][] = [];
-//     for (let i=0; i<5; i++) {
-//         const [x,y] = p;
-//         ps.push([
-//             x + 5*(Math.random() - 0.5),
-//             y + 5*(Math.random() - 0.5),
-//         ]);
-//     }
-
-//     return ps;
-// }
-// const ps = [
-//     [10,10],[10,30],[20,50],[10,40],[70,50],[30,30]
-// ]
-// .flatMap(makeMore);
-// function d(a: number[], b: number[]) {
-//     const x = a[0] - b[0];
-//     const y = a[1] - b[1];
-
-//     return Math.sqrt(x**2 + y**2);
-// }
-// DBSCAN(ps, d, 5, 3);
-

package/src/debug/cp-node-for-debugging.ts

@@ -1,15 +0,0 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { Generated } from './debug.js';
-
-
-/**
- * @internal
- * Used for debugging only. 
- */
-interface ICpNodeForDebugging {
-    generated: Generated,
-    cpNode: CpNode
-}
-
-
-export { ICpNodeForDebugging }

package/src/debug/functions/draw-elem/draw-speed.ts

@@ -1,35 +0,0 @@
-import { normal } from 'flo-bezier3';
-import { drawFs } from 'flo-draw';
-import { toLength, translate } from 'flo-vector2d';
-import { CpNode } from '../../../cp-node/cp-node.js';
-import { getSmoothedSpeed$ } from '../../../cp-node/fs/get-smoothed-speed.js';
-
-
-/** @internal */
-function drawSpeed(
-        g: SVGGElement,
-        cpNode: CpNode,
-        classes_?: string,
-        delay = 0,
-        scaleFactor = 1) {    
-
-    const $elems: SVGElement[] = [];
-
-    const s = getSmoothedSpeed$(0)(cpNode);
-
-    if (s === undefined) { return []; }
-
-    const pos = cpNode.cp.pointOnShape;
-    const { p, t } = pos;
-    const ps = pos.curve.ps;
-
-    const ss = s*scaleFactor/8;
-
-    const n = toLength(normal(ps,t), ss);
-    $elems.push(...drawFs.line(g, [p,translate(p,n)], 'red thin5', delay));
-    
-    return $elems;
-}
-
-
-export { drawSpeed }

package/src/debug/three-prong-for-debugging.ts

@@ -1,58 +0,0 @@
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { posToHumanString } from '../point-on-shape/pos-to-human-string.js';
-import { Circle } from '../geometry/circle.js';
-import { Generated } from './debug.js';
-
-
-/**
- * @internal
- * Used for debugging only. A three-prong is a maximally inscribed circle that
- * touches the shape boundary (tangentially) at 3 points.
- */
-interface ThreeProngForDebugging {
-    generated  : Generated;
-    /** The best fit circle found for the 3-prong. */
-    circle     : Circle;
-    /** The best fit 3 points found for the 3-prong. */
-    poss       : PointOnShape[];
-    /** The 3 boundary pieces on which the three prong points were found. */
-    cp3ss      : CpNode[][];
-    /** The boundary pieces that were used to search the three prong on. */
-    cpss       : CpNode[][];                 
-    bestIndx   : number; 
-    /** An array of 3-prongs, each of which may be a best fit 3-prong. */
-    candidateThreeProngs : { 
-        circle: Circle; 
-        ps: PointOnShape[]; 
-    }[];
-    visitedCps : CpNode[];
-    boundaries : number[][][][];
-    traces     : number[][][];
-}
-
-
-function createEmptyThreeProngForDebugging(): ThreeProngForDebugging {
-    return {
-        generated  : undefined!,
-        circle     : undefined!,
-        poss       : undefined!,
-        cp3ss      : undefined!,
-        cpss       : undefined!,
-        bestIndx   : undefined!,
-        candidateThreeProngs : undefined!,
-        visitedCps : undefined!,
-        boundaries : undefined!,
-        traces     : undefined!,
-    }
-}
-
-function cpsSimple(threeProngForDebugging: ThreeProngForDebugging) {
-    return threeProngForDebugging.cpss.map(δ =>
-        [posToHumanString( δ[0].cp.pointOnShape ),
-         posToHumanString( δ[1].cp.pointOnShape )] 
-    );
-}
-
-
-export { ThreeProngForDebugging, createEmptyThreeProngForDebugging }

package/src/debug/two-prong-for-debugging.ts

@@ -1,30 +0,0 @@
-// import { CpNode } from '../cp-node/cp-node.js';
-// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-// import { Circle } from '../geometry/circle.js';
-// import { CurvePiece } from '../mat/bezier-piece.js';
-// import { Generated } from './debug.js';
-
-
-// /** @internal */
-// interface TwoProngForDebugging {
-//     generated: Generated;
-//     bezierPieces: CurvePiece[];
-//     pos: PointOnShape;
-//     δ: CpNode[]; 
-//     z: number[];
-//     circle: Circle; 
-//     xs: { 
-//         x: number[]; 
-//         y: PointOnShape; 
-//         z: PointOnShape; 
-//         t: number; 
-//     }[]; 
-//     failed: boolean; 
-//     holeClosing: boolean;
-//     notAdded: boolean;
-//     deleted: boolean;
-//     cpNode: CpNode;
-// }
-
-
-// export { TwoProngForDebugging }

package/src/dijkstra/dijkstra.ts

@@ -1,418 +0,0 @@
-// Modified by Floris
-/******************************************************************************
- * Created 2008-08-19.
- *
- * Dijkstra path-finding functions. Adapted from the Dijkstar Python project.
- *
- * Copyright (C) 2008
- *   Wyatt Baldwin <self@wyattbaldwin.com>
- *   All rights reserved
- *
- * Licensed under the MIT license.
- *
- *   http://www.opensource.org/licenses/mit-license.php
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- *****************************************************************************/
-
-// import { Heap } from "../heap/heap";
-/**
- * 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; }
-}
-
-
-interface NodeWithWeight<T> {
-    v: T;
-    w: number;
-}
-
-
-function compareNodeWithWeight<T>(
-        a: NodeWithWeight<T>,
-        b: NodeWithWeight<T>) {
-
-    return a.w - b.w;
-}
-
-
-type OGraph = { [index:string]: { [index:string]: number } };
-
-
-// function getOChildren(
-//         graph: OGraph) {
-
-//     return (
-
-//     )
-// }
-
-
-function singleSourceShortestPaths(
-        graph: OGraph,
-        s: string,
-        d?: string) {
-
-    // Predecessor map for each node that has been encountered.
-    // node ID => predecessor node ID
-    const predecessors: { [index:string]: string } = {};
-
-    // Costs of shortest paths from s to all nodes encountered.
-    // node ID => cost
-    const costs: { [index:string]: number } = {};
-    costs[s] = 0;
-
-    // Costs of shortest paths from s to all nodes encountered; differs from
-    // `costs` in that it provides easy access to the node that currently has
-    // the known shortest path from s.
-    // XXX: Do we actually need both `costs` and `open`?
-    const open = new Heap<NodeWithWeight<string>>(compareNodeWithWeight);
-    open.insert({ v: s, w: 0 });
-
-
-    while (!open.isEmpty()) {
-        // In the nodes remaining in graph that have a known cost from s,
-        // find the node, u, that currently has the shortest path from s.
-        const closest = open.popMax();
-        const u = closest.v;
-        const costOf_s_to_u = closest.w;
-
-        // Get nodes adjacent to u...
-        const adjacentNodes = graph[u] || {};
-
-        // ...and explore the edges that connect u to those nodes, updating
-        // the cost of the shortest paths to any or all of those nodes as
-        // necessary. v is the node across the current edge from u.
-        for (const v in adjacentNodes) {
-            if (adjacentNodes.hasOwnProperty(v)) {
-                // Get the cost of the edge running from u to v.
-                const costOf_e = adjacentNodes[v];
-
-                // Cost of s to u plus the cost of u to v across e--this is *a*
-                // cost from s to v that may or may not be less than the current
-                // known cost to v.
-                const costOf_s_to_u_PLUS_costOf_e = costOf_s_to_u + costOf_e;
-
-                // If we haven't visited v yet OR if the current known cost from s to
-                // v is greater than the new cost we just found (cost of s to u plus
-                // cost of u to v across e), update v's cost in the cost list and
-                // update v's predecessor in the predecessor list (it's now u).
-                const costOf_s_to_v = costs[v];
-                const firstVisit = (costs[v] === undefined);
-                if (firstVisit || costOf_s_to_v > costOf_s_to_u_PLUS_costOf_e) {
-                    costs[v] = costOf_s_to_u_PLUS_costOf_e;
-                    open.insert({ v, w: costOf_s_to_u_PLUS_costOf_e });
-                    predecessors[v] = u;
-                }
-            }
-        }
-    }
-
-    if (d !== undefined && costs[d] === undefined) {
-        const msg = ['Could not find a path from ', s, ' to ', d, '.'].join('');
-        throw new Error(msg);
-    }
-
-    return predecessors;
-}
-
-
-function extractShortestPathFromPredecessorList(
-        predecessors: { [index:string]: string },
-        d: string) {
-
-    const nodes = [];
-    let u = d;
-    while (u) {
-        nodes.push(u);
-        u = predecessors[u];
-    }
-    nodes.reverse();//?
-
-    return nodes;
-}
-
-
-/**
- * Finds any shortest path.
- * 
- * @param graph 
- * @param s 
- * @param d 
- */
-function findShortestPath(
-        graph: { [index:string]: { [index:string]: number } },
-        s: string,
-        d: string) {
-
-    const predecessors = singleSourceShortestPaths(graph, s, d);//?
-
-    return extractShortestPathFromPredecessorList(
-        predecessors, d
-    );
-}
-
-
-function findPathLength<T>(
-        graph: { [index:string]: { [index:string]: number } },
-        path: string[]) {
-
-    if (path.length === 0) { return 0; }
-
-    let d = 0;
-    let prevNode = path[0];
-    for (let i=1; i<path.length; i++) {
-        const S = prevNode;
-        const E = path[i];
-
-        d += S === E ? 0 : graph[S][E];
-
-        prevNode = E;
-    }
-
-    return d;
-}
-
-
-///////////////////////////
-// TESTING
-///////////////////////////
-
-function areStrArrsEql(
-        a: string[],
-        b: string[]) {
-
-    if (a.length !== b.length) { return false; }
-
-    for (let i=0; i<a.length; i++) {
-        if (a[i] !== b[i]) { return false; }
-    }
-
-    return true;
-}
-
-
-function areStrObjsEql(
-        a: { [index:string]: string },
-        b: { [index:string]: string }) {
-
-    const aKeys = Object.keys(a);
-    const bKeys = Object.keys(b);
-    if (!areStrArrsEql(aKeys, bKeys)) { return false; }
-
-    for (let i=0; i<aKeys.length; i++) {
-        const key = aKeys[i];
-        if (a[key] !== b[key]) { return false; }
-    }
-
-    return true;
-}
-
-
-{
-    // should find the path between two points, all edges have weight 1
-    const graph = {
-        a: {b: 10, d: 1},
-        b: {a: 1, c: 1, e: 1},
-        c: {b: 1, f: 1},
-        d: {a: 1, e: 1, g: 1},
-        e: {b: 1, d: 1, f: 1, h: 1},
-        f: {c: 1, e: 1, i: 1},
-        g: {d: 1, h: 1},
-        h: {e: 1, g: 1, i: 1},
-        i: {f: 1, h: 1}
-    };
-
-    findPathLength(graph, ['a', 'b', 'a', 'd', 'e', 'e', 'f', 'i']);//?
-    findPathLength(graph, ['a', 'd', 'e', 'f', 'i']);//?
-    findPathLength(graph, ['a', 'd', 'g', 'h', 'i']);//?
-    const path = findShortestPath(graph, 'a', 'i');//?
-    if (!(
-        areStrArrsEql(path, ['a', 'd', 'e', 'f', 'i']) ||
-        areStrArrsEql(path, ['a', 'd', 'g', 'h', 'i']))) {
-
-        throw new Error('Error')
-    }
-}
-
-/*
-{
-    // should find the path between two points, weighted edges
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    let path = findShortestPath(graph, 'a', 'c');
-    if (!areStrArrsEql(path, ['a', 'd', 'e', 'f', 'c'])) {
-        throw new Error('Error')
-    }
-    path = findShortestPath(graph, 'd', 'b');
-    if (!areStrArrsEql(path, ['d', 'b'])) {
-        throw new Error('Error')
-    }
-}
-
-
-{
-    // should throw on unreachable destination
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // Exception 
-    let errored = false;
-    try { findShortestPath(graph, 'c', 'a'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-    // Exception 
-    errored = false;
-    try { findShortestPath(graph, 'a', 'g'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-}
-
-
-{
-    // should throw on non-existent destination
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // Exception 
-    let errored = false;
-    try { findShortestPath(graph, 'a', 'z'); } catch (e) { errored = true; }
-    if (!errored) {
-        throw new Error('Error');
-    }
-}
-
-
-{
-    // should find all paths from a node
-    const graph = {
-        a: {b: 10, c: 100, d: 1},
-        b: {c: 10},
-        d: {b: 1, e: 1},
-        e: {f: 1},
-        f: {c: 1},
-        g: {b: 1}
-    };
-
-    // All paths from 'a'
-    const paths = singleSourceShortestPaths(graph, 'a');//?
-    if (!areStrObjsEql(paths, ({ b: 'd', c: 'f', d: 'a', e: 'd', f: 'e' }))) {
-        throw new Error('Error')
-    }
-}
-*/

package/src/find-2-prong/find-and-add-2-prongs-on-all-paths.ts

@@ -1,38 +0,0 @@
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Loop } from 'flo-boolean';
-import { CpNode } from '../cp-node/cp-node.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { findAndAdd2Prongs } from './find-and-add-2-prongs.js';
-import { fixOrdering } from '../find-mat/fix-ordering.js';
-
-
-/** 
- * @internal
- * Add 2 prongs. See comments on the add2Prong function.
- * @param loops
- * @param cpGraphs
- * @param for2Prongss
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */ 
-function findAndAdd2ProngsOnAllPaths(
-        cpNode: CpNode | undefined,
-        loops: Loop[],
-        cpGraphs: Map<Loop,LlRbTree<CpNode>>,
-        for2Prongss: PointOnShape[][],
-        extreme: number,
-        for1Prongs: boolean) {
-
-    for (let k=0; k<for2Prongss.length; k++) {
-        const for2Prongs = for2Prongss[k];
-        const _cpNode = findAndAdd2Prongs(loops, cpGraphs, k, for2Prongs, extreme, for1Prongs);
-        cpNode = cpNode || _cpNode;
-    }
-
-    fixOrdering(cpNode!);
-
-    return cpNode;
-}
-
-
-export { findAndAdd2ProngsOnAllPaths }