flo-mat 3.0.1 → 3.0.2

package/src/sat/get-sat-culls.ts

@@ -0,0 +1,46 @@
+import { length } from "flo-bezier3";
+import { CpNode } from "../cp-node/cp-node.js";
+import { getAllOnCircle } from "../cp-node/fs/get-all-on-circle.js";
+import { getMatCurveToNext } from "../cp-node/fs/get-mat-curve-to-next.js";
+import { traverseEdges } from "../cp-node/fs/traverse-edges.js";
+import { DualSet, DualSetFs } from "../utils/dual-set.js";
+
+
+function getSatCulls(
+        cpNode: CpNode, 
+        s: number) {
+
+    /** 
+     * All vertices that are set to be culled initially. This may change later 
+     * in order to preserve topology. 
+     */
+    const culls: DualSet<number,number> = new Map();
+
+    const rMap: Map<CpNode,number> = new Map();
+
+    traverseEdges(cpNode, function(cpNode) {
+        /** The occulating radius stored with this vertex. */
+        const R = rMap.get(cpNode) || (s*cpNode.cp.circle.radius);
+
+        const cpNode_ = cpNode.next;
+
+        const l = length([0,1], getMatCurveToNext(cpNode));
+
+        const r = cpNode_.cp.circle.radius;
+        const r_ = s*r;
+        if (R - l > r_) {
+            for (const cpNode of getAllOnCircle(cpNode_)) {
+                rMap.set(cpNode, R - l); // Update osculating radii
+                if (!cpNode_.isHoleClosing) {
+                    const { center: c } = cpNode_.cp.circle;
+                    DualSetFs.add(culls, c[0], c[1]);
+                }
+            }
+        }
+    });
+
+    return culls;
+}
+
+
+export { getSatCulls }

package/src/sat/to-scale-axis.ts

@@ -1,20 +1,14 @@
 /** @internal */
 declare const _debug_: Debug;
 
-import { length } from 'flo-bezier3';
 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';
+import { clone } from '../cp-node/fs/clone.js';
+import { getSatCulls } from './get-sat-culls.js';
 
 
 /**
@@ -36,61 +30,23 @@ function toScaleAxis(
 	let timingStart = 0;
 	if (typeof _debug_ !== 'undefined') {
 		timingStart = performance.now();
-		const leaves = getLeaves(mat.cpNode);
-		_debug_.generated.elems.leaves.push(leaves);
 	}
 
-	/** The largest vertex (as measured by its inscribed disk) */
-	const cpNodes: CpNode[] = [];
-	traverseVertices(
-		clone(mat.cpNode), 
-		cpNode => { cpNodes.push(cpNode); }
-	);
-
-	const cpNode = getLargestVertex(cpNodes);
-	// console.log(cpNodes.map(c => c.cp.circle.radius).length)
-
-	if (typeof _debug_ !== 'undefined') {
-		_debug_.generated.elems.maxVertex.push(cpNode);
-	}
-
-	/** 
-	 * All vertices that are set to be culled initially. This may change later 
-	 * in order to preserve topology. 
-	 */
-	const culls: Set<Circle> = new Set();
-
-	const rMap: Map<CpNode,number> = new Map();
-
-	traverseEdges(cpNode, function(cpNode) {
-		/** The occulating radius stored with this vertex. */
-		const R = rMap.get(cpNode) || (s*cpNode.cp.circle.radius);
-
-		const cpNode_ = cpNode.next;
-
-		const l = length([0,1], getCurveToNext(cpNode));
-
-		const r = cpNode_.cp.circle.radius;
-		const r_ = s*r;
-		if (R - l > r_) {
-			for (const cpNode of getCpNodesOnCircle(cpNode_)) {
-				rMap.set(cpNode, R - l); // Update osculating radii
-			}
-			culls.add(cpNode_.cp.circle);
-		}
-	});
+	const cpNode = getLargestVertex(clone(mat.cpNode));
+	const culls = getSatCulls(cpNode, s);
 
 	cull(culls, cpNode);
 
-	if (typeof _debug_ !== 'undefined') {
-		_debug_.generated.elems.culls.push(Array.from(culls));
-	}
-	 
-	// 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: cpNode,
+        meta: {
+            ...mat.meta,
+			cpTrees: createNewCpTree(cpNode)
+        }
+    };
+
 
-	addDebugInfo(sat, timingStart);
+	addDebugInfo(timingStart);
 
 	return sat;
 }

package/src/svg/get-extreme.ts

@@ -1,4 +1,4 @@
-import { Loop } from '../loop.js';
+import { Loop } from 'flo-boolean';
 import { getShapeBounds } from './get-shape-bounds.js';
 
 

package/src/utils/bezier-piece-to-bezier.ts

@@ -0,0 +1,13 @@
+import { BezierPiece, fromTo } from "flo-bezier3";
+
+
+function bezierPieceToBezier(
+        piece: BezierPiece) {
+
+    const { ps, ts } = piece;
+
+    return fromTo(ps, ts[0], ts[1]);
+}
+
+
+export { bezierPieceToBezier }

package/src/utils/deg-to-rad.ts

@@ -0,0 +1,7 @@
+
+function degToRad(degrees: number) {
+    return degrees/360*2*Math.PI;
+}
+
+
+export { degToRad };

package/src/utils/dual-map.ts

@@ -0,0 +1,55 @@
+
+/**
+ * A 'dual-map' in the sense that it needs two ordered keys to return one 
+ * value.
+ */
+type DualMap<K,L,V> = Map<K,Map<L,V>>;
+
+
+/**
+ * Get a value from the dual-map.
+ * @param map 
+ * @param k 
+ * @param l 
+ */
+function get<K,L,V>(
+        map: DualMap<K,L,V>,
+        k: K,
+        l: L): V | undefined {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) { return undefined; }
+
+    return lMap.get(l);
+}
+
+
+/**
+ * Set a value in the dual-map.
+ * * destructively sets the value
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param v 
+ */
+function set<K,L,V>(
+        map: DualMap<K,L,V>,
+        k: K,
+        l: L,
+        v: V): void {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) {
+        lMap = new Map();
+        map.set(k, lMap);
+    }
+    lMap.set(l, v);
+}
+
+
+const DualMapFs = {
+    get, set
+}
+
+
+export { DualMap, DualMapFs }

package/src/utils/dual-set.ts

@@ -0,0 +1,82 @@
+
+/**
+ * A 'dual-set' in the sense that it needs two ordered keys.
+ */
+type DualSet<K,L> = Map<K,Set<L>>;
+
+
+/**
+ * Get a value from the dual-set.
+ * @param set 
+ * @param k 
+ */
+function has<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): boolean {
+
+    const lSet = set.get(k);
+    if (lSet === undefined) { return false; }
+
+    return lSet.has(l);
+}
+
+
+/**
+ * Adds a value to the dual-set.
+ * 
+ * * destructively sets the value
+ * 
+ * @param set 
+ * @param k 
+ * @param l 
+ */
+function add<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): void {
+
+    let lSet = set.get(k);
+    if (lSet === undefined) {
+        lSet = new Set();
+        set.set(k, lSet);
+    }
+    lSet.add(l);
+}
+
+
+function remove<K,L>(
+        set: DualSet<K,L>,
+        k: K,
+        l: L): boolean {
+
+    let lSet = set.get(k);
+    if (lSet === undefined) {
+        return false;
+    }
+    const r = lSet.delete(l);
+    if (!r) { return false; }
+
+    if (lSet.size === 0) {
+        set.delete(k);
+    }
+
+    return true;
+}
+
+
+const DualSetFs = { has, add, remove };
+
+
+export { DualSet, DualSetFs }
+
+
+// TESTING
+// const s: DualSet<number,number> = new Map();
+// add(s,1,2);
+// has(s,1,2);//?
+// has(s,2,1);//?
+// has(s,1,1);//?
+// add(s,1,1);
+// has(s,1,1);//?
+// has(s,1,2);//?

package/src/utils/rad-to-deg.ts

@@ -0,0 +1,7 @@
+
+function radToDeg(rad: number) {
+    return rad*360/2/Math.PI;
+}
+
+
+export { radToDeg };

package/src/utils/rotate.ts

@@ -0,0 +1,17 @@
+import { rotate } from "flo-vector2d";
+import { degToRad } from "./deg-to-rad.js";
+
+const { sin, cos } = Math;
+
+
+function rotateRad(v: number[], θ: number) {
+    return rotate(sin(θ), cos(θ))(v);
+}
+
+
+function rotateDeg(v: number[], θ: number) {
+    return rotate(sin(degToRad(θ)), cos(degToRad(θ)))(v);
+}
+
+
+export { rotateRad, rotateDeg }

package/src/utils/sleep.ts

@@ -0,0 +1,7 @@
+
+function sleep(ms: number) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+
+export { sleep }

package/src/utils/sum.ts

@@ -0,0 +1,12 @@
+
+function sum(ns: number[]) {
+    let total = 0;
+    for (let n of ns) {
+        total += n;
+    }
+
+    return total;
+}
+
+
+export { sum }

package/src/utils/tri-map.ts

@@ -0,0 +1,76 @@
+
+/**
+ * A 'tri-map' in the sense that it needs two ordered keys to return one 
+ * value.
+ */
+type TriMap<K,L,M,V> = Map<K,Map<L,Map<M,V>>>;
+
+
+/**
+ * Get a value from the tri-map.
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param m 
+ */
+function get<K,L,M,V>(
+        map: TriMap<K,L,M,V>,
+        k: K,
+        l: L,
+        m: M): V | undefined {
+
+    const lMap = map.get(k);
+    if (lMap === undefined) { return undefined; }
+
+    const mMap = lMap.get(l);
+    if (mMap === undefined) { return undefined; }
+
+    return mMap.get(m);
+}
+
+
+/**
+ * Set a value in the tri-map.
+ * * destructively sets the value
+ * @param map 
+ * @param k 
+ * @param l 
+ * @param v 
+ */
+function set<K,L,M,V>(
+        map: TriMap<K,L,M,V>,
+        k: K,
+        l: L,
+        m: M,
+        v: V): void {
+
+    let lMap = map.get(k);
+    if (lMap === undefined) {
+        lMap = new Map();
+        map.set(k, lMap);
+    }
+
+    let mMap = lMap.get(l);
+    if (mMap === undefined) {
+        mMap = new Map();
+        lMap.set(l, mMap);
+    }
+
+    mMap.set(m, v);
+}
+
+
+const TriMapFs = {
+    get, set
+}
+
+
+export { TriMap, TriMapFs }
+
+
+// Test
+// const triMap = new Map<number,Map<number,Map<number,number>>>();
+// set(triMap, 1,2,3, 4);
+// set(triMap, 4,3,2, 1);
+// get(triMap, 4,2,3); //?
+

package/src/vertex/remove-vertex.ts

@@ -0,0 +1,22 @@
+import { Loop } from 'flo-boolean';
+import { LlRbTree } from 'flo-ll-rb-tree';
+import { CpNode } from "../cp-node/cp-node.js";
+import { getAllOnCircle } from '../cp-node/fs/get-all-on-circle.js';
+import { getProngCount } from '../cp-node/fs/get-prong-count.js';
+import { removeCpNode } from '../cp-node/fs/remove-cp-node.js';
+
+
+function removeVertex(
+        cpNode: CpNode,
+        cpTrees: Map<Loop, LlRbTree<CpNode>>): void {
+
+    const prongCount = getProngCount(cpNode);
+    if (prongCount !== 2) {
+        throw new Error(`Cannot delete \`CpNode\` on ${prongCount}-prong`)
+    }
+
+    getAllOnCircle(cpNode).forEach(cpNode => removeCpNode(cpNode, cpTrees));
+}
+
+
+export { removeVertex }

package/webpack.config.cjs

@@ -1,12 +1,7 @@
-const path = require('path');
-const CircularDependencyPlugin = require('circular-dependency-plugin');
-const ResolveTypeScriptPlugin = require("resolve-typescript-plugin");
-
+// const CircularDependencyPlugin = require('circular-dependency-plugin');
+// const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 
-const extensions = [
-    '.js', '.mjs', '.cjs', 
-    '.jsx', '.cjsx', '.mjsx'
-];
+const path = require('path');
 
 
 const config_Basic = {
@@ -14,19 +9,26 @@ const config_Basic = {
     // mode: 'development',
     entry: './src/index.ts',
     resolve: {
-        extensions,
-        plugins: [
-            new ResolveTypeScriptPlugin({includeNodeModules: false})
-        ]
+        extensions: [
+            '.js', '.mjs', '.cjs', 
+            '.jsx', '.cjsx', '.mjsx',
+            '.tsx', '.ts', '.d.ts'
+        ],
+        extensionAlias: {
+            ".js": [".js", ".ts"],
+            ".cjs": [".cjs", ".cts"],
+            ".mjs": [".mjs", ".mts"]
+        },
+        alias: {}
     },
     module: {
-        rules: [
-            {
-                test: /\.tsx?$/,
-                use: 'ts-loader',
-                exclude: /node_modules/
-            }
-        ]
+        rules: [{
+            test: /\.tsx?$/,
+            loader: 'ts-loader',
+            options: { silent: true },
+            exclude: /node_modules/,
+            sideEffects: false
+        }]
     },
     stats: {
         // Don't display most things
@@ -36,14 +38,14 @@ const config_Basic = {
         builtAt: true
     },
     plugins: [
-        new CircularDependencyPlugin({
-            // exclude detection of files based on a RegExp
-            exclude: /node_modules/,
-            // add errors to webpack instead of warnings
-            failOnError: true,
-            // set the current working directory for displaying module paths
-            cwd: process.cwd(),
-        })
+        // new CircularDependencyPlugin({
+        //     // exclude detection of files based on a RegExp
+        //     exclude: /node_modules/,
+        //     // add errors to webpack instead of warnings
+        //     failOnError: true,
+        //     // set the current working directory for displaying module paths
+        //     cwd: process.cwd(),
+        // })
     ],
     output: {
         path: path.resolve(__dirname, 'browser'),
@@ -65,17 +67,17 @@ const config_EsmMinify = {
 
 
 /** ESM, not minified */ 
-const config_EsmNoMinify = {
-    ...config_Basic,
-    output: {
-        ...config_Basic.output,
-        filename: 'index.js',
-    },
-    optimization: { minimize: false },
-};
+// const config_EsmNoMinify = {
+//     ...config_Basic,
+//     output: {
+//         ...config_Basic.output,
+//         filename: 'index.js',
+//     },
+//     optimization: { minimize: false },
+// };
 
 
 module.exports = [
     config_EsmMinify,
-    config_EsmNoMinify
+    // config_EsmNoMinify
 ];