@jscad/modeling 2.11.1 → 3.0.0-alpha.0

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

@@ -1,14 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePolygonsAsPoints } = require('../../../test/helpers')
+import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
-const { geom3 } = require('../../geometries')
+import { geom3 } from '../../geometries/index.js'
 
-const { sphere, cuboid } = require('../../primitives')
+import { measureVolume } from '../../measurements/index.js'
 
-const { subtract } = require('./index')
+import { sphere, cuboid } from '../../primitives/index.js'
 
-const { center } = require('../transforms/center')
+import { subtract } from './index.js'
+
+import { center } from '../transforms/index.js'
 
 test('subtract: subtract of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
@@ -67,6 +69,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -76,6 +79,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const result2 = subtract(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows.skip(() => geom3.validate(result2))
+  t.is(measureVolume(result2), 25.751611331979678)
   t.is(obs.length, 32)
 
   // subtract of two partially overlapping objects
@@ -98,6 +102,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[12, 9, 8], [12, 8, 8], [9, 8, 8], [9, 9, 8]]
   ]
   t.notThrows.skip(() => geom3.validate(result3))
+  t.is(measureVolume(result3), 63)
   t.is(obs.length, 12)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -105,5 +110,6 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const result4 = subtract(geometry1, geometry3)
   obs = geom3.toPoints(result4)
   t.notThrows(() => geom3.validate(result4))
+  t.is(measureVolume(result4), 0)
   t.is(obs.length, 0)
 })

package/src/operations/booleans/subtractGeom3Sub.js

@@ -1,16 +1,17 @@
-const geom3 = require('../../geometries/geom3')
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const mayOverlap = require('./mayOverlap')
-const { Tree } = require('./trees')
+import { Tree } from './trees/index.js'
+
+import { mayOverlap } from './mayOverlap.js'
 
 /*
  * Return a new 3D geometry representing the space in the first geometry but not
  * in the second geometry. None of the given geometries are modified.
- * @param {geom3} geometry1 - a geometry
- * @param {geom3} geometry2 - a geometry
- * @returns {geom3} new 3D geometry
+ * @param {Geom3} geometry1 - a geometry
+ * @param {Geom3} geometry2 - a geometry
+ * @returns {Geom3} new 3D geometry
  */
-const subtractGeom3Sub = (geometry1, geometry2) => {
+export const subtractGeom3Sub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {
     return geom3.clone(geometry1)
   }
@@ -24,8 +25,6 @@ const subtractGeom3Sub = (geometry1, geometry2) => {
   a.addPolygons(b.allPolygons())
   a.invert()
 
-  const newpolygons = a.allPolygons()
-  return geom3.create(newpolygons)
+  const newPolygons = a.allPolygons()
+  return geom3.create(newPolygons)
 }
-
-module.exports = subtractGeom3Sub

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

@@ -1,5 +1,6 @@
-const plane = require('../../../maths/plane')
-const poly3 = require('../../../geometries/poly3')
+import * as plane from '../../../maths/plane/index.js'
+
+import * as poly3 from '../../../geometries/poly3/index.js'
 
 // # class Node
 // Holds a node in a BSP tree.
@@ -7,7 +8,7 @@ const poly3 = require('../../../geometries/poly3')
 // Polygons are not stored directly in the 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.
-class Node {
+export class Node {
   constructor (parent) {
     this.plane = null
     this.front = null
@@ -33,43 +34,41 @@ class Node {
 
   // clip polygontreenodes to our plane
   // calls remove() for all clipped PolygonTreeNodes
-  clipPolygons (polygontreenodes, alsoRemovecoplanarFront) {
-    let current = { node: this, polygontreenodes: polygontreenodes }
+  clipPolygons (polygonTreeNodes, alsoRemoveCoplanarFront) {
+    let current = { node: this, polygonTreeNodes }
     let node
     const stack = []
 
     do {
       node = current.node
-      polygontreenodes = current.polygontreenodes
+      polygonTreeNodes = current.polygonTreeNodes
 
       if (node.plane) {
         const plane = node.plane
 
-        const backnodes = []
-        const frontnodes = []
-        const coplanarfrontnodes = alsoRemovecoplanarFront ? backnodes : frontnodes
-        const numpolygontreenodes = polygontreenodes.length
-        for (let i = 0; i < numpolygontreenodes; i++) {
-          const treenode = polygontreenodes[i]
-          if (!treenode.isRemoved()) {
+        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
-            treenode.splitByPlane(plane, coplanarfrontnodes, backnodes, frontnodes, backnodes)
+            treeNode.splitByPlane(plane, coplanarFrontNodes, backNodes, frontNodes, backNodes)
           }
-        }
+        })
 
-        if (node.front && (frontnodes.length > 0)) {
+        if (node.front && (frontNodes.length > 0)) {
           // add front node for further splitting
-          stack.push({ node: node.front, polygontreenodes: frontnodes })
+          stack.push({ node: node.front, polygonTreeNodes: frontNodes })
         }
-        const numbacknodes = backnodes.length
-        if (node.back && (numbacknodes > 0)) {
+        const numBackNodes = backNodes.length
+        if (node.back && (numBackNodes > 0)) {
           // add back node for further splitting
-          stack.push({ node: node.back, polygontreenodes: backnodes })
+          stack.push({ node: node.back, polygonTreeNodes: backNodes })
         } else {
           // remove all back nodes from processing
-          for (let i = 0; i < numbacknodes; i++) {
-            backnodes[i].remove()
+          for (let i = 0; i < numBackNodes; i++) {
+            backNodes[i].remove()
           }
         }
       }
@@ -79,12 +78,12 @@ class Node {
 
   // Remove all polygons in this BSP tree that are inside the other BSP tree
   // `tree`.
-  clipTo (tree, alsoRemovecoplanarFront) {
+  clipTo (tree, alsoRemoveCoplanarFront) {
     let node = this
     const stack = []
     do {
       if (node.polygontreenodes.length > 0) {
-        tree.rootnode.clipPolygons(node.polygontreenodes, alsoRemovecoplanarFront)
+        tree.rootnode.clipPolygons(node.polygontreenodes, alsoRemoveCoplanarFront)
       }
       if (node.front) stack.push(node.front)
       if (node.back) stack.push(node.back)
@@ -92,53 +91,51 @@ class Node {
     } while (node !== undefined)
   }
 
-  addPolygonTreeNodes (newpolygontreenodes) {
-    let current = { node: this, polygontreenodes: newpolygontreenodes }
+  addPolygonTreeNodes (newPolygonTreeNodes) {
+    let current = { node: this, polygonTreeNodes: newPolygonTreeNodes }
     const stack = []
     do {
       const node = current.node
-      const polygontreenodes = current.polygontreenodes
+      const polygonTreeNodes = current.polygonTreeNodes
+      const len = polygonTreeNodes.length
 
-      if (polygontreenodes.length === 0) {
+      if (len === 0) {
         current = stack.pop()
         continue
       }
       if (!node.plane) {
         let index = 0 // default
-        index = Math.floor(polygontreenodes.length / 2)
-        // index = polygontreenodes.length >> 1
-        // index = Math.floor(Math.random()*polygontreenodes.length)
-        const bestpoly = polygontreenodes[index].getPolygon()
-        node.plane = poly3.plane(bestpoly)
+        index = Math.floor(len / 2)
+        // index = len >> 1
+        // index = Math.floor(Math.random() * len)
+        const bestPoly = polygonTreeNodes[index].getPolygon()
+        node.plane = poly3.plane(bestPoly)
       }
-      const frontnodes = []
-      const backnodes = []
-      const n = polygontreenodes.length
-      for (let i = 0; i < n; ++i) {
-        polygontreenodes[i].splitByPlane(node.plane, node.polygontreenodes, backnodes, frontnodes, backnodes)
+      const frontNodes = []
+      const backNodes = []
+      for (let i = 0; i < len; ++i) {
+        polygonTreeNodes[i].splitByPlane(node.plane, node.polygontreenodes, backNodes, frontNodes, backNodes)
       }
 
-      if (frontnodes.length > 0) {
+      if (frontNodes.length > 0) {
         if (!node.front) node.front = new Node(node)
 
         // unable to split by any of the current nodes
-        const stopCondition = n === frontnodes.length && backnodes.length === 0
-        if (stopCondition) node.front.polygontreenodes = frontnodes
-        else stack.push({ node: node.front, polygontreenodes: frontnodes })
+        const stopCondition = len === frontNodes.length && backNodes.length === 0
+        if (stopCondition) node.front.polygontreenodes = frontNodes
+        else stack.push({ node: node.front, polygonTreeNodes: frontNodes })
       }
-      if (backnodes.length > 0) {
+      if (backNodes.length > 0) {
         if (!node.back) node.back = new Node(node)
 
         // unable to split by any of the current nodes
-        const stopCondition = n === backnodes.length && frontnodes.length === 0
+        const stopCondition = len === backNodes.length && frontNodes.length === 0
 
-        if (stopCondition) node.back.polygontreenodes = backnodes
-        else stack.push({ node: node.back, polygontreenodes: backnodes })
+        if (stopCondition) node.back.polygontreenodes = backNodes
+        else stack.push({ node: node.back, polygonTreeNodes: backNodes })
       }
 
       current = stack.pop()
     } while (current !== undefined)
   }
 }
-
-module.exports = Node

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

@@ -1,37 +1,37 @@
-const { EPS } = require('../../../maths/constants')
+import { EPS } from '../../../maths/constants.js'
 
-const vec3 = require('../../../maths/vec3')
+import * as vec3 from '../../../maths/vec3/index.js'
 
-const poly3 = require('../../../geometries/poly3')
+import * as poly3 from '../../../geometries/poly3/index.js'
 
-const splitPolygonByPlane = require('./splitPolygonByPlane')
+import { splitPolygonByPlane } from './splitPolygonByPlane.js'
 
 // # 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.
 // Below that are zero or more 'top' nodes; each holds a polygon.
 // 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 splitted polygon.
+// 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
 // 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
 // since they are no longer intact.
-class PolygonTreeNode {
+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.removed = false // state of branch or leaf
   }
 
   // fill the tree 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 splitted polygons
+    // new polygons can only be added to root node; children can only be split polygons
     if (!this.isRootNode()) {
       throw new Error('Assertion failed')
     }
@@ -98,11 +98,11 @@ class PolygonTreeNode {
     }
   }
 
-  // split the node by a plane; add the resulting nodes to the frontnodes and backnodes array
+  // 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) {
+  splitByPlane (plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes) {
     if (this.children.length) {
       const queue = [this.children]
       let i
@@ -118,59 +118,59 @@ class PolygonTreeNode {
             queue.push(node.children)
           } else {
             // no children. Split the polygon:
-            node._splitByPlane(plane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes)
+            node._splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
           }
         }
       }
     } else {
-      this._splitByPlane(plane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes)
+      this._splitByPlane(plane, coplanarFrontNodes, coplanarBackNodes, frontNodes, backNodes)
     }
   }
 
   // only to be called for nodes with no children
-  _splitByPlane (splane, coplanarfrontnodes, coplanarbacknodes, frontnodes, backnodes) {
+  _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)
+      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) {
+        const splitResult = splitPolygonByPlane(splane, polygon)
+        switch (splitResult.type) {
           case 0:
             // coplanar front:
-            coplanarfrontnodes.push(this)
+            coplanarFrontNodes.push(this)
             break
 
           case 1:
             // coplanar back:
-            coplanarbacknodes.push(this)
+            coplanarBackNodes.push(this)
             break
 
           case 2:
             // front:
-            frontnodes.push(this)
+            frontNodes.push(this)
             break
 
           case 3:
             // back:
-            backnodes.push(this)
+            backNodes.push(this)
             break
 
           case 4:
             // spanning:
-            if (splitresult.front) {
-              const frontnode = this.addChild(splitresult.front)
-              frontnodes.push(frontnode)
+            if (splitResult.front) {
+              const frontNode = this.addChild(splitResult.front)
+              frontNodes.push(frontNode)
             }
-            if (splitresult.back) {
-              const backnode = this.addChild(splitresult.back)
-              backnodes.push(backnode)
+            if (splitResult.back) {
+              const backNode = this.addChild(splitResult.back)
+              backNodes.push(backNode)
             }
             break
         }
@@ -184,9 +184,9 @@ class PolygonTreeNode {
   // a child should be created for every fragment of the split polygon
   // returns the newly created child
   addChild (polygon) {
-    const newchild = new PolygonTreeNode(this, polygon)
-    this.children.push(newchild)
-    return newchild
+    const newChild = new PolygonTreeNode(this, polygon)
+    this.children.push(newChild)
+    return newChild
   }
 
   invertSub () {
@@ -257,5 +257,3 @@ class PolygonTreeNode {
     return result
   }
 }
-
-module.exports = PolygonTreeNode

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

@@ -1,11 +1,11 @@
-const Node = require('./Node')
-const PolygonTreeNode = require('./PolygonTreeNode')
+import { Node } from './Node.js'
+import { PolygonTreeNode } from './PolygonTreeNode.js'
 
 // # class Tree
 // This is the root of a BSP tree.
 // This separate class for the root of the tree in order to hold the PolygonTreeNode root.
 // The actual tree is kept in this.rootnode
-class Tree {
+export class Tree {
   constructor (polygons) {
     this.polygonTree = new PolygonTreeNode()
     this.rootnode = new Node(null)
@@ -19,8 +19,8 @@ class Tree {
 
   // Remove all polygons in this BSP tree that are inside the other BSP tree
   // `tree`.
-  clipTo (tree, alsoRemovecoplanarFront = false) {
-    this.rootnode.clipTo(tree, alsoRemovecoplanarFront)
+  clipTo (tree, alsoRemoveCoplanarFront = false) {
+    this.rootnode.clipTo(tree, alsoRemoveCoplanarFront)
   }
 
   allPolygons () {
@@ -30,11 +30,11 @@ class Tree {
   }
 
   addPolygons (polygons) {
-    const polygontreenodes = new Array(polygons.length)
+    const polygonTreeNodes = new Array(polygons.length)
     for (let i = 0; i < polygons.length; i++) {
-      polygontreenodes[i] = this.polygonTree.addChild(polygons[i])
+      polygonTreeNodes[i] = this.polygonTree.addChild(polygons[i])
     }
-    this.rootnode.addPolygonTreeNodes(polygontreenodes)
+    this.rootnode.addPolygonTreeNodes(polygonTreeNodes)
   }
 
   clear () {
@@ -42,9 +42,6 @@ class Tree {
   }
 
   toString () {
-    const result = 'Tree: ' + this.polygonTree.toString('')
-    return result
+    return 'Tree: ' + this.polygonTree.toString('')
   }
 }
-
-module.exports = Tree

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

@@ -1,3 +1 @@
-module.exports = {
-  Tree: require('./Tree')
-}
+export { Tree } from './Tree.js'

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

@@ -1,6 +1,6 @@
-const vec3 = require('../../../maths/vec3')
+import * as vec3 from '../../../maths/vec3/index.js'
 
-const splitLineSegmentByPlane = (plane, p1, p2) => {
+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
@@ -11,5 +11,3 @@ const splitLineSegmentByPlane = (plane, p1, p2) => {
   vec3.add(direction, p1, direction)
   return direction
 }
-
-module.exports = splitLineSegmentByPlane