@woosh/meep-engine 2.67.0 → 2.68.0

package/src/core/bvh2/BinaryNode.js

@@ -1,1188 +0,0 @@
-/**
- * Created by Alex on 17/11/2014.
- */
-
-
-import { assert } from "../assert.js";
-import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
-import { aabb3_box_surface_area_2 } from "../geom/3d/aabb/aabb3_box_surface_area_2.js";
-import { aabb3_combined_surface_area } from "../geom/3d/aabb/aabb3_combined_surface_area.js";
-import { aabb3_intersects_aabb3 } from "../geom/3d/aabb/aabb3_intersects_aabb3.js";
-import { max2 } from "../math/max2.js";
-import { min2 } from "../math/min2.js";
-import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { isLeaf, LeafNode } from "./LeafNode.js";
-import { Node } from "./Node.js";
-import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
-import { BVHVisitor } from "./traversal/BVHVisitor.js";
-import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUsingVisitor.js";
-
-
-/**
- * @callback BinaryNode~Visitor
- * @param {Node} node
- * @returns {boolean} flag, controls traversal of descendants. If false - no traversal is done over descendants
- */
-
-
-/**
- *
- * @type {number}
- */
-let stackPointer = 0;
-/**
- *
- * @type {Node[]}
- */
-const stack = [];
-
-/**
- * @deprecated use {@link BVH} instead
- */
-export class BinaryNode extends Node {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {null|BinaryNode|LeafNode}
-         */
-        this.parentNode = null;
-
-        /**
-         *
-         * @type {null|Node|LeafNode|BinaryNode}
-         */
-        this.left = null;
-
-        /**
-         *
-         * @type {null|Node|LeafNode|BinaryNode}
-         */
-        this.right = null;
-
-        /**
-         * Number of leaf nodes in the hierarchy
-         * @deprecated
-         * @type {number}
-         * @private
-         */
-        this.leafNodeCount = 0;
-
-        /**
-         * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
-         * @type {number}
-         */
-        this.height = 0;
-    }
-
-    /**
-     * Same as traversePreOrder but without recursion. This runs faster thanks to avoidance of function call overhead. Especially useful for deeper trees.
-     * @param {BinaryNode~Visitor} visitor
-     * @param [thisArg]
-     * @deprecated use visitor-based traversal instead of callback-based
-     */
-    traversePreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
-
-        const stackOffset = stackPointer;
-
-        stack[stackPointer++] = this;
-        let n;
-        while (stackPointer-- > stackOffset) {
-
-            visitCount++;
-
-            n = stack[stackPointer];
-
-            const traverseDeeper = visitor.call(thisArg, n);
-
-            if (traverseDeeper !== false && n.isBinaryNode) {
-                if (n.right !== null) {
-                    stack[stackPointer++] = n.right;
-                }
-                if (n.left !== null) {
-                    stack[stackPointer++] = n.left;
-                }
-            }
-        }
-
-        // drop stack frame
-        stackPointer = stackOffset;
-
-        return visitCount;
-    }
-
-    /**
-     * Traverse leaf nodes in a fast manner
-     * @param {function(node:LeafNode)} visitor
-     * @param {*} [thisArg]
-     */
-    traverseLeavesPreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
-
-        const stackOffset = stackPointer;
-
-        stack[stackPointer++] = this;
-
-        let n;
-
-        while (stackPointer-- > stackOffset) {
-
-            visitCount++;
-
-            n = stack[stackPointer];
-
-            if (n.isLeafNode) {
-                visitor.call(thisArg, n);
-            } else {
-                //a binary node
-                if (n.right !== null) {
-                    stack[stackPointer++] = n.right;
-                }
-                if (n.left !== null) {
-                    stack[stackPointer++] = n.left;
-                }
-            }
-        }
-
-        // drop stack frame
-        stackPointer = stackOffset;
-
-        return visitCount;
-    }
-
-
-    /**
-     * Contains no children
-     * @returns {boolean}
-     */
-    isEmpty() {
-        return this.left === null && this.right === null;
-    }
-
-    reset() {
-        this.left = null;
-        this.right = null;
-
-        this.leafNodeCount = 0;
-        this.height = 0;
-
-        this.setNegativelyInfiniteBounds();
-    }
-
-    /**
-     *
-     * @param {Node|BinaryNode} left
-     * @param {Node|BinaryNode} right
-     */
-    setChildren(left, right) {
-        this.left = left;
-        this.right = right;
-
-        left.parentNode = this;
-        right.parentNode = this;
-    }
-
-    /**
-     *
-     * @param {Node} child
-     */
-    setChildLeft(child) {
-        assert.isNull(this.left, 'left');
-
-        this.left = child;
-        child.parentNode = this;
-    }
-
-    /**
-     *
-     * @param {Node} child
-     */
-    setChildRight(child) {
-        assert.isNull(this.right, 'right');
-
-        this.right = child;
-        child.parentNode = this;
-    }
-
-    /**
-     * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
-     * @see https://github.com/erincatto/box2d/blob/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb/src/collision/b2_dynamic_tree.cpp#L197
-     * @private
-     * @param {AABB3} box
-     * @returns {BinaryNode|LeafNode}
-     */
-    __insertion_findSiblingFor(box) {
-
-        let node = this;
-        let cost_left = 0;
-        let cost_right = 0;
-
-        while (node.isBinaryNode === true) {
-            const left = node.left;
-            const right = node.right;
-
-            const area = aabb3_box_surface_area_2(node);
-
-            const combined_area = aabb3_combined_surface_area(node, box);
-
-            //cost of creating a new parent for this node and the new leaf
-            const cost = combined_area;
-
-            // minimum cost of pushing the leaf further down the tree
-            const inheritance_cost = combined_area - area;
-
-            // cost of descending left
-            if (left !== null) {
-                const combined_left = aabb3_combined_surface_area(left, box);
-                if (left.isLeafNode) {
-                    cost_left = combined_left + inheritance_cost;
-                } else {
-                    cost_left = combined_left - aabb3_box_surface_area_2(left) + inheritance_cost;
-                }
-            } else {
-                cost_left = Infinity;
-            }
-
-            // cost of descending right
-            if (right !== null) {
-
-                const combined_right = aabb3_combined_surface_area(right, box);
-                if (right.isLeafNode) {
-                    cost_right = combined_right + inheritance_cost;
-                } else {
-                    cost_right = combined_right - aabb3_box_surface_area_2(right) + inheritance_cost;
-                }
-            } else {
-                cost_right = Infinity;
-            }
-
-            if (cost < cost_left && cost < cost_right) {
-                // descending either branch is too expensive
-                break;
-            }
-
-            if (cost_left < cost_right && left !== null) {
-                node = left;
-            } else if (right !== null) {
-                node = right;
-            } else {
-                break;
-            }
-        }
-
-        return node;
-    }
-
-    /**
-     *
-     * @param {AABB3} box
-     * @returns {Node|BinaryNode|LeafNode}
-     */
-    findParentFor(box) {
-        let n = this;
-        let aCost = 0;
-        let bCost = 0;
-
-        for (; ;) {
-
-            const a = n.left;
-            const b = n.right;
-
-            if (a === null || b === null) {
-                //unbalanced node, good candidate already
-                return n;
-            }
-
-            const aIsBinary = a.isBinaryNode;
-            const bIsBinary = b.isBinaryNode;
-
-            aCost = a.costForInclusion(box);
-            bCost = b.costForInclusion(box);
-
-            if (aCost === bCost) {
-
-                if (a.isLeafNode) {
-
-                    return a;
-
-                } else if (b.isLeafNode) {
-
-                    return b;
-
-                }
-
-                //change costs to be based on balance
-                aCost = a.leafNodeCount / aabb3_box_surface_area_2(a);
-                bCost = b.leafNodeCount / aabb3_box_surface_area_2(b);
-            }
-
-            if (aCost === bCost) {
-                //still the same, toss a coin
-                aCost = Math.random();
-                bCost = 1 - aCost;
-            }
-
-            if (aCost < bCost) {
-                if (aIsBinary) {
-                    n = a;
-                } else {
-                    return a;
-                }
-            } else {
-                if (bIsBinary) {
-                    n = b;
-                } else {
-                    return b;
-                }
-            }
-        }
-    }
-
-    traverse(visitor) {
-        if (this.left !== null) {
-            const cA = visitor(this.left);
-            if (cA !== false) {
-                this.left.traverse(visitor);
-            }
-        }
-        if (this.right !== null) {
-            const cB = visitor(this.right);
-            if (cB !== false) {
-                this.right.traverse(visitor);
-            }
-        }
-    }
-
-    /**
-     * Bottom-up tree traversal, children first
-     * @param visitor
-     */
-    traversePostOrder(visitor) {
-        //left
-        if (this.left instanceof BinaryNode) {
-            this.left.traversePostOrder(visitor);
-        } else if (this.left instanceof LeafNode) {
-            visitor(this.left);
-        }
-        //right
-        if (this.right instanceof BinaryNode) {
-            this.right.traversePostOrder(visitor);
-        } else if (this.right instanceof LeafNode) {
-            visitor(this.right);
-        }
-        visitor(this);
-    }
-
-    traversePreOrder(visitor) {
-        const carryOn = visitor(this);
-        if (carryOn !== false) {
-            //left
-            if (this.left instanceof BinaryNode) {
-                this.left.traversePreOrder(visitor);
-            } else if (this.left instanceof LeafNode) {
-                visitor(this.left);
-            }
-            //right
-            if (this.right instanceof BinaryNode) {
-                this.right.traversePreOrder(visitor);
-            } else if (this.right instanceof LeafNode) {
-                visitor(this.right);
-            }
-        }
-    }
-
-    refitFor2() {
-        const a = this.left;
-        const b = this.right;
-
-        const x0 = min2(a.x0, b.x0);
-        const y0 = min2(a.y0, b.y0);
-        const z0 = min2(a.z0, b.z0);
-
-        const x1 = max2(a.x1, b.x1);
-        const y1 = max2(a.y1, b.y1);
-        const z1 = max2(a.z1, b.z1);
-
-        this.setBounds(x0, y0, z0, x1, y1, z1);
-    }
-
-    bubbleRefit() {
-        let n = this;
-
-        n.refit();
-
-        //bubble up
-        for (; ;) {
-            //record old node size
-            const _x0 = n.x0;
-            const _y0 = n.y0;
-            const _z0 = n.z0;
-            const _x1 = n.x1;
-            const _y1 = n.y1;
-            const _z1 = n.z1;
-
-            n = n.parentNode;
-
-            if (n === null) {
-                // hit the root
-                return;
-            }
-
-
-            //check if this node violates bounds of the parent
-            let flag = false;
-
-            if (_x0 < n.x0) {
-                n.x0 = _x0;
-                flag = true;
-            }
-            if (_y0 < n.y0) {
-                n.y0 = _y0;
-                flag = true;
-            }
-            if (_z0 < n.z0) {
-                n.z0 = _z0;
-                flag = true;
-            }
-
-            if (_x1 > n.x1) {
-                n.x1 = _x1;
-                flag = true;
-            }
-            if (_y1 > n.y1) {
-                n.y1 = _y1;
-                flag = true;
-            }
-            if (_z1 > n.z1) {
-                n.z1 = _z1;
-                flag = true;
-            }
-
-            if (!flag) {
-                //no violation, we can stop here
-                break;
-            }
-        }
-    }
-
-    refit() {
-        if (this.left !== null && this.right !== null) {
-            this.refitFor2();
-        } else if (this.left !== null) {
-            this.copy(this.left);
-        } else if (this.right !== null) {
-            this.copy(this.right);
-        }
-    }
-
-    sumSurfaceArea() {
-        let result = 0;
-        this.traversePreOrderUsingStack(function (node) {
-            const nodeArea = node.computeSurfaceArea();
-            result += nodeArea;
-        });
-
-        return result;
-    }
-
-    countDescendants() {
-        let result = 0;
-        this.traversePreOrderUsingStack(function (node) {
-            result++;
-        });
-        return result;
-    }
-
-    /**
-     * @deprecated Incorrect usage of SAH
-     * @return {number}
-     */
-    computeSAH() {
-        let leftLeaves, rightLeaves, leftArea, rightArea;
-
-        const left = this.left;
-
-        if (left === null) {
-            leftArea = 0;
-            leftLeaves = 0;
-        } else {
-            leftArea = aabb3_box_surface_area_2(left);
-            leftLeaves = left.leafNodeCount;
-        }
-
-        const right = this.right;
-        if (right === null) {
-            rightArea = 0;
-            rightLeaves = 0;
-        } else {
-            rightArea = aabb3_box_surface_area_2(right);
-            rightLeaves = right.leafNodeCount;
-        }
-
-        const thisArea = aabb3_box_surface_area_2(this);
-
-        return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
-    }
-
-    updateHeight() {
-        let node = this;
-        let n = 0;
-
-        while (node !== null) {
-            n = 0;
-
-            const right = node.right;
-
-            if (right !== null) {
-                n = right.height;
-            }
-
-            const left = this.left;
-
-            if (left !== null) {
-                n = max2(n, left.height);
-            }
-
-            node.height = n + 1;
-
-            // propagate update up the tree
-            node = node.parentNode;
-        }
-    }
-
-    /**
-     * @deprecated
-     */
-    updateLeafNodeCount() {
-        let node = this;
-
-        while (node !== null) {
-            let n = 0;
-
-            const right = node.right;
-
-            if (right !== null) {
-                if (right.isLeafNode) {
-                    n++;
-                } else {
-                    n += right.leafNodeCount;
-                }
-            }
-
-            const left = this.left;
-
-            if (left !== null) {
-                if (left.isLeafNode) {
-                    n++;
-                } else {
-                    n += left.leafNodeCount;
-                }
-            }
-
-            node.leafNodeCount = n;
-
-            // propagate update up the tree
-            node = node.parentNode;
-        }
-
-    }
-
-    /**
-     * As a result of rotation, this node 'becomes' the right node, and left node get's replaced by the right node with necessary adjustments
-     */
-    rotateLeft() {
-
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        const r = this.right;
-
-        const l = this.left;
-
-        const rL = r.left;
-        const rR = r.right;
-
-        this.left = r;
-        this.right = rR;
-
-        if (rR !== null) {
-            rR.parentNode = this;
-        }
-
-        r.left = l;
-        if (l !== null) {
-            l.parentNode = r;
-        }
-
-        r.right = rL;
-
-        r.updateLeafNodeCount();
-        r.updateHeight();
-
-        r.bubbleRefit();
-    }
-
-    rotateRight() {
-        const r = this.right;
-
-        const left = this.left;
-
-        const lL = left.left;
-        const lR = left.right;
-
-        if (lL !== null) {
-            lL.parentNode = this;
-        }
-
-        left.right = r;
-        if (r !== null) {
-            r.parentNode = left;
-        }
-
-        left.left = lR;
-
-        left.updateLeafNodeCount();
-        left.updateHeight();
-
-        left.bubbleRefit();
-    }
-
-    /**
-     *
-     * @param {function(index:int):LeafNode} leafFactory
-     * @param {int} numNodes
-     */
-    insertManyBoxes2(leafFactory, numNodes) {
-        let i, n;
-        //create leaf nodes
-        const nodes = new Array(numNodes);
-
-        for (i = 0; i < numNodes; i++) {
-            //leaf needs to be set up inside the callback
-            n = leafFactory(i);
-
-            nodes[i] = n;
-        }
-
-        //sort leaves
-        arrayQuickSort(nodes, n => n.computeMortonCode(), null, 0, max2(0, numNodes - 1));
-
-        let remaining_nodes = numNodes;
-
-        while (remaining_nodes > 2) {
-
-            //pair
-            for (i = 0; i < remaining_nodes - 1; i += 2) {
-                const a = nodes[i];
-                const b = nodes[i + 1];
-
-                n = new BinaryNode();
-
-                n.setChildren(a, b);
-
-                n.updateHeight();
-                n.refitFor2();
-
-                nodes[i >> 1] = n;
-            }
-
-            const numNodesMod2 = remaining_nodes & 1; //faster version of %2
-
-            if (numNodesMod2 !== 0) {
-                //shift remaining node up so it will be considered later
-                nodes[i >> 1] = nodes[i];
-            }
-
-            remaining_nodes = (remaining_nodes >> 1) + numNodesMod2;
-        }
-
-        //finally insert these boxes from this node
-        for (i = 0; i < remaining_nodes; i++) {
-            n = nodes[i];
-            this.insertNode(n);
-        }
-    }
-
-    /**
-     *
-     * @param {LeafNode[]} result destination
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     * @returns {number} number of objects added to the result
-     */
-    requestLeafIntersectionsAABB3(result, x0, y0, z0, x1, y1, z1) {
-        const startOffset = stackPointer;
-
-        stack[stackPointer++] = this;
-
-        let count = 0;
-
-        while (stackPointer > startOffset) {
-            stackPointer--;
-            const node = stack[stackPointer];
-
-            if (!aabb3_intersects_aabb3(
-                x0, y0, z0, x1, y1, z1,
-                node.x0, node.y0, node.z0, node.x1, node.y1, node.z1
-            )) {
-                //no overlap
-                continue;
-            }
-
-            if (node.isLeafNode) {
-                result[count++] = node;
-
-                count++;
-            } else {
-                const left = node.left;
-                if (left !== null) {
-                    stack[stackPointer++] = left;
-                }
-
-                const right = node.right;
-                if (right !== null) {
-                    stack[stackPointer++] = right;
-                }
-            }
-        }
-
-        return count;
-    }
-
-    traverseSegmentLeafIntersections(startX, startY, startZ, endX, endY, endZ, visitor) {
-        this.traversePreOrder(function (node) {
-            let b = node.intersectSegment(startX, startY, startZ, endX, endY, endZ);
-            if (!b) {
-                return false;
-            }
-            if (node instanceof LeafNode) {
-                visitor(node);
-                return false;
-            } else {
-                return true;
-            }
-        });
-    }
-
-    /**
-     *
-     * @param {Frustum[]} frustums Collection of THREE.js Frustums
-     * @param {function(node:LeafNode, boolean)} visitor
-     * @returns {number}
-     * @deprecated Use {@link ThreeFrustumsIntersectionBVHVisitor}
-     */
-    threeTraverseFrustumsIntersections(frustums, visitor) {
-        const numFrustums = frustums.length;
-
-        /**
-         *
-         * @param {LeafNode|BinaryNode} node
-         * @returns {boolean}
-         */
-        function visitNode(node) {
-            let b = false;
-            let i = 0;
-
-            for (; i < numFrustums; i++) {
-
-                const degree = node.intersectFrustumDegree(frustums[i]);
-
-                if (degree === 2) {
-                    //completely inside frustum
-
-                    if (node.isLeafNode) {
-                        visitor(node, true);
-                    } else {
-                        node.traverseLeavesPreOrderUsingStack(fastVisitLeafNodeIntersection, visitor);
-                    }
-
-                    //prevent further traversal
-                    return false;
-
-                } else if (degree === 1) {
-
-                    //partially inside frustum
-                    b = true;
-
-                }
-            }
-
-            if (!b) {
-                return false;
-            }
-
-            if (node.isLeafNode) {
-                visitor(node, false);
-            }
-
-            return true;
-        }
-
-        return this.traversePreOrderUsingStack(visitNode);
-    }
-
-    /**
-     * As recursion goes on, we remove frustums and planes from checks reducing total number of checks necessary
-     * @param {Array.<THREE.Frustum>} frustums
-     * @param {function} visitor
-     * @returns {number}
-     */
-    threeTraverseFrustumsIntersections2(frustums, visitor) {
-        const numFrustums = frustums.length;
-
-        function visitLeaves(node) {
-            if (node instanceof LeafNode) {
-                visitor(node);
-                return false;
-            } else {
-                return true;
-            }
-        }
-
-        function fastTraverseLeaves(node) {
-            if (node instanceof LeafNode) {
-                visitor(node);
-            } else {
-                node.traversePreOrderUsingStack(visitLeaves);
-            }
-        }
-
-
-        function isFlagSet(mask, index) {
-            return mask & (1 << index) !== 0;
-        }
-
-        function clearFlag(mask, index) {
-            return mask & ~(1 << index);
-        }
-
-        function removeElementFromClone(original, clone, mask, originalIndex) {
-            if (clone === original) {
-                //clone planes
-                clone = clone.slice();
-            }
-            //remove the plane from new set
-            clone.splice(originalIndex, 1);
-            return clone;
-        }
-
-        function processVolumesIntersections(node, planeSets, planeSetCount) {
-            let newPlaneSets = planeSets;
-            for (let iPS = planeSetCount - 1; iPS >= 0; iPS--) {
-
-                const planes = planeSets[iPS];
-                let newPlanes = planes;
-                const numPlanes = planes.length;
-
-                //check plane set
-                for (let i = numPlanes - 1; i >= 0; i--) {
-                    const plane = planes[i];
-                    const planeSide = node.computePlaneSide(plane);
-                    if (planeSide < 0) {
-                        //completely inside
-                        newPlanes = removeElementFromClone(planes, newPlanes, i);
-                    } else if (planeSide > 0) {
-                        //on the wrong side of the plane
-                        //drop plane set
-                        newPlaneSets = removeElementFromClone(planeSets, newPlaneSets, iPS);
-
-                        break;
-                    }
-                }
-
-                //update plane sets as needed
-                if (newPlanes !== planes && newPlaneSets.indexOf(planes) !== -1) {
-                    //replace
-                    if (newPlaneSets === planeSets) {
-                        //clone if needed
-                        newPlaneSets = newPlaneSets.slice();
-                    }
-                    newPlaneSets[iPS] = newPlanes;
-                }
-            }
-
-            return newPlaneSets;
-        }
-
-        function traverseVolumeIntersections(node, planeSets, numPlaneSets) {
-            function internalVisitor(node) {
-                let newPlaneSet = processVolumesIntersections(node, planeSets, numPlaneSets);
-                if (newPlaneSet !== planeSets) {
-                    let newPlaneSetCount = newPlaneSet.length;
-                    if (newPlaneSetCount !== 0) {
-                        //some intersections
-
-                        //check if all plane sets are trivial (contain no test planes)
-                        let trivialPlaneSets = 0;
-                        for (let i = 0; i < newPlaneSetCount; i++) {
-                            if (newPlaneSet[i].length === 0) {
-                                trivialPlaneSets++;
-                            }
-                        }
-
-                        if (isLeaf(node)) {
-                            visitor(node);
-                        } else {
-                            if (trivialPlaneSets === newPlaneSetCount) {
-                                fastTraverseLeaves(node);
-                            } else {
-                                traverseVolumeIntersections(node, newPlaneSet, newPlaneSetCount);
-                            }
-                        }
-                    }
-                } else {
-                    if (isLeaf(node)) {
-                        visitor(node);
-                    } else {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            node.traversePreOrderUsingStack(internalVisitor);
-        }
-
-        function startTraversal(node) {
-            let planeSets = [];
-            for (let i = 0; i < numFrustums; i++) {
-                const frustum = frustums[i];
-                const planes = frustum.planes;
-                planeSets.push(planes);
-            }
-            traverseVolumeIntersections(node, planeSets, numFrustums);
-        }
-
-        startTraversal(this);
-    }
-
-    /**
-     *
-     * @param {number} startX
-     * @param {number} startY
-     * @param {number} startZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     * @param {function(node:LeafNode)} visitor
-     * @param thisArg
-     * @deprecated use {@link RaycastBVHVisitor} instead
-     */
-    traverseRayLeafIntersections(startX, startY, startZ, directionX, directionY, directionZ, visitor, thisArg) {
-        this.traversePreOrderUsingStack(function (node) {
-            let b = node.intersectRay(startX, startY, startZ, directionX, directionY, directionZ);
-
-            if (!b) {
-                //no intersection, terminate this branch
-                return false;
-            }
-
-            if (isLeaf(node)) {
-                //leaf node, supply to visitor
-                visitor.call(thisArg, node);
-                return false;
-            } else {
-                //intermediate node, continue traversal
-                return true;
-            }
-        });
-    }
-
-    /**
-     * Fraction of balanced nodes in the tree (those that have both children)
-     * @returns {number}
-     */
-    computeBalanceFactor() {
-
-        const bvhVisitor = new BVHVisitor();
-
-
-        const depths = [];
-
-        bvhVisitor.visitLeaf = (leaf) => {
-            const depth = leaf.computeDepth();
-
-            depths.push(depth);
-        };
-
-        traverseBinaryNodeUsingVisitor(this, bvhVisitor)
-
-        if (depths.length === 0) {
-            return 1;
-        } else {
-            return computeSampleStandardDeviation(depths);
-        }
-
-    }
-
-    /**
-     * @template T
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     * @param {T} value
-     * @returns {LeafNode}
-     */
-    insert(x0, y0, z0, x1, y1, z1, value) {
-        const leaf = new LeafNode(value, x0, y0, z0, x1, y1, z1);
-        this.insertNode(leaf);
-        return leaf;
-    }
-
-    /**
-     *
-     * @param {Node|BinaryNode|LeafNode} child
-     */
-    insertNode(child) {
-
-        assert.notNull(child, "child");
-        assert.defined(child, "child");
-        assert.isInstanceOf(child, Node, 'child', "Node");
-        assert.equal(child.parentNode, null, "parentNode must be null, otherwise Node still belongs to another tree");
-
-        const sibling = this.__insertion_findSiblingFor(child);
-
-        let parent = sibling.parentNode;
-
-        if (parent === null) {
-            // "sibling" is the root node
-
-            parent = sibling;
-
-            if (sibling.left === null) {
-                sibling.setChildLeft(child);
-            } else if (sibling.right === null) {
-                sibling.setChildRight(child);
-            } else {
-                parent = new BinaryNode();
-
-                parent.setChildren(sibling.right, child);
-                sibling.right = parent;
-                parent.parentNode = sibling;
-            }
-
-        } else {
-
-            // non-root
-
-            if (parent.left === sibling && parent.right === null) {
-
-                // right node is free, take it
-                parent.setChildRight(child);
-
-            } else if (parent.right === sibling && parent.left === null) {
-
-                // left node is free, take it
-                parent.setChildLeft(child);
-
-            } else {
-
-                parent = transplantNewCommonParent(sibling, child)
-
-            }
-
-        }
-
-        // walk back up the tree fixing heights and bounds
-        do {
-            // parent = this.balance();
-
-            const left = parent.left;
-            const right = parent.right;
-
-            parent.height = 1 + max2(left !== null ? left.height : 0, right !== null ? right.height : 0);
-            parent.refit();
-
-            parent = parent.parentNode;
-        } while (parent !== null);
-    }
-
-    /**
-     * @param {boolean} deep
-     * @returns {BinaryNode}
-     */
-    clone(deep = false) {
-        const clone = new BinaryNode();
-
-        clone.x0 = this.x0;
-        clone.y0 = this.y0;
-        clone.z0 = this.z0;
-        clone.x1 = this.x1;
-        clone.y1 = this.y1;
-        clone.z1 = this.z1;
-
-        clone.leafNodeCount = this.leafNodeCount;
-
-        clone.parentNode = this.parentNode;
-
-        if (deep === true) {
-            if (this.left !== null) {
-                clone.left = this.left.clone(true);
-                clone.left.parentNode = clone;
-            }
-            if (this.right !== null) {
-                clone.right = this.right.clone(true);
-                clone.right.parentNode = clone;
-            }
-        } else {
-            clone.left = this.left;
-            clone.right = this.right;
-        }
-
-        clone.modifiers = this.modifiers;
-
-        return clone;
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-BinaryNode.prototype.isBinaryNode = true;
-
-/**
- * @private
- * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly
- * @param {LeafNode} node
- */
-function fastVisitLeafNodeIntersection(node) {
-    this(node, true);
-}
-
-/**
- *
- * @param {Node} node
- * @param {Node} child
- * @return {BinaryNode}
- */
-function transplantNewCommonParent(node, child) {
-    const bNode = new BinaryNode();
-
-    //
-    const parent = node.parentNode;
-    if (node === parent.left) {
-        parent.left = bNode;
-    } else if (node === parent.right) {
-        parent.right = bNode;
-    } else {
-        throw new Error("Not a child of specified parent node(impostor)");
-    }
-
-    bNode.setChildren(node, child);
-    bNode.parentNode = parent;
-
-    return bNode;
-}
-