flo-mat 2.0.4 → 3.0.0

package/src/mat/find-mat/find-and-add-3-prongs.ts

@@ -1,218 +0,0 @@
-/** @internal */
-declare const _debug_: Debug; 
-
-import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug } from '../../debug/debug.js';
-import { CpNode } from '../../cp-node.js';
-import { Loop } from '../../loop.js';
-import { Circle } from '../../circle.js';
-import { calcPosOrder, isPosSharpCorner } from '../../point-on-shape.js';
-import { find3Prong } from './find-3-prong/find-3-prong.js';
-import { add3Prong  } from '../find-mat/add-3-prong.js';
-
-
-/**
- * @hidden
- * Finds and adds all 3-prongs.
- * @param cpGraphs
- * @param cpStart The CpNode to start traversing from. 
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAddAll3Prongs(
-		cpGraphs : Map<Loop,LlRbTree<CpNode>>,
-		cpStart  : CpNode,
-		extreme  : number) {
-
-	// Don't change this function to be recursive, the call stack may overflow 
-	// if there are too many two-prongs.
-
-	const visitedEdges = new Map<CpNode, Set<CpNode>>();
-
-	const edgesToCheck = [{ fromCpNode: undefined as CpNode, cpStart }];
-
-	while (edgesToCheck.length) {
-		const { fromCpNode, cpStart } = edgesToCheck.shift();
-
-		markEdgeAsTaken(visitedEdges, fromCpNode, cpStart);
-		
-		for (const cpNode of cpStart.getCpNodesOnCircle()) {
-
-			//if (!PointOnShape.isSharpCorner(cpNode.cp.pointOnShape)) {
-			if (!isPosSharpCorner(cpNode.cp.pointOnShape)) {
-				if (findAndAdd3Prongs(cpGraphs, cpNode, extreme) === undefined) {
-					return; // only for debugging purposes
-				}
-			}
-
-			if (hasEdgeBeenTaken(visitedEdges, cpNode, cpNode.next)) {
-				continue; // We already visited this edge
-			}
-
-			edgesToCheck.push({ fromCpNode: cpStart, cpStart: cpNode.next }); 
-		}
-	}
-}
-
-
-/**
- * @hidden
- * Marks the given edge as already taken.
- */
-function markEdgeAsTaken(
-		visitedEdges: Map<CpNode, Set<CpNode>>,
-		cp1: CpNode, 
-		cp2: CpNode) {
-
-	if (cp1 === undefined) { return; }
-
-	f(cp1, cp2);
-	f(cp2, cp1);
-
-	function f(cp1: CpNode, cp2: CpNode) {
-		let visited = visitedEdges.get(cp1);
-		if (!visited) { 
-			visited = new Set<CpNode>();
-			visitedEdges.set(cp1, visited);
-		}  
-		visited.add(cp2);
-	}
-}
-
-
-/** @hidden */
-function hasEdgeBeenTaken(
-		visitedEdges: Map<CpNode, Set<CpNode>>,
-		cp1: CpNode, 
-		cp2: CpNode) {
-
-	let cps: Set<CpNode>;
-
-	cps = visitedEdges.get(cp1);
-	const takenForward   = cps && cps.has(cp2); 
-
-	cps = visitedEdges.get(cp2);
-	const takenBackwards = cps && cps.has(cp1); 
-
-	return takenForward || takenBackwards;
-}
-
-
-/**
- * @hidden
- * Traverses the shape from the given ContactPoint going around contact circles 
- * so that only a piece of the shape is traversed and returns the visited 
- * CpNodes (starting from the given CpNode).
- * @param cpStart The ContactPoint from where to start the traversal.
- */
-function traverseShape(cpStart: CpNode) {
-	let cpNode = cpStart;
-
-	if (cpNode === cpNode.next.prevOnCircle) {
-		return [cpNode];
-	}
-
-	const visitedCps = [];
-	do {
-		visitedCps.push(cpNode);
-	
-		const next = cpNode.next.prevOnCircle;
-		cpNode = cpNode === next
-				? cpNode = cpNode.next.next // Terminal vertex
-				: cpNode = next         // Take last exit
-	
-	} while (cpNode !== cpStart); 
-	
-	return visitedCps;
-}
-
-
-/**
- * @hidden
- * Starting from some ContactPoint, traverses the shape going around Vertices
- * and if more than two Vertices have been visited in total then recursively 
- * adds 3-prongs until only one or two Vertices have been visited. 
- * 
- * This process further subdivides the shape.
- * @param cpGraphs
- * @param cpStart The ContactPoint from where to start the process.
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-let ii = 0;
-function findAndAdd3Prongs(
-		cpGraphs : Map<Loop,LlRbTree<CpNode>>,
-		cpStart  : CpNode,
-		extreme  : number) {
-
-	let visitedCps: CpNode[];
-	
-	do {
-		visitedCps = traverseShape(cpStart);
-	
-		if (visitedCps.length > 2) {
-			findAndAdd3Prong(cpGraphs, visitedCps, extreme);
-			ii++;
-		}
-
-		if (typeof _debug_ !== 'undefined') {
-            if (ii === _debug_.directives.stopAfterThreeProngsNum) {
-                return undefined;
-            }
-        }
-	} while (visitedCps.length > 2);
-
-	return visitedCps;
-}
-
-
-/**
- * @hidden
- * Finds and add a 3-prong MAT circle to the given shape. 
- * @param cpGraphs
- * @param visitedCps
- * @param extreme The maximum coordinate value used to calculate floating point
- * tolerances.
- */
-function findAndAdd3Prong(
-		cpGraphs   : Map<Loop,LlRbTree<CpNode>>,
-		visitedCps : CpNode[],
-		extreme    : number) {
-	
-	const δs = [];
-	for (const visitedCp of visitedCps) {
-		δs.push([visitedCp, visitedCp.next]);
-	}
-	
-	const threeProng = find3Prong(δs, extreme);
-	
-	const orders = [];
-	for (let i=0; i<3; i++) {
-		orders.push(
-			//PointOnShape.calcOrder(threeProng.circle, threeProng.ps[i])
-			calcPosOrder(threeProng.circle, threeProng.ps[i])
-		);
-	}
-	
-	const circle = add3Prong(cpGraphs, orders, threeProng);
-
-	if (typeof _debug_ !== 'undefined') { 
-		add3ProngDebugInfo(circle, visitedCps);
-	}
-}
-
-
-/** @hidden */
-function add3ProngDebugInfo(
-		circle: Circle, 
-		visitedCps: CpNode[]) {
-
-	const threeProngs = _debug_.generated.elems.threeProng;
-	const len = threeProngs.length;
-	const data = threeProngs[len-1];
-	data.visitedCps = visitedCps;
-	data.circle     = circle;
-}
-
-
-export { findAndAddAll3Prongs }

package/src/mat/find-mat/get-potential-2-prongs.ts

@@ -1,24 +0,0 @@
-import { IPointOnShape, isPosQuiteSharpCorner } from '../../point-on-shape.js';
-
-
-/** @hidden */
-function getPotential2Prongs(possPerLoop: IPointOnShape[][]) {
-    const for2ProngsArray = []; 
-    
-    for (const poss of possPerLoop) {
-        const for2Prongs = [];
-        
-        for (const pos of poss) {
-            if (!isPosQuiteSharpCorner(pos)) {
-                for2Prongs.push(pos);
-            } 
-        }
-        
-        for2ProngsArray.push(for2Prongs);
-    }
-
-    return for2ProngsArray;
-}
-
-
-export { getPotential2Prongs }

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

@@ -1,25 +0,0 @@
-import { IPointOnShape, isPosQuiteSharpCorner } from '../../point-on-shape.js';
-
-
-/** @hidden */
-function getSharpCorners(possPerLoop: IPointOnShape[][]) {
-    const sharpCornersPerLoop = [];
-    
-    for (const poss of possPerLoop) {
-        const sharpCorners = [];
-        
-        for (const pos of poss) {
-            //if (PointOnShape.isQuiteSharpCorner(pos)) {
-            if (isPosQuiteSharpCorner(pos)) {
-                sharpCorners.push(pos);
-            }
-        }
-        
-        sharpCornersPerLoop.push(sharpCorners);
-    }
-
-    return sharpCornersPerLoop;
-}
-
-
-export { getSharpCorners }

package/src/mat/find-mat/get-total-abs-curvature.ts

@@ -1,17 +0,0 @@
-import { totalAbsoluteCurvature } from 'flo-bezier3';
-import { getCurvatureAtInterface } from '../../svg/get-curvature-at-interface.js';
-import { getTotalBy } from './get-total-by.js';
-
-
-/**
- * @hidden
- */
-const getTotalAbsoluteCurvature = getTotalBy(
-    curve => (
-        totalAbsoluteCurvature(curve.ps, [0,1]) + 
-        Math.abs(getCurvatureAtInterface(curve))
-    )
-);
-
-
-export { getTotalAbsoluteCurvature }

package/src/mat/get-contact-circles-at-interface.ts

@@ -1,26 +0,0 @@
-import { Curve, getCornerAtEnd } from '../curve.js';
-import { PointOnShape } from '../point-on-shape.js';
-import { IPointOnShape } from '../point-on-shape.js';
-
-
-/**
- * @hidden
- * @param curve 
- */
-function getContactCirclesAtInterface(curve: Curve): IPointOnShape[] {
-	const { isQuiteSharp, isQuiteDull } = getCornerAtEnd(curve);
-
-	if (isQuiteSharp) {  
-		return [new PointOnShape(curve, 1)]; 
-	} else if (isQuiteDull) {
-		return [
-			new PointOnShape(curve, 1),
-			new PointOnShape(curve.next, 0)
-		];
-	}
-
-	return [];
-}
-
-
-export { getContactCirclesAtInterface }

package/src/mat/to-scale-axis/add-to-tree.ts

@@ -1,66 +0,0 @@
-import { Circle } from '../../circle.js';
-import { calcGroups } from './calc-groups.js';
-import { TTree } from './t-tree.js';
-
-
-// DEPTH_LIMIT can be anything from 1 to 16, but from 2 to 6 seem to be the 
-// fastest.
-/** @hidden */
-const DEPTH_LIMIT = 6;
-
-/**
- * @hidden
- * @param s 
- * @param tree 
- * @param coordinate 
- * @param limits 
- * @param circle 
- * @param depth 
- */
-function addToTree(
-    s: number, 
-    tree: TTree, 
-    coordinate: number, 
-    limits: number[][], 
-    circle: Circle,
-    depth: number) {
-
-    const { groups, newLimits } = calcGroups(
-        s,
-        coordinate, 
-        limits, 
-        circle
-    );
-
-    // Create new edge if it does not exist yet.
-    if (groups.length === 1 && depth !== DEPTH_LIMIT) {
-        const group = groups[0]; 
-        
-        if (!tree.trees!.get(group)) { 
-            tree.trees!.set(group, { trees: new Map(), circles: new Set() } ); 
-        }	
-        const t = tree.trees!.get(group)!;
-        
-        // Flip coordinates
-        const newCoordinate = coordinate ? 0 : 1; 
-        addToTree(
-            s,
-            t, 
-            newCoordinate, 
-            newLimits, 
-            circle, 
-            depth+1
-        );
-        
-        return;
-    }
-
-    if (!tree.trees!.get(5)) { 
-        tree.trees!.set(5, { trees: new Map(), circles: new Set() } );
-    }
-    const vertices = tree.trees!.get(5)!.circles;
-    vertices!.add(circle);
-}
-
-
-export { addToTree }

package/src/mat/to-scale-axis/calc-groups.ts

@@ -1,82 +0,0 @@
-import { Circle } from '../../circle.js';
-
-
-/**
- * @hidden
- * Spacially divide into 5 special groups as follows:
- * 
- *   *******||*******|*******|*******|*******||*******
- * 0 <--------------->
- * 1         <--------------->        
- * 2                 <--------------->
- * 3                         <--------------->
- * 4                                 <--------------->
- * 5 - If the circle does not fall in any of above 5 groups.
- * 
- * Note: In the above, the double pipes denote the limits for
- *       a coordinate, so as can be seen groups 0 and 4 go outside
- *       the limits. Also, groups 1 and 3 are preferred and checked
- *       first. 
- *          
- * @param s Scale parameter, e.g. 1.1
- * @param coordinate - 0 -> horizontal or 1 -> vertical.
- * @param limits - The limits within which the circle bounds can fall.
- * @param circle - The circle to categorize into a group. 
- */
-function calcGroups(
-        s: number, 
-        coordinate: number, 
-        limits: number[][], 
-        circle: Circle) {
-
-    const limit = limits[coordinate];
-    const l1 = limit[0];
-    const l2 = limit[1];
-
-    // Relevant cut-off lines.
-    const q = (l2 - l1) / 4;
-    const w = q+q;
-
-    // Shift origin
-    const r = circle.radius;
-    const x = circle.center[coordinate] - l1;
-    const x0 = x - (r * s);
-    const x1 = x + (r * s); 
-
-    let newLimit: (number | undefined)[] = [,];
-    const groups: number[] = []; // Group to which circle belongs;
-
-    const qStart = Math.floor(x0/q);
-    const qEnd   = Math.floor(x1/q) + 1;
-    const qDiff  = qEnd - qStart; 
-
-    let group: number;
-    if (qDiff === 1) {
-        // If contained in sliver.
-        group = (2 * Math.floor(qStart/2)) + 1;
-        groups.push(group);
-        
-        const lowerLimit = l1 + q*(group-1); 
-        newLimit = [lowerLimit, lowerLimit + w];			
-        
-    } else if (qDiff === 2) {
-        group = qStart + 1;
-        groups.push(group);
-        
-        const lowerLimit = l1 + q*(group-1); 
-        newLimit = [lowerLimit, lowerLimit + w];
-    }
-
-    const newLimits: ((number | undefined)[] | undefined)[] = [,];
-    if (groups.length === 1) {
-        const otherCoordinate = coordinate ? 0 : 1; 
-        
-        newLimits[otherCoordinate] = limits[otherCoordinate];
-        newLimits[coordinate] = newLimit;
-    } 
-
-    return { groups, newLimits };
-}
-
-
-export { calcGroups }

package/src/mat/to-scale-axis/create-spacial-tree.ts

@@ -1,41 +0,0 @@
-import { Circle } from '../../circle.js';
-import { TTree } from './t-tree.js';
-import { addToTree } from './add-to-tree.js';
-
-
-/** @hidden */
-const width  = 1620; // TODO change to actual shape coordinates
-/** @hidden */
-const height = 1560; // ...
-
-
-/**
- * @hidden
- * @param s 
- * @param circles 
- */
-function createSpacialTree(
-        s: number, 
-        circles: Circle[]) {
-
-    const coordinate = 0;
-    const limits = [[0, width], [0, height]];
-
-    const tree: TTree = { trees: new Map(), circles: new Set() };
-
-    for (const circle of circles) {
-        addToTree(
-                s, 
-                tree, 
-                coordinate, 
-                limits, 
-                circle, 
-                0
-        );
-    }
-
-    return tree;
-}
-
-
-export { createSpacialTree }

package/src/mat/to-scale-axis/get-engulfed-vertices.ts

@@ -1,135 +0,0 @@
-import { Circle, scaleCircle, engulfsCircle } from '../../circle.js';
-import { TTree } from './t-tree.js';
-import { calcGroups } from './calc-groups.js';
-
-
-/** @hidden */
-const width  = 1620; // TODO change to actual shape coordinates
-/** @hidden */
-const height = 1560; // ...
-
-
-/**
- * @hidden
- * Returns a map of engulfed MAT nodes determined to be engulfed by the given
- * test node and scale factor and starting from the given spacial tree node.
- * @param s The scale factor
- * @param tree The spacial tree node from where to start
- * @param circle The circle potentially engulfing other nodes
- */
-function getEngulfedVertices(
-        s: number, 
-        tree: TTree, 
-        circle: Circle) {
-
-    const c1 = scaleCircle(circle, s);
-
-    const cullNodes: Set<Circle> = new Set();
-
-    const limits = [[0, width], [0, height]];
-    f(tree, 0, limits, 0);
-
-    return cullNodes;
-
-
-    function cullBranch5(tree: TTree) {
-        const t = tree.trees!.get(5);
-        if (!t) { return; }
-
-        const circles = t.circles!;
-        
-        circles.forEach(function(circle, key) {
-            const c2 = scaleCircle(circle, s);
-            if (engulfsCircle(c1, c2)) {
-                cullNodes.add(circle);
-                circles.delete(key);
-            }					
-        });
-    }
-
-    
-    function f(
-            tree: TTree, 
-            coordinate: number, 
-            limits: number[][] | null, 
-            depth: number) {
-        
-        if (limits === null) {
-            // If we already reached a circle which spans multiple groups 
-            // previously, then check all circles in the tree.
-            cullBranch5(tree);
-            
-            for (let i=0; i<=4; i++) {
-                const t = tree.trees!.get(i);
-                if (t) {
-                    f(t, 0, null, depth+1);
-                }
-            }
-            
-            return;
-        }
-        
-        const { groups, newLimits } = calcGroups(
-                s, 
-                coordinate, 
-                limits, 
-                circle
-        );
-        
-        if (groups.length === 1) {
-            cullBranch5(tree);
-            
-            const group = groups[0];
-            const newCoordinate = coordinate ? 0 : 1;
-            
-            if (group === 1 || group === 3) {
-                // One of the higher priority left/top or 
-                // right/bottom half groups.
-                const t = tree.trees!.get(group);
-                
-                if (t) {
-                    f(
-                            t, 
-                            newCoordinate, 
-                            newLimits, 
-                            depth+1
-                    );
-                }
-            } else {
-                // One of the lower priority even groups (0,2 or 4).
-                
-                const branches: TTree[] = [];
-                branches.push(tree.trees!.get(group)!);
-                if (group > 0) { branches.push(tree.trees!.get(group-1)!); }
-                if (group < 4) { branches.push(tree.trees!.get(group+1)!); }
-                
-                for (const branch of branches) {
-                    if (branch) {
-                        f(
-                                branch, 
-                                newCoordinate, 
-                                newLimits, 
-                                depth+1
-                        );
-                    }
-                }
-            }
-            
-            return;
-        } 
-        
-
-        cullBranch5(tree);
-        // Circle spans multiple groups at this level of the tree. Check all 
-        // circles in all branches.
-        for (let i=0; i<=4; i++) {
-            const t = tree.trees!.get(i);
-            if (!t) { continue; }
-            
-            f(t, 0, null, depth+1);
-        }
-    }
-}
-
-
-export { getEngulfedVertices }