flo-mat 2.0.4 → 3.0.0

package/src/mat/trim-mat.ts

@@ -1,6 +1,6 @@
-import { Mat } from '../mat.js';
+import { Mat } from './mat.js';
 import { createNewCpTree } from './create-new-cp-tree.js';
-import { cullNonCycles } from './to-scale-axis/cull-non-cycles.js';
+import { cullNonCycles } from '../sat/cull-non-cycles.js';
 import { clone } from '../cp-node/clone.js';
 
 
@@ -12,7 +12,7 @@ import { clone } from '../cp-node/clone.js';
 function trimMat(mat: Mat): Mat {
 	const cpNode = cullNonCycles(clone(mat.cpNode));
 
-    if (!cpNode) { return undefined; }
+    if (!cpNode) { return undefined!; }
 
     return { cpNode, cpTrees: createNewCpTree(cpNode) };
 }

package/src/point-on-shape/calc-pos-order.ts

@@ -0,0 +1,35 @@
+import { dot, fromTo, rotateNeg90Degrees, toUnitVector } from "flo-vector2d";
+import { Circle } from "../geometry/circle.js";
+import { PointOnShape } from "./point-on-shape.js";
+import { isPosCorner } from './is-pos-corner.js';
+import { isPosDullCorner } from "./is-pos-dull-corner.js";
+import { getPosCorner } from './get-pos-corner.js';
+
+
+
+/**
+ * @internal
+ * 
+ * Calculates the order (to distinguish between points lying on top of each 
+ * other) of the contact point if it is a dull corner.
+ * 
+ * @param circle
+ * @param pos
+ */
+function calcPosOrder(
+        circle: Circle, 
+        pos: PointOnShape): number {
+
+    if (!isPosCorner(pos)) { return 0; }
+    if (!isPosDullCorner(pos)) { return 0; }
+
+    const corner = getPosCorner(pos);
+
+    const n = rotateNeg90Degrees(corner.tangents[0]);
+    const v = toUnitVector( fromTo(pos.p, circle.center) );
+
+    return -dot(n, v);
+}
+
+
+export { calcPosOrder }

package/src/point-on-shape/compare-poss.ts

@@ -0,0 +1,26 @@
+import { PointOnShape } from "./point-on-shape.js";
+
+
+/**
+ * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
+ * by their relative positions on the shape boundary. 
+ * @param a The first [[PointOnShape]].
+ * @param b The second [[PointOnShape]].
+ * @internal
+ */
+function comparePoss(
+        a: PointOnShape,
+        b: PointOnShape): number {
+
+    let res;
+
+    res = a.curve.idx - b.curve.idx;
+    if (res !== 0) { return res; }
+
+    res = a.t - b.t;
+
+    return res;
+}
+
+
+export { comparePoss }

package/src/point-on-shape/create-pos.ts

@@ -0,0 +1,21 @@
+import { evalDeCasteljauDd } from "flo-bezier3"
+import { Curve } from "../curve/curve.js"
+import { PointOnShape } from "./point-on-shape.js"
+
+
+function createPos(
+        curve: Curve,
+        t: number,
+        source: boolean): PointOnShape {
+
+    return {
+        curve,
+        t,
+        p: evalDeCasteljauDd(curve.ps, [0,t]).map(c => c[1]),
+        // angle
+        source
+    }
+}
+
+
+export { createPos }

package/src/point-on-shape/get-osculating-circle.ts

@@ -0,0 +1,39 @@
+import { tangentExact, ddCurvature } from 'flo-bezier3';
+import { Circle } from '../geometry/circle.js';
+import { PointOnShape } from './point-on-shape.js';
+
+
+
+/**
+ * Returns the osculating circle at this point of the curve.
+ * @param maxOsculatingCircleRadius If not Number.POSITIVE_INFINITY then the
+ * circle radius will be limited to this value.
+ * @param pos The [[PointOnShape]] identifying the point.
+ */
+function getOsculatingCircle(
+        minCurvature: number, 
+        pos: PointOnShape,
+        useMaxRadius = false): Circle {
+
+    const ps = pos.curve.ps;
+    const { p, t } = pos;
+
+    let k = -ddCurvature(ps, t);
+
+    if (k < minCurvature || useMaxRadius) {
+        k = minCurvature;
+    }
+
+    const tangent_ = tangentExact(ps,t).map(c => c[c.length-1]);
+    const normal_ = [-tangent_[1],tangent_[0]];
+    const l = Math.sqrt(normal_[0]**2 + normal_[1]**2);
+    const circleCenter = [
+        p[0] - normal_[0]/(k*l),
+        p[1] - normal_[1]/(k*l)
+    ];
+
+    return { center: circleCenter, radius: 1/k };
+}
+
+
+export { getOsculatingCircle }

package/src/point-on-shape/get-pos-corner.ts

@@ -0,0 +1,16 @@
+import { getCornerAtEnd } from "../curve/curve.js";
+import { Corner } from "../corner/corner.js";
+import { PointOnShape } from "./point-on-shape.js";
+
+
+/**
+ * @internal
+ */
+function getPosCorner(pos: PointOnShape): Corner {
+    return getCornerAtEnd(
+        pos.t === 1 ? pos.curve : pos.curve.prev
+    );
+}
+
+
+export { getPosCorner }

package/src/point-on-shape/is-pos-corner.ts

@@ -0,0 +1,12 @@
+import { PointOnShape } from "./point-on-shape.js";
+
+
+/**
+ * @internal
+ */
+function isPosCorner(pos: PointOnShape) {
+    return (pos.t === 0 || pos.t === 1);
+}
+
+
+export { isPosCorner }

package/src/point-on-shape/is-pos-dull-corner.ts

@@ -0,0 +1,16 @@
+import { memoize } from "flo-memoize";
+import { getPosCorner } from "./get-pos-corner.js";
+import { isPosCorner } from "./is-pos-corner.js";
+import { PointOnShape } from "./point-on-shape.js";
+
+/**
+ * @internal
+ */
+const isPosDullCorner = memoize((pos: PointOnShape) => {
+    if (!isPosCorner(pos)) { return false; }
+
+    return getPosCorner(pos).isDull;
+});
+
+
+export { isPosDullCorner }

package/src/point-on-shape/is-pos-quite-dull-corner.ts

@@ -0,0 +1,17 @@
+import { memoize } from 'flo-memoize';
+import { PointOnShape } from "./point-on-shape.js";
+import { isPosCorner } from './is-pos-corner.js';
+import { getPosCorner } from './get-pos-corner.js';
+
+
+/**
+ * @internal
+ */
+const isPosQuiteDullCorner = memoize((pos: PointOnShape) => {
+    if (!isPosCorner(pos)) { return false; }
+
+    return getPosCorner(pos).isQuiteDull;
+});
+
+
+export { isPosQuiteDullCorner }

package/src/point-on-shape/is-pos-quite-sharp-corner.ts

@@ -0,0 +1,17 @@
+import { memoize } from 'flo-memoize';
+import { PointOnShape } from "./point-on-shape.js";
+import { isPosCorner } from './is-pos-corner.js';
+import { getPosCorner } from './get-pos-corner.js';
+
+
+/**
+ * @internal
+ */
+const isPosQuiteSharpCorner = memoize((pos: PointOnShape) => {
+    if (!isPosCorner(pos)) { return false; }
+
+    return getPosCorner(pos).isQuiteSharp;
+});
+
+
+export { isPosQuiteSharpCorner }

package/src/point-on-shape/is-pos-sharp-corner.ts

@@ -0,0 +1,17 @@
+import { memoize } from "flo-memoize";
+import { getPosCorner } from "./get-pos-corner.js";
+import { isPosCorner } from "./is-pos-corner.js";
+import { PointOnShape } from "./point-on-shape.js";
+
+
+/**
+ * @internal
+ */
+const isPosSharpCorner = memoize((pos: PointOnShape) => {
+    if (!isPosCorner(pos)) { return false; }
+
+    return getPosCorner(pos).isSharp;
+});
+
+
+export { isPosSharpCorner }

package/src/point-on-shape/point-on-shape.ts

@@ -0,0 +1,15 @@
+import { Curve } from '../curve/curve.js';
+
+
+interface PointOnShape {
+    /** The [[ICurve]] on the shape boundary this points belong to. */
+    curve: Curve;
+    /** The bezier parameter value on the curve identifying the point coordinates. */
+    t: number;
+    p: number[];
+    /** just for debugging */
+    source: boolean;  
+}
+
+
+export { PointOnShape }

package/src/point-on-shape/pos-to-human-string.ts

@@ -0,0 +1,16 @@
+import { PointOnShape } from "./point-on-shape.js"
+
+
+/**
+ * Returns a human-readable string of the given [[PointOnShape]]. 
+ * For debugging only.
+ * @internal
+ */
+function posToHumanString(pos: PointOnShape) {
+    return '' + pos.p[0] + ', ' + pos.p[1] + 
+        ' | bz: '   + pos.curve.idx + 
+        ' | t: '    + pos.t 
+}
+
+
+export { posToHumanString }

package/src/{mat/to-scale-axis → sat}/add-debug-info.ts

@@ -1,11 +1,11 @@
 declare const _debug_: Debug; 
 
-import { Debug } from '../../debug/debug.js';
-import { Mat } from '../../mat.js';
+import { Debug } from '../debug/debug.js';
+import { Mat } from '../mat/mat.js';
 
 
 /**
- * @hidden
+ * @internal
  * @param sat 
  */
 function addDebugInfo(

package/src/{mat/to-scale-axis → sat}/cull-non-cycles.ts

@@ -1,9 +1,9 @@
-import { getLeaves } from '../get-leaves.js';
-import { CpNode } from '../../cp-node.js';
+import { getLeaves } from './get-leaves.js';
+import { CpNode, getProngCount, isOnSameCircle, isTerminating } from '../cp-node/cp-node.js';
 
 
 /**
- * @hidden
+ * @internal
  * Cull all edges not part of a cycle in the MAT planar graph.
  * @param cpStart The start CpNode which must reprsesent the maximal 3-prong 
  * vertex.
@@ -16,7 +16,7 @@ function cullNonCycles(cpStart: CpNode) {
 
     
     while (leaves.length) {
-        const leaf = leaves.pop();
+        const leaf = leaves.pop()!;
 
         // Preserve topology - keep cycles.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -28,19 +28,19 @@ function cullNonCycles(cpStart: CpNode) {
             let cut = false;
             const cp1 = cpNode.prevOnCircle;
 
-            if (cpNode.getProngCount() > 2) {
+            if (getProngCount(cpNode) > 2) {
                 //const cp2 = cp1.prevOnCircle;
                 const cp2 = cpNode.nextOnCircle;
 
                 //if (cpStart === cpNode || cpStart === cp1 || cpStart === cp2) {
-                if (CpNode.isOnSameCircle(cpNode, cpStart)) {
+                if (isOnSameCircle(cpNode, cpStart)) {
                     cut = true; // We are at the max disk - cut whole edge
                 } else if (cpNode.next === cp2) {
                     cpNode = cp2;
                 } else if (cp2.next !== cp1) {
                     cut = true; // Cut whole edge
                 }
-            } else if (cpNode.isTerminating() && !cpNode.isIntersection) {
+            } else if (isTerminating(cpNode) && !cpNode.isIntersection) {
                 cpNodeKept = cpNode;
                 return undefined;
             }

package/src/{mat/to-scale-axis → sat}/cull.ts

@@ -1,10 +1,10 @@
-import { Circle } from '../../circle.js';
-import { getLeaves } from '../get-leaves.js';
-import { CpNode } from '../../cp-node.js';
+import { Circle } from '../geometry/circle.js';
+import { getLeaves } from './get-leaves.js';
+import { CpNode, isOnSameCircle } from '../cp-node/cp-node.js';
 
 
 /**
- * @hidden
+ * @internal
  * Returns the set of Vertices passing the following test: walk the MAT tree and 
  * keep all Vertices not in the current cull set and any Vertices that have a 
  * non-culled node further down the line toward the tree leaves.
@@ -32,7 +32,7 @@ function cull(
     }
 
     while (leaves.length) {
-        const leaf = leaves.pop();
+        const leaf = leaves.pop()!;
 
         // Preserve topology.
         if (leaf.isHoleClosing || leaf.isIntersection) { continue; }
@@ -51,7 +51,7 @@ function cull(
             if (!culls.has(cpNode.cp.circle)) {
                 // Cut off the edge once a non-cull has been reached.
                 cut = true;
-            } else if (CpNode.isOnSameCircle(cpNode, maxCpNode)) {
+            } else if (isOnSameCircle(cpNode, maxCpNode)) {
                 cut = true; // We are at the max disk - cut whole edge
             } else {
                 const cps = getNonTrivialEdges(cpNode);

package/src/{mat → sat}/get-leaves.ts

@@ -1,13 +1,13 @@
-import { CpNode } from '../cp-node.js';
+import { CpNode, getAllOnLoop, isTerminating } from '../cp-node/cp-node.js';
 
 
-/** @hidden */
+/** @internal */
 function getLeaves(cpNode: CpNode) {
     const leaves: CpNode[] = [];
 
-    const cps = cpNode.getAllOnLoop();
+    const cps = getAllOnLoop(cpNode);
     cps.forEach(function(cp) {
-        if (cp.isTerminating()) { 
+        if (isTerminating(cp)) { 
             leaves.push(cp);
         }
     });

package/src/{mat/to-scale-axis → sat}/t-tree.ts

@@ -1,7 +1,7 @@
-import { Circle } from '../../circle.js';
+import { Circle } from '../geometry/circle.js';
 
 
-/** @hidden */
+/** @internal */
 export type TTree = {
     trees?: Map<number,TTree>,
     circles?: Set<Circle>

package/src/{to-scale-axis.ts → sat/to-scale-axis.ts}

@@ -2,19 +2,19 @@
 declare const _debug_: Debug;
 
 import { length } from 'flo-bezier3';
-import { Debug } from './debug/debug.js';
-import { CpNode } from './cp-node.js';
-import { Circle } from './circle.js';
-import { Mat } from './mat.js';
-import { traverseEdges } from './traverse-edges.js';
-import { traverseVertices } from './traverse-vertices.js';
-import { getLargestVertex } from './mat/get-largest-vertex.js';
-import { createNewCpTree } from './mat/create-new-cp-tree.js';
-import { getLeaves } from './mat/get-leaves.js';
-import { cull } from './mat/to-scale-axis/cull.js';
-import { addDebugInfo } from './mat/to-scale-axis/add-debug-info.js';
-import { clone } from './cp-node/clone.js';
-import { getCurveToNext } from './get-curve-to-next.js';
+import { Debug } from '../debug/debug.js';
+import { CpNode, getCpNodesOnCircle } from '../cp-node/cp-node.js';
+import { Circle } from '../geometry/circle.js';
+import { Mat } from '../mat/mat.js';
+import { traverseEdges } from '../cp-node/traverse-edges.js';
+import { traverseVertices } from '../cp-node/traverse-vertices.js';
+import { getLargestVertex } from '../mat/get-largest-vertex.js';
+import { createNewCpTree } from '../mat/create-new-cp-tree.js';
+import { getLeaves } from './get-leaves.js';
+import { cull } from './cull.js';
+import { addDebugInfo } from './add-debug-info.js';
+import { clone } from '../cp-node/clone.js';
+import { getCurveToNext } from '../cp-node/get-curve-to-next.js';
 
 
 function linearScale(s: number) {
@@ -24,7 +24,7 @@ function linearScale(s: number) {
 }
 
 
-/** @hidden */
+/** @internal */
 //let len = length([0,1]);
 
 
@@ -85,7 +85,7 @@ function toScaleAxis(
 		const r = cpNode_.cp.circle.radius;
 		const r_ = f_(r);
 		if (R - l > r_) {
-			for (const cpNode of cpNode_.getCpNodesOnCircle()) {
+			for (const cpNode of getCpNodesOnCircle(cpNode_)) {
 				rMap.set(cpNode, R - l); // Update osculating radii
 			}
 			culls.add(cpNode_.cp.circle);
@@ -100,7 +100,7 @@ function toScaleAxis(
 	 
 	// TODO - put line below back - goes into infinite loop
 	//const sat: Mat = { cpNode, cpTrees: createNewCpTree(cpNode) };
-	const sat: Mat = { cpNode, cpTrees: undefined };
+	const sat: Mat = { cpNode, cpTrees: undefined! };
 
 	addDebugInfo(sat, timingStart);
 

package/src/{mat/to-scale-axis → sat}/traverse-spacial-tree.ts

@@ -1,9 +1,9 @@
-import { Circle } from '../../circle.js';
+import { Circle } from '../geometry/circle.js';
 import { TTree } from './t-tree.js';
 
 
 /**
- * @hidden
+ * @internal
  * Traverses the spacial tree and calls the given callback function for each
  * MAT circle in the tree and iteravely for each subtree.
  * @param tree The spacial tree to traverse
@@ -18,14 +18,14 @@ function traverseSpacialTree(
     function g(tree: TTree) {
         if (!tree) { return; }
         
-        if (tree.circles.size) {
-            tree.circles.forEach(f);
+        if (tree.circles!.size) {
+            tree.circles!.forEach(f);
             
             return; // Leaf reached 
         }
 
         [5,0,2,4,1,3].forEach(
-            i => g(tree.trees.get(i))
+            i => g(tree.trees!.get(i)!)
         );
     }
 }

package/src/svg/get-loop-bounds.ts

@@ -1,22 +1,23 @@
 import { getBounds } from 'flo-bezier3';
 import { memoize } from 'flo-memoize';
-import { Loop } from '../loop.js';
-import { Curve } from '../curve.js';
-import { PointOnShape, IPointOnShape } from '../point-on-shape.js';
+import { Loop } from 'flo-boolean';
+import { Curve } from '../curve/curve.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { createPos } from '../point-on-shape/create-pos.js';
 
 
-/** @hidden */
+/** @internal */
 const INF = Number.POSITIVE_INFINITY;
 
 
 /** 
- * @hidden 
+ * @internal 
  */
 const getLoopBounds = memoize(function(loop: Loop): {
-		minX: IPointOnShape;
-		minY: IPointOnShape;
-		maxX: IPointOnShape;
-		maxY: IPointOnShape } {	
+		minX: PointOnShape;
+		minY: PointOnShape;
+		maxX: PointOnShape;
+		maxY: PointOnShape } {	
 
 	const extremes: { 
 		bezier: Curve, 
@@ -24,12 +25,12 @@ const getLoopBounds = memoize(function(loop: Loop): {
 		val: number 
 	}[][] = [
 		[
-			{ bezier: undefined, t: undefined, val: INF}, 
-			{ bezier: undefined, t: undefined, val: INF}
+			{ bezier: undefined!, t: undefined!, val: INF}, 
+			{ bezier: undefined!, t: undefined!, val: INF}
 		], 
 		[
-			{ bezier: undefined, t: undefined, val: -INF}, 
-			{ bezier: undefined, t: undefined, val: -INF}
+			{ bezier: undefined!, t: undefined!, val: -INF}, 
+			{ bezier: undefined!, t: undefined!, val: -INF}
 		]
 	];
 	
@@ -93,10 +94,14 @@ const getLoopBounds = memoize(function(loop: Loop): {
 	});
 
 	return {
-		minX : new PointOnShape(extremes[0][0].bezier, extremes[0][0].t),
-		minY : new PointOnShape(extremes[0][1].bezier, extremes[0][1].t),
-		maxX : new PointOnShape(extremes[1][0].bezier, extremes[1][0].t),
-		maxY : new PointOnShape(extremes[1][1].bezier, extremes[1][1].t)
+		// minX : new PointOnShape(extremes[0][0].bezier, extremes[0][0].t),
+		// minY : new PointOnShape(extremes[0][1].bezier, extremes[0][1].t),
+		// maxX : new PointOnShape(extremes[1][0].bezier, extremes[1][0].t),
+		// maxY : new PointOnShape(extremes[1][1].bezier, extremes[1][1].t)
+		minY : createPos(extremes[0][1].bezier, extremes[0][1].t, true),
+		minX : createPos(extremes[0][0].bezier, extremes[0][0].t, true),
+		maxX : createPos(extremes[1][0].bezier, extremes[1][0].t, true),
+		maxY : createPos(extremes[1][1].bezier, extremes[1][1].t, true)
 	};
 });
 

package/src/svg/get-min-y-pos.ts

@@ -1,10 +1,10 @@
-/** @hidden */
-import { Loop } from '../loop.js';
+/** @internal */
+import { Loop } from 'flo-boolean';
 import { getLoopBounds } from './get-loop-bounds.js';
 
 
 /**
- * @hidden
+ * @internal
  * Get topmost PointOnShape of the given loop.
  */
 function getMinYPos(loop: Loop) {

package/src/svg/get-shape-bounds.ts

@@ -1,11 +1,9 @@
 import { memoize } from 'flo-memoize';
-import { Loop } from '../loop.js';
+import { Loop } from 'flo-boolean';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
 import { getLoopBounds } from './get-loop-bounds.js';
 
 
-// TODO - move to another library
-
-
 /** @internal */
 const getShapeBounds = memoize(function(loops: Loop[]) {
     let minX_ = Number.POSITIVE_INFINITY;
@@ -13,10 +11,10 @@ const getShapeBounds = memoize(function(loops: Loop[]) {
     let minY_ = Number.POSITIVE_INFINITY;
     let maxY_ = Number.NEGATIVE_INFINITY;
 
-    let minX;
-    let maxX;
-    let minY;
-    let maxY;
+    let minX: PointOnShape;
+    let maxX: PointOnShape;
+    let minY: PointOnShape;
+    let maxY: PointOnShape;
 
     for (const loop of loops) {
         const bounds = getLoopBounds(loop);
@@ -38,7 +36,12 @@ const getShapeBounds = memoize(function(loops: Loop[]) {
         }
     }
     
-    return { minX, minY, maxX, maxY };
+    return {
+        minX: minX!,
+        minY: minY!,
+        maxX: maxX!,
+        maxY: maxY!
+    };
 });
 
 

package/src/sweep-line/are-boxes-intersecting.ts

@@ -1,6 +1,6 @@
 
 /**
- * @hidden
+ * @internal
  * Returns true if the 2 given (closed) boxes intersect. At this stage we already
  * know their x-axis intersect.
  * @param a A rectangular box

package/src/sweep-line/sweep-line.ts

@@ -1,16 +1,16 @@
 
-/** @hidden */
+/** @internal */
 const EVENT_LEFT  = 0;
-/** @hidden */
+/** @internal */
 const EVENT_RIGHT = 1;
 
-/** @hidden */
+/** @internal */
 type LEFT = 0;
-/** @hidden */
+/** @internal */
 type RIGHT = 1;
 
 /**
- * @hidden
+ * @internal
  * Generalized sweepline algorithm.
  * 
  * Typically used to turn O(n^2) algorithms into roughly O(n logn) algorithms.
@@ -71,7 +71,7 @@ function sweepLine<T>(
 	return pairedItems;
 }
 
-/** @hidden */
+/** @internal */
 interface IEvent<T> {
     /** type - 0 -> left side, 1 -> right side */
     type: LEFT|RIGHT;
@@ -85,7 +85,7 @@ interface IEvent<T> {
 
 
 /**
- * @hidden
+ * @internal
  * Compare two Events by their x-axis and then by their type. Since it is
  * open boxes that are compared we must let the right endpoint type come
  * before the left.