@jscad/modeling 3.0.1-alpha.0 → 3.0.3-alpha.0

package/src/operations/booleans/subtractGeom3.test.js

@@ -17,7 +17,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of one object
   const result1 = subtract(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = subtract(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows.skip(() => geom3.validate(result2))
   t.is(measureArea(result2), 44.053756306589825)
   t.is(measureVolume(result2), 25.751611331979678)
@@ -88,7 +88,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = subtract(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
   exp = [
     [[12, 8, 8], [12, 12, 8], [12, 12, 12], [12, 8, 12]],
     [[8, 12, 8], [8, 12, 12], [12, 12, 12], [12, 12, 8]],
@@ -111,7 +111,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of two completely overlapping objects
   const result4 = subtract(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows(() => geom3.validate(result4))
   t.is(measureArea(result4), 0)
   t.is(measureVolume(result4), 0)

package/src/operations/booleans/trees/Node.js

@@ -5,7 +5,7 @@ import * as poly3 from '../../../geometries/poly3/index.js'
 // # class Node
 // Holds a node in a BSP tree.
 // A BSP tree is built from a collection of polygons by picking a polygon to split along.
-// Polygons are not stored directly in the tree, but in PolygonTreeNodes, stored in this.polygontreenodes.
+// Polygons are not stored directly in the BSP tree, but in PolygonTreeNodes, stored in this.polygontreenodes.
 // Those PolygonTreeNodes are children of the owning Tree.polygonTree.
 // This is not a leafy BSP tree since there is no distinction between internal and leaf nodes.
 export class Node {
@@ -23,17 +23,16 @@ export class Node {
     let node
     for (let i = 0; i < queue.length; i++) {
       node = queue[i]
-      if (node.plane) node.plane = plane.flip(plane.create(), node.plane)
-      if (node.front) queue.push(node.front)
-      if (node.back) queue.push(node.back)
+      if (node.plane !== null) node.plane = plane.flip(plane.create(), node.plane)
+      if (node.front !== null) queue.push(node.front)
+      if (node.back !== null) queue.push(node.back)
       const temp = node.front
       node.front = node.back
       node.back = temp
     }
   }
 
-  // clip polygontreenodes to our plane
-  // calls remove() for all clipped PolygonTreeNodes
+  // Clip the given tree nodes to our plane
   clipPolygons (polygonTreeNodes, alsoRemoveCoplanarFront) {
     let current = { node: this, polygonTreeNodes }
     let node
@@ -43,26 +42,27 @@ export class Node {
       node = current.node
       polygonTreeNodes = current.polygonTreeNodes
 
-      if (node.plane) {
+      if (node.plane !== null) {
         const plane = node.plane
 
         const backNodes = []
         const frontNodes = []
         const coplanarFrontNodes = alsoRemoveCoplanarFront ? backNodes : frontNodes
-        polygonTreeNodes.forEach((treeNode) => {
-          if (!treeNode.isRemoved()) {
-            // split this polygon tree node using the plane
-            // NOTE: children are added to the tree if there are spanning polygons
+        for (let i = 0; i < polygonTreeNodes.length; i++) {
+          const treeNode = polygonTreeNodes[i]
+          if (treeNode.canSplit()) {
+            // split this tree node using the plane
+            // NOTE: children are added to the tree node if there are spanning polygons
             treeNode.splitByPlane(plane, coplanarFrontNodes, backNodes, frontNodes, backNodes)
           }
-        })
+        }
 
-        if (node.front && (frontNodes.length > 0)) {
+        if (node.front !== null && frontNodes.length > 0) {
           // add front node for further splitting
           stack.push({ node: node.front, polygonTreeNodes: frontNodes })
         }
         const numBackNodes = backNodes.length
-        if (node.back && (numBackNodes > 0)) {
+        if (node.back !== null && numBackNodes > 0) {
           // add back node for further splitting
           stack.push({ node: node.back, polygonTreeNodes: backNodes })
         } else {
@@ -76,17 +76,16 @@ export class Node {
     } while (current !== undefined)
   }
 
-  // Remove all polygons in this BSP tree that are inside the other BSP tree
-  // `tree`.
-  clipTo (tree, alsoRemoveCoplanarFront) {
+  // Remove all polygons in this BSP tree that are inside the given BSP tree
+  clipTo (bsptree, alsoRemoveCoplanarFront) {
     let node = this
     const stack = []
     do {
       if (node.polygontreenodes.length > 0) {
-        tree.rootnode.clipPolygons(node.polygontreenodes, alsoRemoveCoplanarFront)
+        bsptree.clipPolygons(node.polygontreenodes, alsoRemoveCoplanarFront)
       }
-      if (node.front) stack.push(node.front)
-      if (node.back) stack.push(node.back)
+      if (node.front !== null) stack.push(node.front)
+      if (node.back !== null) stack.push(node.back)
       node = stack.pop()
     } while (node !== undefined)
   }
@@ -103,7 +102,7 @@ export class Node {
         current = stack.pop()
         continue
       }
-      if (!node.plane) {
+      if (node.plane === null) {
         let index = 0 // default
         index = Math.floor(len / 2)
         // index = len >> 1
@@ -118,21 +117,20 @@ export class Node {
       }
 
       if (frontNodes.length > 0) {
-        if (!node.front) node.front = new Node(node)
+        if (node.front === null) node.front = new Node(node)
 
         // unable to split by any of the current nodes
         const stopCondition = len === frontNodes.length && backNodes.length === 0
-        if (stopCondition) node.front.polygontreenodes = frontNodes
-        else stack.push({ node: node.front, polygonTreeNodes: frontNodes })
+
+        stopCondition ? node.front.polygontreenodes = frontNodes : stack.push({ node: node.front, polygonTreeNodes: frontNodes })
       }
       if (backNodes.length > 0) {
-        if (!node.back) node.back = new Node(node)
+        if (node.back === null) node.back = new Node(node)
 
         // unable to split by any of the current nodes
         const stopCondition = len === backNodes.length && frontNodes.length === 0
 
-        if (stopCondition) node.back.polygontreenodes = backNodes
-        else stack.push({ node: node.back, polygonTreeNodes: backNodes })
+        stopCondition ? node.back.polygontreenodes = backNodes : stack.push({ node: node.back, polygonTreeNodes: backNodes })
       }
 
       current = stack.pop()

package/src/operations/booleans/trees/PolygonTreeNode.js

@@ -6,6 +6,9 @@ import * as poly3 from '../../../geometries/poly3/index.js'
 
 import { splitPolygonByPlane } from './splitPolygonByPlane.js'
 
+// cached values to boost performance
+const splitResult = { type: 0, front: null, back: null }
+
 // # class PolygonTreeNode
 // This class manages hierarchical splits of polygons.
 // At the top is a root node which does not hold a polygon, only child PolygonTreeNodes.
@@ -13,72 +16,72 @@ import { splitPolygonByPlane } from './splitPolygonByPlane.js'
 // The polygons can be in different planes.
 // splitByPlane() splits a node by a plane. If the plane intersects the polygon,
 // two new child nodes are created holding the split polygon.
-// getPolygons() retrieves the polygons from the tree. If for PolygonTreeNode the polygon is split but
+// getPolygons() retrieves the polygons from the node. If for PolygonTreeNode the polygon is split but
 // the two split parts (child nodes) are still intact, then the unsplit polygon is returned.
 // This ensures that we can safely split a polygon into many fragments. If the fragments are untouched,
 // getPolygons() will return the original unsplit polygon instead of the fragments.
-// remove() removes a polygon from the tree. Once a polygon is removed, the parent polygons are invalidated
+// remove() removes a polygon from the node. Once a polygon is removed, the parent polygons are invalidated
 // since they are no longer intact.
 export class PolygonTreeNode {
   // constructor creates the root node
   constructor (parent, polygon) {
     this.parent = parent
-    this.children = []
     this.polygon = polygon
-    this.removed = false // state of branch or leaf
+    this.children = []
   }
 
-  // fill the tree with polygons. Should be called on the root node only; child nodes must
+  // fill the node with polygons. Should be called on the root node only; child nodes must
   // always be a derivate (split) of the parent node.
   addPolygons (polygons) {
     // new polygons can only be added to root node; children can only be split polygons
-    if (!this.isRootNode()) {
-      throw new Error('Assertion failed')
+    if (!this.isRootNode()) throw new Error('PolygonTreeNode01')
+
+    for (let i = 0; i < polygons.length; i++) {
+      this.addChild(polygons[i])
     }
-    const _this = this
-    polygons.forEach((polygon) => {
-      _this.addChild(polygon)
-    })
   }
 
   // remove a node
   // - the siblings become toplevel nodes
   // - the parent is removed recursively
   remove () {
-    if (!this.removed) {
-      this.removed = true
-      this.polygon = null
+    this.polygon = null
 
-      // remove ourselves from the parent's children list:
-      const parentschildren = this.parent.children
-      const i = parentschildren.indexOf(this)
-      if (i < 0) throw new Error('Assertion failed')
-      parentschildren.splice(i, 1)
+    // remove ourselves from the parent's children list:
+    const parentschildren = this.parent.children
+    const i = parentschildren.indexOf(this)
+    if (i < 0) throw new Error('PolyTreeNode02')
+    parentschildren.splice(i, 1)
 
-      // invalidate the parent's polygon, and of all parents above it:
-      this.parent.recursivelyInvalidatePolygon()
-    }
+    // invalidate the parent's polygon, and of all parents above it:
+    this.parent._recursivelyInvalidatePolygon()
   }
 
-  isRemoved () {
-    return this.removed
+  /*
+   * Can the node be split, either base polygon or children
+   */
+  canSplit () {
+    return this.polygon != null || this.children.length > 0
   }
 
   isRootNode () {
     return !this.parent
   }
 
-  // invert all polygons in the tree. Call on the root node
+  // invert all polygons in the node. Call on the root node
   invert () {
-    if (!this.isRootNode()) throw new Error('Assertion failed') // can only call this on the root node
-    this.invertSub()
+    if (!this.isRootNode()) throw new Error('PolyTreeNode03')
+    this._invertSub()
   }
 
   getPolygon () {
-    if (!this.polygon) throw new Error('Assertion failed') // doesn't have a polygon, which means that it has been broken down
+    if (this.polygon === null) throw new Error('PolyTreeNode04')
     return this.polygon
   }
 
+  /*
+   * Get all polygons from the node, and add to the result
+   */
   getPolygons (result) {
     let children = [this]
     const queue = [children]
@@ -87,23 +90,37 @@ export class PolygonTreeNode {
       children = queue[i]
       for (j = 0, l = children.length; j < l; j++) { // ok to cache length
         node = children[j]
-        if (node.polygon) {
-          // the polygon hasn't been broken yet. We can ignore the children and return our polygon:
+        if (node.polygon !== null) {
+          // the polygon hasn't been broken yet. We can ignore the children and return our polygon
           result.push(node.polygon)
         } else {
-          // our polygon has been split up and broken, so gather all subpolygons from the children
-          if (node.children.length > 0) queue.push(node.children)
+          // our polygon has been split up and broken, so gather all subpolygons
+          if (node.children.length > 0) {
+            queue.push(node.children)
+          }
         }
       }
     }
   }
 
-  // split the node by a plane; add the resulting nodes to the frontNodes and backNodes array
-  // If the plane doesn't intersect the polygon, the 'this' object is added to one of the arrays
-  // If the plane does intersect the polygon, two new child nodes are created for the front and back fragments,
-  //  and added to both arrays.
-  splitByPlane (plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes) {
-    if (this.children.length) {
+  // NOTE: This version of getPolygons() is much SLOWER.
+  getPolygonsNew (result) {
+    if (this.polygon !== null) {
+      // the polygon hasn't been broken yet, so return the original polygon
+      result.push(this.polygon)
+    } else {
+      // the polygon has been split, so gather all polygons from the children
+      for (let i = 0; i < this.children.length; i++) {
+        const node = this.children[i]
+        node.getPolygons(result)
+      }
+    }
+  }
+
+  // split the node by a plane, adding the resulting nodes to the frontNodes and backNodes array
+  // Also see canSplit()
+  splitByPlaneOld (plane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes) {
+    if (this.children.length > 0) {
       const queue = [this.children]
       let i
       let j
@@ -117,68 +134,90 @@ export class PolygonTreeNode {
           if (node.children.length > 0) {
             queue.push(node.children)
           } else {
-            // no children. Split the polygon:
-            node._splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
+            if (this.polygon !== null) {
+              // no children. Split the polygon:
+              node._splitByPlane(plane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes)
+            }
           }
         }
       }
     } else {
-      this._splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
+      if (this.polygon !== null) {
+        this._splitByPlane(plane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes)
+      }
+    }
+  }
+
+  splitByPlane (plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes) {
+    if (this.children.length > 0) {
+      // the polygon has been split, so split the children by the given plane
+      for (let i = 0; i < this.children.length; i++) {
+        const node = this.children[i]
+        node.splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
+      }
+    } else {
+      if (this.polygon !== null) {
+        // the polygon hasn't been split, so split this node by the given plane
+        this._splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
+      }
     }
   }
 
+  // PRIVATE
+  // If the plane doesn't intersect the polygon, the 'this' object is added to one of the arrays
+  // If the plane does intersect the polygon, two new child nodes are created for the front and back fragments,
+  // and added to both arrays.
   // only to be called for nodes with no children
   _splitByPlane (splane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes) {
-    const polygon = this.polygon
-    if (polygon) {
-      const bound = poly3.measureBoundingSphere(polygon)
-      const sphereRadius = bound[3] + EPS // ensure radius is LARGER then polygon
-      const sphereCenter = bound
-      const d = vec3.dot(splane, sphereCenter) - splane[3]
-      if (d > sphereRadius) {
-        frontNodes.push(this)
-      } else if (d < -sphereRadius) {
-        backNodes.push(this)
-      } else {
-        const splitResult = splitPolygonByPlane(splane, polygon)
-        switch (splitResult.type) {
-          case 0:
-            // coplanar front:
-            coplanarFrontNodes.push(this)
-            break
+    // perform a quick check to see the plane is outside the bounds of the polygon
+    const bounds = poly3.measureBoundingSphereAndCache(this.polygon)
+    const sphereRadius = bounds[3] + EPS // ensure radius is LARGER then polygon
+    const d = vec3.dot(splane, bounds) - splane[3]
+    if (d > sphereRadius) {
+      frontNodes.push(this)
+      return
+    } else if (d < -sphereRadius) {
+      backNodes.push(this)
+      return
+    }
 
-          case 1:
-            // coplanar back:
-            coplanarBackNodes.push(this)
-            break
+    // the plane may intersect the polyogn
+    splitPolygonByPlane(splitResult, splane, this.polygon)
+    switch (splitResult.type) {
+      case 0:
+        // coplanar front:
+        coplanarFrontNodes.push(this)
+        break
 
-          case 2:
-            // front:
-            frontNodes.push(this)
-            break
+      case 1:
+        // coplanar back:
+        coplanarBackNodes.push(this)
+        break
 
-          case 3:
-            // back:
-            backNodes.push(this)
-            break
+      case 2:
+        // front:
+        frontNodes.push(this)
+        break
 
-          case 4:
-            // spanning:
-            if (splitResult.front) {
-              const frontNode = this.addChild(splitResult.front)
-              frontNodes.push(frontNode)
-            }
-            if (splitResult.back) {
-              const backNode = this.addChild(splitResult.back)
-              backNodes.push(backNode)
-            }
-            break
+      case 3:
+        // back:
+        backNodes.push(this)
+        break
+
+      case 4:
+        // spanning:
+        if (splitResult.front !== null) {
+          const frontNode = this.addChild(splitResult.front)
+          frontNodes.push(frontNode)
         }
-      }
+        if (splitResult.back !== null) {
+          const backNode = this.addChild(splitResult.back)
+          backNodes.push(backNode)
+        }
+        break
     }
   }
 
-  // PRIVATE methods from here:
   // add child to a node
   // this should be called whenever the polygon is split
   // a child should be created for every fragment of the split polygon
@@ -189,7 +228,9 @@ export class PolygonTreeNode {
     return newChild
   }
 
-  invertSub () {
+  // PRIVATE
+  // See invert()
+  _invertSub () {
     let children = [this]
     const queue = [children]
     let i, j, l, node
@@ -197,7 +238,7 @@ export class PolygonTreeNode {
       children = queue[i]
       for (j = 0, l = children.length; j < l; j++) {
         node = children[j]
-        if (node.polygon) {
+        if (node.polygon !== null) {
           node.polygon = poly3.invert(node.polygon)
         }
         if (node.children.length > 0) queue.push(node.children)
@@ -205,34 +246,40 @@ export class PolygonTreeNode {
     }
   }
 
-  // private method
+  // NOTE: This verison is SLOWER
+  _invertSubNew () {
+    if (this.polygon !== null) {
+      this.polygon = poly3.invert(this.polygon)
+    }
+    for (let i = 0; i < this.children.length; i++) {
+      const node = this.children[i]
+      node._invertSub()
+    }
+  }
+
+  // PRIVATE
   // remove the polygon from the node, and all parent nodes above it
   // called to invalidate parents of removed nodes
-  recursivelyInvalidatePolygon () {
+  _recursivelyInvalidatePolygon () {
     this.polygon = null
-    if (this.parent) {
-      this.parent.recursivelyInvalidatePolygon()
+    if (this.parent !== null) {
+      this.parent._recursivelyInvalidatePolygon()
     }
   }
 
   clear () {
-    let children = [this]
-    const queue = [children]
-    for (let i = 0; i < queue.length; ++i) { // queue size can change in loop, don't cache length
-      children = queue[i]
-      const l = children.length
-      for (let j = 0; j < l; j++) {
-        const node = children[j]
-        if (node.polygon) {
-          node.polygon = null
-        }
-        if (node.parent) {
-          node.parent = null
-        }
-        if (node.children.length > 0) queue.push(node.children)
-        node.children = []
-      }
+    // clear children
+    for (let i = 0; i < this.children.length; i++) {
+      const node = this.children[i]
+      node.clear()
+    }
+    this.children.length = 0
+    // unlink polygon
+    if (this.polygon !== null) {
+      this.polygon = null
     }
+    // unlink parent
+    this.parent = null
   }
 
   toString () {
@@ -246,7 +293,7 @@ export class PolygonTreeNode {
       for (j = 0, l = children.length; j < l; j++) { // ok to cache length
         node = children[j]
         result += `${prefix}PolygonTreeNode (${node.isRootNode()}): ${node.children.length}`
-        if (node.polygon) {
+        if (node.polygon !== null) {
           result += `\n ${prefix}polygon: ${node.polygon.vertices}\n`
         } else {
           result += '\n'

package/src/operations/booleans/trees/Tree.js

@@ -7,7 +7,7 @@ import { PolygonTreeNode } from './PolygonTreeNode.js'
 // The actual tree is kept in this.rootnode
 export class Tree {
   constructor (polygons) {
-    this.polygonTree = new PolygonTreeNode()
+    this.polygonTree = new PolygonTreeNode(null, null)
     this.rootnode = new Node(null)
     if (polygons) this.addPolygons(polygons)
   }
@@ -17,10 +17,9 @@ export class Tree {
     this.rootnode.invert()
   }
 
-  // Remove all polygons in this BSP tree that are inside the other BSP tree
-  // `tree`.
+  // Remove all polygons in this tree that are inside the given tree
   clipTo (tree, alsoRemoveCoplanarFront = false) {
-    this.rootnode.clipTo(tree, alsoRemoveCoplanarFront)
+    this.rootnode.clipTo(tree.rootnode, alsoRemoveCoplanarFront)
   }
 
   allPolygons () {
@@ -37,6 +36,12 @@ export class Tree {
     this.rootnode.addPolygonTreeNodes(polygonTreeNodes)
   }
 
+  // NOTE: This version is SLOWER
+  addPolygonsNew (polygons) {
+    this.polygonTree.addPolygons(polygons)
+    this.rootnode.addPolygonTreeNodes(this.polygonTree.children)
+  }
+
   clear () {
     this.polygonTree.clear()
   }

package/src/operations/booleans/trees/splitLineSegmentByPlane.js

@@ -3,9 +3,11 @@ import * as vec3 from '../../../maths/vec3/index.js'
 export const splitLineSegmentByPlane = (plane, p1, p2) => {
   const direction = vec3.subtract(vec3.create(), p2, p1)
   let lambda = (plane[3] - vec3.dot(plane, p1)) / vec3.dot(plane, direction)
-  if (Number.isNaN(lambda)) lambda = 0
-  if (lambda > 1) lambda = 1
-  if (lambda < 0) lambda = 0
+
+  Number.isNaN(lambda) ? lambda = 0
+    : lambda > 1 ? lambda = 1
+      : lambda < 0 ? lambda = 0
+        : lambda
 
   vec3.scale(direction, direction, lambda)
   vec3.add(direction, p1, direction)