@woosh/meep-engine 2.34.33 → 2.34.37

package/core/bvh2/BinaryNode.js

@@ -8,7 +8,7 @@ import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { aabb3_intersect_aabb3, boxSurfaceArea2 } from "./aabb3/AABB3Math.js";
+import { _boxSurfaceArea2, aabb3_intersect_aabb3, boxSurfaceArea2 } from "./aabb3/AABB3Math.js";
 import { isLeaf, LeafNode } from "./LeafNode.js";
 import { Node } from "./Node.js";
 import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
@@ -25,1021 +25,1137 @@ import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUs
 
 /**
  *
- * @enum {int}
+ * @type {number}
  */
-const ModifierType = {
-    Protected: 1,
-    Marked1: 2,
-    Marked2: 4,
-    Marked3: 8
-};
-
+let stackPointer = 0;
 /**
- * @extends {Node}
- * @constructor
+ *
+ * @type {Node[]}
  */
-const BinaryNode = function () {
+const stack = [];
+
+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
+         * @type {number}
+         * @private
+         */
+        this.leafNodeCount = 0;
+    }
+
     /**
-     *
-     * @type {null|BinaryNode|LeafNode}
+     * 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
      */
-    this.parentNode = null;
+    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;
+    }
 
     /**
-     *
-     * @type {null|Node|LeafNode|BinaryNode}
+     * Traverse leaf nodes in a fast manner
+     * @param {function(node:LeafNode)} visitor
+     * @param {*} [thisArg]
      */
-    this.left = null;
+    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;
+        }
+
+
     /**
-     *
-     * @type {null|Node|LeafNode|BinaryNode}
+     * Contains no children
+     * @returns {boolean}
      */
-    this.right = null;
+    isEmpty() {
+        return this.left === null && this.right === null;
+    }
+
+    reset() {
+        this.left = null;
+        this.right = null;
 
-    this.modifiers = 0;
+        this.leafNodeCount = 0;
+
+        this.setNegativelyInfiniteBounds();
+    }
 
     /**
-     * Number of leaf nodes in the hierarchy
-     * @type {number}
+     *
+     * @param {Node|BinaryNode} left
+     * @param {Node|BinaryNode} right
      */
-    this.leafNodeCount = 0;
+    setChildren(left, right) {
+        this.left = left;
+        this.right = right;
 
-    this.x0 = 0;
-    this.y0 = 0;
-    this.z0 = 0;
+        this.updateLeafNodeCount()
 
-    this.x1 = 0;
-    this.y1 = 0;
-    this.z1 = 0;
-};
+        this.refitFor2();
 
-BinaryNode.Modifier = ModifierType;
+        left.parentNode = this;
+        right.parentNode = this;
+    }
 
-BinaryNode.prototype = Object.create(Node.prototype);
+    /**
+     *
+     * @param {Node} child
+     */
+    setChildLeft(child) {
+        assert.isNull(this.left, 'left');
 
-/**
- * @readonly
- * @type {boolean}
- */
-BinaryNode.prototype.isBinaryNode = true;
+        this.left = child;
 
-/**
- *
- * @param {int} modifier
- * @param {boolean} flag
- */
-BinaryNode.prototype.setModifier = function (modifier, flag) {
-    if (flag) {
-        this.modifiers |= modifier;
-    } else {
-        this.modifiers &= ~modifier;
+        this.updateLeafNodeCount();
+
+        this.refit();
+
+        child.parentNode = this;
     }
-};
 
-BinaryNode.prototype.isModifierSet = function (modifier) {
-    return (this.modifiers & modifier) !== 0;
-};
+    /**
+     *
+     * @param {Node} child
+     */
+    setChildRight(child) {
+        assert.isNull(this.right, 'right');
 
-BinaryNode.prototype.isProtected = function () {
-    return this.isModifierSet(ModifierType.Protected);
-};
+        this.right = child;
 
-/**
- * Contains no children
- * @returns {boolean}
- */
-BinaryNode.prototype.isEmpty = function () {
-    return this.left === null && this.right === null;
-}
+        this.updateLeafNodeCount();
 
+        this.refit();
 
-BinaryNode.prototype.reset = function () {
-    this.left = null;
-    this.right = null;
+        child.parentNode = this;
+    }
 
-    this.leafNodeCount = 0;
+    /**
+     * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
+     * @param {AABB3} box
+     * @returns {BinaryNode|LeafNode}
+     */
+    __insertion_findSiblingFor(box) {
 
-    this.setNegativelyInfiniteBounds();
-};
+        const open_set = [this];
+        let cursor = 1;
 
-/**
- *
- * @param {Node|BinaryNode} left
- * @param {Node|BinaryNode} right
- */
-BinaryNode.prototype.setChildren = function (left, right) {
-    this.left = left;
-    this.right = right;
+        let best_cost = Infinity;
+        let best_node = this;
 
-    this.updateLeafNodeCount()
+        while (cursor > 0) {
+            const node = open_set[--cursor];
 
-    this.refitFor2();
+            const cost = inclusion_surface_area_heuristic(node, box);
 
-    left.parentNode = this;
-    right.parentNode = this;
-};
+            if (cost < best_cost) {
+                best_cost = cost;
+                best_node = node;
+            }
 
-/**
- *
- * @param {AABB3} box
- * @returns {Node}
- */
-BinaryNode.prototype.findParentFor = function (box) {
-    let n = this;
+            if (node.isBinaryNode) {
+
+                // consider pushing children into the queue
+
+                // compute lower bound for cost
+                const c_low = inclusion_cost_lower_bound(node, box);
 
-    for (; ;) {
+                if (c_low < best_cost) {
+                    // worth-while to explore children
+                    if (node.left !== null) {
+                        open_set[cursor++] = node.left;
+                    }
+                    if (node.right !== null) {
+                        open_set[cursor++] = node.right
+                    }
+                }
+            }
 
-        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;
+        return best_node;
+    }
 
-        // handle protected nodes
-        if (aIsBinary && a.isProtected()) {
-            if (bIsBinary) {
-                if (b.isProtected()) {
-                    return n;
-                } else {
-                    n = b;
+    /**
+     *
+     * @param {AABB3} box
+     * @returns {Node|BinaryNode|LeafNode}
+     */
+    findParentFor(box) {
+        let n = this;
+        let aCost = 0;
+        let bCost = 0;
 
-                    continue;
-                }
-            } else {
-                return b;
-            }
-        } else if (bIsBinary && b.isProtected()) {
-            if (aIsBinary) {
-                n = a;
-            } else {
-                return a;
+        for (; ;) {
+
+            const a = n.left;
+            const b = n.right;
+
+            if (a === null || b === null) {
+                //unbalanced node, good candidate already
+                return n;
             }
-        }
 
-        let aCost = a.costForInclusion(box);
-        let bCost = b.costForInclusion(box);
+            const aIsBinary = a.isBinaryNode;
+            const bIsBinary = b.isBinaryNode;
 
-        if (aCost === bCost) {
+            aCost = a.costForInclusion(box);
+            bCost = b.costForInclusion(box);
 
-            if (a.isLeafNode) {
+            if (aCost === bCost) {
 
-                return a;
+                if (a.isLeafNode) {
 
-            } else if (b.isLeafNode) {
+                    return a;
 
-                return b;
+                } else if (b.isLeafNode) {
 
-            }
+                    return b;
 
-            //change costs to be surface areas instead
-            aCost = a.computeSAH();
-            bCost = b.computeSAH();
-        }
+                }
 
-        if (aCost === bCost) {
-            //still the same, toss a coin
-            aCost = Math.random();
-            bCost = 1 - aCost;
-        }
+                //change costs to be based on balance
+                aCost = a.leafNodeCount / boxSurfaceArea2(a);
+                bCost = b.leafNodeCount / boxSurfaceArea2(b);
+            }
 
-        if (aCost < bCost) {
-            if (aIsBinary) {
-                n = a;
-            } else {
-                return a;
+            if (aCost === bCost) {
+                //still the same, toss a coin
+                aCost = Math.random();
+                bCost = 1 - aCost;
             }
-        } else {
-            if (bIsBinary) {
-                n = b;
+
+            if (aCost < bCost) {
+                if (aIsBinary) {
+                    n = a;
+                } else {
+                    return a;
+                }
             } else {
-                return b;
+                if (bIsBinary) {
+                    n = b;
+                } else {
+                    return b;
+                }
             }
         }
     }
-};
 
-BinaryNode.prototype.traverse = function (visitor) {
-    if (this.left !== null) {
-        const cA = visitor(this.left);
-        if (cA !== false) {
-            this.left.traverse(visitor);
+    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);
+        if (this.right !== null) {
+            const cB = visitor(this.right);
+            if (cB !== false) {
+                this.right.traverse(visitor);
+            }
         }
     }
-};
 
-/**
- * Bottom-up tree traversal, children first
- * @param visitor
- */
-BinaryNode.prototype.traversePostOrder = function (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);
-};
-BinaryNode.prototype.traversePreOrder = function (visitor) {
-    const carryOn = visitor(this);
-    if (carryOn !== false) {
+    /**
+     * Bottom-up tree traversal, children first
+     * @param visitor
+     */
+    traversePostOrder(visitor) {
         //left
         if (this.left instanceof BinaryNode) {
-            this.left.traversePreOrder(visitor);
+            this.left.traversePostOrder(visitor);
         } else if (this.left instanceof LeafNode) {
             visitor(this.left);
         }
         //right
         if (this.right instanceof BinaryNode) {
-            this.right.traversePreOrder(visitor);
+            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);
+            }
+        }
+    }
 
-/**
- * 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
- */
-BinaryNode.prototype.traversePreOrderUsingStack = (function (visitor, thisArg) {
-
+    refitFor2() {
+        const a = this.left;
+        const b = this.right;
 
-    let stackPointer = 0;
-    const stack = [];
+        this.x0 = min2(a.x0, b.x0);
+        this.y0 = min2(a.y0, b.y0);
+        this.z0 = min2(a.z0, b.z0);
 
-    function cleanup(position) {
-        stack.length = position;
-        stackPointer = position;
+        this.x1 = max2(a.x1, b.x1);
+        this.y1 = max2(a.y1, b.y1);
+        this.z1 = max2(a.z1, b.z1);
     }
 
-    /**
-     * @param {BinaryNode~Visitor} visitor
-     * @param {*} [thisArg]
-     * @returns {number}
-     */
-    function traversePreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
+    bubbleRefit() {
+        let n = this;
 
-        const stackOffset = stackPointer;
+        n.refit();
 
-        stack[stackPointer++] = this;
-        let n;
-        while (stackPointer-- > stackOffset) {
+        //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;
 
-            visitCount++;
+            n = n.parentNode;
 
-            n = stack[stackPointer];
+            if (n === null) {
+                // hit the root
+                return;
+            }
 
-            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;
-                }
+            //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;
             }
-        }
 
-        cleanup(stackOffset);
+            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;
+            }
 
-        return visitCount;
+            if (!flag) {
+                //no violation, we can stop here
+                break;
+            }
+        }
     }
 
-    return traversePreOrderUsingStack;
-})();
-
-/**
- * Traverse leaf nodes in a fast manner
- * @param {function(node:LeafNode)} visitor
- * @param {*} [thisArg]
- */
-BinaryNode.prototype.traverseLeavesPreOrderUsingStack = (function (visitor, thisArg) {
+    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;
+        });
 
-    let stackPointer = 0;
-    const stack = [];
+        return result;
+    }
 
-    function cleanup(position) {
-        stack.length = position;
-        stackPointer = position;
+    countDescendants() {
+        let result = 0;
+        this.traversePreOrderUsingStack(function (node) {
+            result++;
+        });
+        return result;
     }
 
     /**
-     * @param {function(node:LeafNode)} visitor
-     * @param {*} [thisArg]
-     * @returns {number}
+     * @deprecated Incorrect usage of SAH
+     * @return {number}
      */
-    function traverseLeavesPreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
+    computeSAH() {
+        let leftLeaves, rightLeaves, leftArea, rightArea;
 
-        const stackOffset = stackPointer;
+        const left = this.left;
 
-        stack[stackPointer++] = this;
+        if (left === null) {
+            leftArea = 0;
+            leftLeaves = 0;
+        } else {
+            leftArea = boxSurfaceArea2(left);
+            leftLeaves = left.leafNodeCount;
+        }
 
-        let n;
+        const right = this.right;
+        if (right === null) {
+            rightArea = 0;
+            rightLeaves = 0;
+        } else {
+            rightArea = boxSurfaceArea2(right);
+            rightLeaves = right.leafNodeCount;
+        }
 
-        while (stackPointer-- > stackOffset) {
+        const thisArea = boxSurfaceArea2(this);
 
-            visitCount++;
+        return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
+    }
 
-            n = stack[stackPointer];
+    updateLeafNodeCount() {
+        let node = this;
 
-            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;
+        while (node !== null) {
+            let n = 0;
+
+            const right = node.right;
+
+            if (right !== null) {
+                if (right.isLeafNode) {
+                    n++;
+                } else {
+                    n += right.leafNodeCount;
                 }
             }
-        }
 
-        cleanup(stackOffset);
+            const left = this.left;
 
-        return visitCount;
-    }
+            if (left !== null) {
+                if (left.isLeafNode) {
+                    n++;
+                } else {
+                    n += left.leafNodeCount;
+                }
+            }
 
-    return traverseLeavesPreOrderUsingStack;
-})();
+            node.leafNodeCount = n;
 
-BinaryNode.prototype.refitFor2 = function () {
-    const a = this.left;
-    const b = this.right;
+            // propagate update up the tree
+            node = node.parentNode;
+        }
 
-    this.x0 = min2(a.x0, b.x0);
-    this.y0 = min2(a.y0, b.y0);
-    this.z0 = min2(a.z0, b.z0);
+    }
 
-    this.x1 = max2(a.x1, b.x1);
-    this.y1 = max2(a.y1, b.y1);
-    this.z1 = max2(a.z1, b.z1);
-};
+    /**
+     * 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() {
 
-BinaryNode.prototype.bubbleRefit = function () {
-    let n = this;
+        /**
+         *
+         * @type {BinaryNode}
+         */
+        const r = this.right;
 
-    n.refit();
+        const l = this.left;
 
-    //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;
+        const rL = r.left;
+        const rR = r.right;
 
-        n = n.parentNode;
+        this.left = r;
+        this.right = rR;
 
-        if (n === null) {
-            return;
+        if (rR !== null) {
+            rR.parentNode = this;
         }
 
-        //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;
+        r.left = l;
+        if (l !== null) {
+            l.parentNode = r;
         }
 
-        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;
-        }
+        r.right = rL;
 
-        if (!flag) {
-            //no violation, we can stop here
-            break;
-        }
-    }
-};
-BinaryNode.prototype.refit = function () {
-    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);
+        r.updateLeafNodeCount();
+
+        r.bubbleRefit();
     }
-};
 
-/**
- *
- * @param {Node} n0
- * @param {Node} n1
- * @return {number}
- */
-function sortMortonCodes(n0, n1) {
-    return n0._mortonCode - n1._mortonCode;
-}
+    rotateRight() {
+        const r = this.right;
 
-BinaryNode.prototype.sumSurfaceArea = function () {
-    let result = 0;
-    this.traversePreOrderUsingStack(function (node) {
-        const nodeArea = node.computeSurfaceArea();
-        result += nodeArea;
-    });
+        const l = this.left;
 
-    return result;
-};
+        const lL = l.left;
+        const lR = l.right;
 
-BinaryNode.prototype.countDescendants = function () {
-    let result = 0;
-    this.traversePreOrderUsingStack(function (node) {
-        result++;
-    });
-    return result;
-};
+        if (lL !== null) {
+            lL.parentNode = this;
+        }
+
+        l.right = r;
+        if (r !== null) {
+            r.parentNode = l;
+        }
 
+        l.left = lR;
 
-/**
- *
- * @param node
- */
-function countLeaves(node) {
-    if (isLeaf(node)) {
-        return 1;
+        l.updateLeafNodeCount();
+
+        l.bubbleRefit();
     }
 
-    let result = 0;
+    /**
+     *
+     * @param {function(index:int):LeafNode} leafFactory
+     * @param {int} numNodes
+     */
+    insertManyBoxes2(leafFactory, numNodes) {
+        let i, n;
+        //create leaf nodes
+        const nodes = new Array(numNodes);
 
-    node.traversePreOrderUsingStack(function (node) {
-        if (isLeaf(node)) {
-            result++;
+        for (i = 0; i < numNodes; i++) {
+            //leaf needs to be set up inside the callback
+            n = leafFactory(i);
+
+            nodes[i] = n;
         }
-    });
 
-    return result;
-}
+        //sort leaves
+        arrayQuickSort(nodes, n => n.computeMortonCode(), null, 0, max2(0, numNodes - 1));
 
-/**
- *
- * @return {number}
- */
-BinaryNode.prototype.computeSAH = function () {
-    let leftLeaves, rightLeaves, leftArea, rightArea;
+        let remaining_nodes = numNodes;
 
-    if (this.left === null) {
-        leftArea = 0;
-        leftLeaves = 0;
-    } else {
-        leftArea = boxSurfaceArea2(this.left);
-        leftLeaves = this.left.leafNodeCount;
-    }
+        while (remaining_nodes > 2) {
 
-    if (this.right === null) {
-        rightArea = 0;
-        rightLeaves = 0;
-    } else {
-        rightArea = boxSurfaceArea2(this.right);
-        rightLeaves = this.right.leafNodeCount;
-    }
-
-    const thisArea = boxSurfaceArea2(this);
+            //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);
+                nodes[i >> 1] = n;
+            }
 
-    return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
-};
+            const numNodesMod2 = remaining_nodes & 1; //faster version of %2
 
-BinaryNode.prototype.updateLeafNodeCount = function () {
-    let n = 0;
+            if (numNodesMod2 !== 0) {
+                //shift remaining node up so it will be considered later
+                nodes[i >> 1] = nodes[i];
+            }
 
-    const right = this.right;
+            remaining_nodes = (remaining_nodes >> 1) + numNodesMod2;
+        }
 
-    if (right !== null) {
-        if (right.isLeafNode) {
-            n++;
-        } else {
-            n += right.leafNodeCount;
+        //finally insert these boxes from this node
+        for (i = 0; i < remaining_nodes; i++) {
+            n = nodes[i];
+            this.insertNode(n);
         }
     }
 
-    const left = this.left;
+    /**
+     *
+     * @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;
 
-    if (left !== null) {
-        if (left.isLeafNode) {
-            n++;
-        } else {
-            n += left.leafNodeCount;
-        }
-    }
+        stack[stackPointer++] = this;
+
+        let count = 0;
+
+        while (stackPointer > startOffset) {
+            stackPointer--;
+            const node = stack[stackPointer];
 
-    this.leafNodeCount = n;
+            if (!aabb3_intersect_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;
+                }
 
-    // propagate update up the tree
-    let parentNode = this.parentNode;
+                const right = node.right;
+                if (right !== null) {
+                    stack[stackPointer++] = right;
+                }
+            }
+        }
 
-    if (parentNode !== null) {
-        // bubble up
-        parentNode.updateLeafNodeCount();
+        return count;
     }
-}
-
 
-/**
- * As a result of rotation, this node 'becomes' the right node, and left node get's replaced by the right node with necessary adjustments
- */
-BinaryNode.prototype.rotateLeft = function () {
+    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;
+            }
+        });
+    }
 
     /**
      *
-     * @type {BinaryNode}
+     * @param {Frustum[]} frustums Collection of THREE.js Frustums
+     * @param {function(node:LeafNode, boolean)} visitor
+     * @returns {number}
+     * @deprecated Use {@link ThreeFrustumsIntersectionBVHVisitor}
      */
-    const r = this.right;
+    threeTraverseFrustumsIntersections(frustums, visitor) {
+        const numFrustums = frustums.length;
 
-    const l = this.left;
+        /**
+         *
+         * @param {LeafNode|BinaryNode} node
+         * @returns {boolean}
+         */
+        function visitNode(node) {
+            let b = false;
+            let i = 0;
 
-    const rL = r.left;
-    const rR = r.right;
+            for (; i < numFrustums; i++) {
 
-    this.left = r;
-    this.right = rR;
+                const degree = node.intersectFrustumDegree(frustums[i]);
 
-    if (rR !== null) {
-        rR.parentNode = this;
-    }
+                if (degree === 2) {
+                    //completely inside frustum
 
-    r.left = l;
-    if (l !== null) {
-        l.parentNode = r;
-    }
+                    if (node.isLeafNode) {
+                        visitor(node, true);
+                    } else {
+                        node.traverseLeavesPreOrderUsingStack(fastVisitLeafNodeIntersection, visitor);
+                    }
 
-    r.right = rL;
+                    //prevent further traversal
+                    return false;
 
-    r.updateLeafNodeCount();
+                } else if (degree === 1) {
 
-    r.bubbleRefit();
-};
+                    //partially inside frustum
+                    b = true;
 
-BinaryNode.prototype.rotateRight = function () {
-    const r = this.right;
+                }
+            }
 
-    const l = this.left;
+            if (!b) {
+                return false;
+            }
 
-    const lL = l.left;
-    const lR = l.right;
+            if (node.isLeafNode) {
+                visitor(node, false);
+            }
 
-    if (lL !== null) {
-        lL.parentNode = this;
-    }
+            return true;
+        }
 
-    l.right = r;
-    if (r !== null) {
-        r.parentNode = l;
+        return this.traversePreOrderUsingStack(visitNode);
     }
 
-    l.left = lR;
+    /**
+     * 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;
 
-    l.updateLeafNodeCount();
+        function visitLeaves(node) {
+            if (node instanceof LeafNode) {
+                visitor(node);
+                return false;
+            } else {
+                return true;
+            }
+        }
 
-    l.bubbleRefit();
-};
+        function fastTraverseLeaves(node) {
+            if (node instanceof LeafNode) {
+                visitor(node);
+            } else {
+                node.traversePreOrderUsingStack(visitLeaves);
+            }
+        }
 
-/**
- *
- * @param {function(index:int):LeafNode} leafFactory
- * @param {int} numNodes
- */
-BinaryNode.prototype.insertManyBoxes2 = function (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);
+        function isFlagSet(mask, index) {
+            return mask & (1 << index) !== 0;
+        }
 
-        nodes[i] = n;
-    }
+        function clearFlag(mask, index) {
+            return mask & ~(1 << index);
+        }
 
-    //sort leaves
-    arrayQuickSort(nodes, n => n.computeMortonCode(), null, 0, max2(0, numNodes - 1));
+        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;
+        }
 
-    let remaining_nodes = numNodes;
+        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;
+                    }
+                }
 
-    while (remaining_nodes > 2) {
+                //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;
+                }
+            }
 
-        //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);
-            nodes[i >> 1] = n;
+            return newPlaneSets;
         }
 
-        const numNodesMod2 = remaining_nodes & 1; //faster version of %2
+        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;
+            }
 
-        if (numNodesMod2 !== 0) {
-            //shift remaining node up so it will be considered later
-            nodes[i >> 1] = nodes[i];
+            node.traversePreOrderUsingStack(internalVisitor);
         }
 
-        remaining_nodes = (remaining_nodes >> 1) + numNodesMod2;
-    }
+        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);
+        }
 
-    //finally insert these boxes from this node
-    for (i = 0; i < remaining_nodes; i++) {
-        n = nodes[i];
-        this.insertNode(n);
+        startTraversal(this);
     }
-};
-
 
-let stackPointer = 0;
-/**
- *
- * @type {Node[]}
- */
-const stack = [];
+    /**
+     *
+     * @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);
 
-/**
- *
- * @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
- */
-BinaryNode.prototype.requestLeafIntersectionsAABB3 = function (result, x0, y0, z0, x1, y1, z1) {
-    const startOffset = stackPointer;
+            if (!b) {
+                //no intersection, terminate this branch
+                return false;
+            }
 
-    stack[stackPointer++] = this;
+            if (isLeaf(node)) {
+                //leaf node, supply to visitor
+                visitor.call(thisArg, node);
+                return false;
+            } else {
+                //intermediate node, continue traversal
+                return true;
+            }
+        });
+    }
 
-    let count = 0;
+    /**
+     * Fraction of balanced nodes in the tree (those that have both children)
+     * @returns {number}
+     */
+    computeBalanceFactor() {
 
-    while (stackPointer > startOffset) {
-        stackPointer--;
-        const node = stack[stackPointer];
+        const bvhVisitor = new BVHVisitor();
 
-        if (!aabb3_intersect_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;
+        const depths = [];
 
-            count++;
-        } else {
-            const left = node.left;
-            if (left !== null) {
-                stack[stackPointer++] = left;
-            }
+        bvhVisitor.visitLeaf = (leaf) => {
+            const depth = leaf.computeDepth();
 
-            const right = node.right;
-            if (right !== null) {
-                stack[stackPointer++] = right;
-            }
-        }
-    }
+            depths.push(depth);
+        };
 
-    return count;
-};
+        traverseBinaryNodeUsingVisitor(this, bvhVisitor)
 
-BinaryNode.prototype.traverseSegmentLeafIntersections = function (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;
+        if (depths.length === 0) {
+            return 1;
         } else {
-            return true;
+            return computeSampleStandardDeviation(depths);
         }
-    });
-};
 
-/**
- * @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 {Frustum[]} frustums Collection of THREE.js Frustums
- * @param {function(node:LeafNode, boolean)} visitor
- * @returns {number}
- * @deprecated Use {@link ThreeFrustumsIntersectionBVHVisitor}
- */
-BinaryNode.prototype.threeTraverseFrustumsIntersections = function (frustums, visitor) {
-    const numFrustums = frustums.length;
+    /**
+     * @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 {LeafNode|BinaryNode} node
-     * @returns {boolean}
+     * @param {Node|BinaryNode|LeafNode} child
      */
-    function visitNode(node) {
-        let b = false;
-        let i = 0;
-
-        for (; i < numFrustums; i++) {
+    insertNode(child) {
 
-            const degree = node.intersectFrustumDegree(frustums[i]);
+        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");
 
-            if (degree === 2) {
-                //completely inside frustum
+        const sibling = this.__insertion_findSiblingFor(child);
 
-                if (node.isLeafNode) {
-                    visitor(node, true);
-                } else {
-                    node.traverseLeavesPreOrderUsingStack(fastVisitLeafNodeIntersection, visitor);
-                }
-
-                //prevent further traversal
-                return false;
+        const sibling_parent = sibling.parentNode;
+        if (sibling_parent === null) {
+            // root node
 
-            } else if (degree === 1) {
-
-                //partially inside frustum
-                b = true;
+            if (sibling.left === null) {
+                sibling.setChildLeft(child);
+            } else if (sibling.right === null) {
+                sibling.setChildRight(child);
+            } else {
+                const parent = new BinaryNode();
 
+                parent.setChildren(sibling.right, child);
+                sibling.right = parent;
+                parent.parentNode = sibling;
             }
-        }
 
-        if (!b) {
-            return false;
-        }
+        } else {
 
-        if (node.isLeafNode) {
-            visitor(node, false);
-        }
+            // non-root
 
-        return true;
-    }
+            if (sibling_parent.left === sibling && sibling_parent.right === null) {
 
-    return this.traversePreOrderUsingStack(visitNode);
-};
+                // right node is free, take it
+                sibling_parent.setChildRight(child);
 
-/**
- * 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}
- */
-BinaryNode.prototype.threeTraverseFrustumsIntersections2 = function (frustums, visitor) {
-    const numFrustums = frustums.length;
+            } else if (sibling_parent.right === sibling && sibling_parent.left === null) {
 
-    function visitLeaves(node) {
-        if (node instanceof LeafNode) {
-            visitor(node);
-            return false;
-        } else {
-            return true;
-        }
-    }
+                // left node is free, take it
+                sibling_parent.setChildLeft(child);
 
-    function fastTraverseLeaves(node) {
-        if (node instanceof LeafNode) {
-            visitor(node);
-        } else {
-            node.traversePreOrderUsingStack(visitLeaves);
-        }
-    }
+            } else {
 
+                transplantNewCommonParent(sibling, child)
 
-    function isFlagSet(mask, index) {
-        return mask & (1 << index) !== 0;
-    }
+            }
 
-    function clearFlag(mask, index) {
-        return mask & ~(1 << index);
-    }
+            sibling_parent.bubbleRefit();
 
-    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;
-                }
-            }
+    /**
+     * @param {boolean} deep
+     * @returns {BinaryNode}
+     */
+    clone(deep = false) {
+        const clone = new BinaryNode();
 
-            //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;
-            }
-        }
+        clone.x0 = this.x0;
+        clone.y0 = this.y0;
+        clone.z0 = this.z0;
+        clone.x1 = this.x1;
+        clone.y1 = this.y1;
+        clone.z1 = this.z1;
 
-        return newPlaneSets;
-    }
+        clone.leafNodeCount = this.leafNodeCount;
 
-    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++;
-                        }
-                    }
+        clone.parentNode = this.parentNode;
 
-                    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;
-                }
+        if (deep === true) {
+            if (this.left !== null) {
+                clone.left = this.left.clone(true);
+                clone.left.parentNode = clone;
             }
-
-            return false;
+            if (this.right !== null) {
+                clone.right = this.right.clone(true);
+                clone.right.parentNode = clone;
+            }
+        } else {
+            clone.left = this.left;
+            clone.right = this.right;
         }
 
-        node.traversePreOrderUsingStack(internalVisitor);
-    }
+        clone.modifiers = this.modifiers;
 
-    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);
+        return clone;
     }
+}
 
-    startTraversal(this);
-};
+/**
+ * @readonly
+ * @type {boolean}
+ */
+BinaryNode.prototype.isBinaryNode = true;
 
 /**
- *
- * @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
+ * @see "Dynamic BVH" by Erin Catto / Blizzard
+ * @param {AABB3} node
+ * @param {AABB3} addition
+ * @returns {number}
  */
-BinaryNode.prototype.traverseRayLeafIntersections = function (startX, startY, startZ, directionX, directionY, directionZ, visitor, thisArg) {
-    this.traversePreOrderUsingStack(function (node) {
-        let b = node.intersectRay(startX, startY, startZ, directionX, directionY, directionZ);
+function inclusion_surface_area_heuristic(node, addition) {
+    const x0 = min2(node.x0, addition.x0);
+    const y0 = min2(node.y0, addition.y0);
+    const z0 = min2(node.z0, addition.z0);
 
-        if (!b) {
-            //no intersection, terminate this branch
-            return false;
-        }
+    const x1 = max2(node.x1, addition.x1);
+    const y1 = max2(node.y1, addition.y1);
+    const z1 = max2(node.z1, addition.z1);
 
-        if (isLeaf(node)) {
-            //leaf node, supply to visitor
-            visitor.call(thisArg, node);
-            return false;
-        } else {
-            //intermediate node, continue traversal
-            return true;
-        }
-    });
-};
+    return _boxSurfaceArea2(x0, y0, z0, x1, y1, z1) - boxSurfaceArea2(node);
+}
 
 /**
- * Fraction of balanced nodes in the tree (those that have both children)
- * @returns {number}
+ *
+ * @param {BinaryNode|LeafNode} node
+ * @param {AABB3} addition
  */
-BinaryNode.prototype.computeBalanceFactor = function () {
+function inclusion_cost_lower_bound(node, addition) {
+    let n = node;
+    let r = boxSurfaceArea2(addition);
+
+    while (n !== null) {
 
-    const bvhVisitor = new BVHVisitor();
+        r += n.costForInclusion(addition);
 
+        n = n.parentNode;
+    }
 
-    const depths = [];
+    return r;
+}
 
-    bvhVisitor.visitLeaf = (leaf) => {
-        const depth = leaf.computeDepth();
 
-        depths.push(depth);
-    };
+/**
+ *
+ * @param {Node} n0
+ * @param {Node} n1
+ * @return {number}
+ */
+function sortMortonCodes(n0, n1) {
+    return n0._mortonCode - n1._mortonCode;
+}
 
-    traverseBinaryNodeUsingVisitor(this, bvhVisitor)
 
-    if (depths.length === 0) {
+/**
+ *
+ * @param node
+ */
+function countLeaves(node) {
+    if (isLeaf(node)) {
         return 1;
-    } else {
-        return computeSampleStandardDeviation(depths);
     }
 
-};
+    let result = 0;
+
+    node.traversePreOrderUsingStack(function (node) {
+        if (isLeaf(node)) {
+            result++;
+        }
+    });
+
+    return result;
+}
+
 
 /**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {*} value
- * @returns {LeafNode}
+ * @private
+ * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly
+ * @param {LeafNode} node
  */
-BinaryNode.prototype.insert = function (x0, y0, z0, x1, y1, z1, value) {
-    const leaf = new LeafNode(value);
-    leaf.setBounds(x0, y0, z0, x1, y1, z1);
-    this.insertNode(leaf);
-    return leaf;
-};
+function fastVisitLeafNodeIntersection(node) {
+    this(node, true);
+}
 
 /**
  *
@@ -1065,92 +1181,8 @@ function transplantNewCommonParent(node, child) {
 
     parent.bubbleExpandToFit(bNode);
 
+    parent.updateLeafNodeCount();
+
     return bNode;
 }
 
-/**
- *
- * @param {Node|BinaryNode|LeafNode} child
- */
-BinaryNode.prototype.insertNode = function (child) {
-    assert.notEqual(child, null, "child node is null");
-    assert.notEqual(child, undefined, "child node is undefined");
-    assert.ok(child instanceof Node, undefined, "child node is not an instance of Node");
-    assert.equal(child.parentNode, null, "parentNode must be null, otherwise Node still belongs to another tree");
-
-    const node = this.findParentFor(child);
-
-    let bNode;
-
-    if (node.isBinaryNode) {
-        if ((node.isProtected() && node !== this)) {
-            transplantNewCommonParent(node, child);
-        } else if (node.left === null) {
-            node.left = child;
-            child.parentNode = node;
-            node.bubbleExpandToFit(child);
-        } else if (node.right === null) {
-            node.right = child;
-            child.parentNode = node;
-            node.bubbleExpandToFit(child);
-        } else {
-            //take right child and insert another binary node there
-            bNode = new BinaryNode();
-            bNode.setChildren(node.right, child);
-            //
-            node.right = bNode;
-            bNode.parentNode = node;
-            node.bubbleExpandToFit(bNode);
-        }
-
-        node.updateLeafNodeCount();
-    } else {
-        //need to do transplanting and introduce a new common parent
-        bNode = transplantNewCommonParent(node, child);
-
-        bNode.updateLeafNodeCount();
-    }
-
-};
-
-/**
- *
- * @returns {BinaryNode}
- */
-BinaryNode.prototype.clone = function (deep) {
-    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;
-};
-
-
-export {
-    BinaryNode
-};