@woosh/meep-engine 2.66.0 → 2.68.0

package/src/core/bvh2/transform/BottomUpOptimizingRebuilder.js

@@ -1,144 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf } from "../LeafNode.js";
-import { surfaceAreaHeuristic } from "../sah/surfaceAreaHeuristic.js";
-import { aabb3_score_boxes_SAH } from "../../geom/3d/aabb/aabb3_score_boxes_SAH.js";
-import { aabb3_box_surface_area_2 } from "../../geom/3d/aabb/aabb3_box_surface_area_2.js";
-
-function BottomUpOptimizingRebuilder() {
-    this.root = null;
-    this.nodes = [];
-    /**
-     * @type {function(left:NodeDescription, right:NodeDescription):number} heuristic Cost function of pairing two nodes, lower value means better pairing
-     */
-    this.heuristic = aabb3_score_boxes_SAH;
-}
-
-/**
- *
- * @param {BinaryNode} root
- */
-BottomUpOptimizingRebuilder.prototype.init = function (root) {
-    this.root = root;
-    const nodes = this.nodes = [];
-    const binaryNodePool = this.binaryNodePool = [];
-
-    //first extract all leaf nodes
-    root.traversePreOrderUsingStack(function (node) {
-        if (isLeaf(node)) {
-            nodes.push(node);
-        } else if (node !== root) {
-            //collect intermediate nodes for reuse
-            binaryNodePool.push(node);
-        }
-    });
-};
-/**
- * Factory to allow reuse of existing node, avoiding garbage collection
- * @returns {BinaryNode}
- */
-BottomUpOptimizingRebuilder.prototype.makeBinaryNode = function () {
-    if (this.binaryNodePool.length > 0) {
-        return this.binaryNodePool.pop();
-    } else {
-        return new BinaryNode();
-    }
-};
-
-/**
- *
- * @param {number} maxSteps
- * @returns {boolean} true when complete
- */
-BottomUpOptimizingRebuilder.prototype.compute = function (maxSteps) {
-    const self = this;
-    /**
-     *
-     * @type {Array.<NodeDescription>}
-     */
-    const nodes = this.nodes;
-
-    let nodeCount = nodes.length;
-
-    const heuristic = this.heuristic;
-
-    let stepsRemaining = maxSteps;
-
-
-    while (nodeCount > 2 && stepsRemaining-- >= 0) {
-        let bestI = -1;
-        let bestJ = -1;
-        let bestCost = Number.POSITIVE_INFINITY;
-        for (let i = 0; i < nodeCount - 1; i++) {
-            const first = nodes[i];
-            for (let j = i + 1; j < nodeCount; j++) {
-                const second = nodes[j];
-
-                const cost = heuristic(first, second);
-
-                if (cost < bestCost) {
-                    bestCost = cost;
-
-                    bestI = i;
-                    bestJ = j;
-                }
-            }
-        }
-
-        const first = nodes[bestI];
-        const second = nodes[bestJ];
-
-        const binaryNode = self.makeBinaryNode();
-        binaryNode.setChildren(first, second);
-
-        //transplant new node in place of the second removed node
-        nodes[bestI] = binaryNode;
-        nodes.splice(bestJ, 1);
-
-        nodeCount--;
-    }
-
-    const root = this.root;
-
-    if (nodeCount === 2) {
-        root.setChildren(nodes[0], nodes[1]);
-        return true;
-    } else if (nodeCount === 1) {
-        root.left = nodes[0];
-        root.left.parentNode = root;
-        root.refit();
-        return true;
-    } else if (nodeCount === 0) {
-        //no nodes, we're done
-        return true;
-    } else {
-        //not done yet
-        return false;
-    }
-};
-
-const leafCounts = new Map();
-
-function leaves(node) {
-    if (leafCounts.has(node)) {
-        return leafCounts.get(node);
-    } else {
-        const count = countLeaves(node);
-        leafCounts.set(node, count);
-        return count;
-    }
-}
-
-function sah(left, right) {
-    const leftArea = aabb3_box_surface_area_2(left);
-    const rightArea = aabb3_box_surface_area_2(right);
-
-    const leftLeaves = leaves(left);
-    const rightLeaves = leaves(right);
-
-    const commonArea = aabb3_score_boxes_SAH(left, right);
-
-    return surfaceAreaHeuristic(commonArea, leftArea, rightArea, leftLeaves, rightLeaves);
-}
-
-
-export { BottomUpOptimizingRebuilder };

package/src/core/bvh2/transform/RotationOptimizer.js

@@ -1,123 +0,0 @@
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf } from "../LeafNode.js";
-import { StacklessTraverser } from "../StacklessTraverser.js";
-import { tryRotateSingleNode } from "./tryRotateSingleNode.js";
-
-
-/**
- *
- * @type {(BinaryNode|LeafNode)[]}
- */
-const stack = [];
-let stackPointer = 0;
-
-/**
- *  * @param {BinaryNode} node
- * @param {Map.<NodeDescription,int>} leafCounts
- */
-function getLeafCount(node, leafCounts) {
-    if (isLeaf(node)) {
-        return 1;
-    }
-
-    let result = 0;
-
-    let n;
-
-    const storedValue = leafCounts.get(node);
-
-    if (storedValue !== undefined) {
-        return storedValue;
-    }
-
-    const stackOffset = stackPointer;
-
-    stack[stackPointer++] = node;
-
-    while (stackPointer-- > stackOffset) {
-
-        n = stack[stackPointer];
-
-
-        const storedValue = leafCounts.get(node);
-
-        if (storedValue !== undefined) {
-            result += storedValue;
-            continue;
-        }
-
-
-        if (n.isBinaryNode) {
-
-            if (n.right !== null) {
-                stack[stackPointer++] = n.right;
-            }
-
-            if (n.left !== null) {
-                stack[stackPointer++] = n.left;
-            }
-
-        } else {
-
-            result++;
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer = stackOffset;
-
-    leafCounts.set(node, result);
-
-    return result;
-}
-
-/**
- *
- * @param {BinaryNode} root
- * @param {int} maxIterations
- */
-export function optimize(root, maxIterations = 1000) {
-    const traverser = new StacklessTraverser();
-
-    traverser.init(root);
-
-    let changeCounter = 0;
-
-    const leafCounts = new Map();
-
-    function visit(node) {
-
-        if (isLeaf(node)) {
-            //skip leaves
-            return true;
-        }
-
-        const rotationType = tryRotateSingleNode(node, leafCounts);
-        if (rotationType !== 0) {
-            changeCounter++;
-        }
-    }
-
-    let oldChangeCounter = changeCounter;
-
-    let i;
-    for (i = 0; i < maxIterations; i++) {
-        const canAdvance = traverser.advance(visit);
-        if (!canAdvance) {
-            //check if we have made any rotations in this traversal pass
-            if (oldChangeCounter === changeCounter) {
-                //done, no changes
-                break;
-            } else {
-                oldChangeCounter = changeCounter;
-            }
-
-            //re-initialize the traverser
-            traverser.init(root);
-        }
-
-    }
-
-    return changeCounter;
-}

package/src/core/bvh2/transform/RotationOptimizer.spec.js

@@ -1,303 +0,0 @@
-import { seededRandom } from "../../math/random/seededRandom.js";
-import { BinaryNode } from "../BinaryNode.js";
-import { isLeaf, LeafNode } from "../LeafNode.js";
-import { validateNode, validateTree } from "../NodeValidator.js";
-import { optimize } from "./RotationOptimizer.js";
-
-expect.extend({
-    toBeValid(node) {
-        const violations = [];
-
-        function violationCallback(v) {
-            violations.push(v);
-        }
-
-        let pass = true;
-        if (isLeaf(node)) {
-            pass = pass && validateNode(node, violationCallback);
-        } else {
-            pass = pass && validateTree(node, violationCallback);
-        }
-
-        if (!pass) {
-            let message = violations.map((v) => v.toString()).join("\n");
-
-            if (message.trim().length === 0) {
-                message = `node is not valid`;
-            }
-
-            return {
-                message: function () {
-                    return message
-                },
-                pass: false
-            };
-        }
-
-        return {
-            pass: true
-        };
-    },
-    /**
-     *
-     * @param {BinaryNode} container
-     * @param node
-     */
-    toContainNode(container, node) {
-        let found = false;
-        let message;
-        container.traversePreOrderUsingStack(function (n) {
-            if (n === node) {
-                found = true;
-                //stop traversal
-                return false;
-            }
-        });
-
-        if (!found) {
-            message = `node is not contained within the tree`;
-        }
-
-        return {
-            message,
-            pass: found
-        };
-    }
-});
-
-/**
- *
- * @param {number} v0
- * @param {number} v1
- * @param {*} [value]
- * @returns {LeafNode}
- */
-function leaf(v0, v1, value) {
-    const leafNode = new LeafNode(value, v0, v0, v0, v1, v1, v1);
-    return leafNode;
-}
-
-/**
- *
- * @param {NodeDescription} left
- * @param {NodeDescription} right
- * @returns {BinaryNode}
- */
-function pair(left, right) {
-    const node = new BinaryNode();
-
-    if (left === null) {
-        node.right = right;
-        right.parentNode = node;
-        node.refit();
-    } else if (right === null) {
-        node.left = left;
-        left.parentNode = left;
-        node.refit();
-    } else {
-        node.setChildren(left, right);
-    }
-    return node;
-}
-
-
-describe.skip("suite", () => {
-
-
-    test("empty node", () => {
-        const node = new BinaryNode();
-        node.setInfiniteBounds();
-
-        optimize(node, 100);
-
-        expect(node.left).toBeNull();
-        expect(node.right).toBeNull();
-    });
-
-    test("does nothing on optimal 2 child tree", () => {
-        const a = leaf(0, 1, "hello");
-        const b = leaf(2, 3, "goodbye");
-
-        const root = pair(a, b);
-
-        const optimized = optimize(root, 100);
-        expect(optimized).toBe(0);
-
-        //positions preserved
-        expect(root.left.object).toEqual(a.object);
-        expect(root.right.object).toEqual(b.object);
-
-        //parent node is root
-        expect(root.left.parentNode).toEqual(root);
-        expect(root.right.parentNode).toEqual(root);
-
-        expect(root).toBeValid();
-    });
-
-    test("does nothing on optimal depth 2 tree", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const n0 = pair(a, b);
-        const n1 = pair(c, d);
-
-        const root = pair(n0, n1);
-
-        const optimized = optimize(root, 100);
-        expect(optimized).toBe(0);
-
-        expect(root.parentNode).toBeNull();
-
-        expect(root.left).toBe(n0);
-        expect(root.right).toBe(n1);
-
-        expect(n0.left).toBe(a);
-        expect(n0.right).toBe(b);
-
-        expect(n1.left).toBe(c);
-        expect(n1.right).toBe(d);
-
-        expect(root).toBeValid();
-    });
-
-    test("produces a valid tree from left-leaning tree with 4 leaves", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const root = pair(
-            pair(
-                pair(c, d),
-                b
-            ),
-            a
-        );
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        expect(root).toContainNode(a);
-        expect(root).toContainNode(b);
-        expect(root).toContainNode(c);
-        expect(root).toContainNode(d);
-    });
-
-    test("produces a valid tree from right-leaning tree with 4 leaves", () => {
-        const a = leaf(-2, -1, "a");
-        const b = leaf(-1, 0, "b");
-        const c = leaf(0, 1, "c");
-        const d = leaf(1, 2, "d");
-
-        const root = pair(
-            a,
-            pair(
-                b,
-                pair(c, d)
-            )
-        );
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        expect(root).toContainNode(a);
-        expect(root).toContainNode(b);
-        expect(root).toContainNode(c);
-        expect(root).toContainNode(d);
-    });
-
-    test("100 node random tree optimization does not degrade quality", () => {
-        const random = seededRandom(42);
-
-        const nodes = [];
-
-        for (let i = 0; i < 100; i++) {
-            const x0 = random() * 100;
-            const y0 = random() * 100;
-            const z0 = random() * 100;
-
-            const x1 = x0 + random() * 5;
-            const y1 = y0 + random() * 5;
-            const z1 = z0 + random() * 5;
-
-            nodes.push(new LeafNode(i, x0, y0, z0, x1, y1, z1));
-        }
-
-        while (nodes.length >= 2) {
-            const left = nodes.pop();
-            const right = nodes.pop();
-            nodes.unshift(pair(left, right));
-        }
-
-        const root = nodes[0];
-
-        const oldSAH = root.computeSAH();
-
-        optimize(root, 100);
-
-        expect(root).toBeValid();
-
-        const newSAH = root.computeSAH();
-
-        //at least not degraded
-        expect(newSAH).toBeLessThanOrEqual(oldSAH);
-    });
-
-    test("case 0:  4 node tree optimization does not degrade quality", () => {
-        const ll = new LeafNode("ll",
-            76.06244471671744,
-            7.73902752171125,
-            1.925105413576489,
-            94.49883157197291,
-            50.63123012084361,
-            76.75841101302467
-        );
-
-        const lr = new LeafNode("lr",
-            76.11310176957886,
-            58.65097077867176,
-            11.346076624795387,
-            97.55653706044541,
-            89.91247777413719,
-            90.73181902923352
-        );
-
-        const rl = new LeafNode("rl",
-            32.4771196630536,
-            0.9366270797727339,
-            1.378434756588831,
-            66.71670340545461,
-            99.32784918828929,
-            97.52435446605432
-        );
-
-        const rr = new LeafNode("rr",
-            1.124263022938976,
-            0.13232239543867763,
-            2.702786005283997,
-            31.51776058888572,
-            94.87720282424561,
-            101.03932220629758
-        );
-
-        const root = pair(pair(ll, lr), pair(rl, rr));
-
-        expect(root).toBeValid();
-
-        const oldSAH = root.computeSAH();
-
-        optimize(root, 1000);
-
-        expect(root).toBeValid();
-
-        const newSAH = root.computeSAH();
-
-        //at least not degraded
-        expect(newSAH).toBeLessThanOrEqual(oldSAH);
-    });
-
-})