@jscad/modeling 3.0.0-alpha.0 → 3.0.2-alpha.0

package/src/operations/booleans/martinez/sweepEvent.js

@@ -9,9 +9,9 @@ export class SweepEvent {
    * @param {boolean} left
    * @param {SweepEvent=} otherEvent
    * @param {boolean} isSubject
-   * @param {number} edgeType
+   * @param {number} type OPTIONAL
    */
-  constructor (point, left, otherEvent, isSubject, edgeType) {
+  constructor (point, left, otherEvent, isSubject, type = NORMAL) {
     /**
      * Is left endpoint?
      * @type {Boolean}
@@ -39,7 +39,7 @@ export class SweepEvent {
      * Edge contribution type
      * @type {Number}
      */
-    this.type = edgeType || NORMAL
+    this.type = type
 
     /**
      * In-out transition for the sweepline crossing polygon
@@ -115,18 +115,4 @@ export class SweepEvent {
   get inResult () {
     return this.resultTransition !== 0
   }
-
-  clone () {
-    const copy = new SweepEvent(
-      this.point, this.left, this.otherEvent, this.isSubject, this.type)
-
-    copy.contourId = this.contourId
-    copy.resultTransition = this.resultTransition
-    copy.prevInResult = this.prevInResult
-    copy.isExteriorRing = this.isExteriorRing
-    copy.inOut = this.inOut
-    copy.otherInOut = this.otherInOut
-
-    return copy
-  }
 }

package/src/operations/booleans/mayOverlap.js

@@ -2,7 +2,6 @@ import { EPS } from '../../maths/constants.js'
 
 import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
 
-
 /*
  * Determine if the given geometries overlap by comparing min and max bounds.
  * NOTE: This is used in union for performance gains.

package/src/operations/booleans/scission.d.ts

@@ -0,0 +1,5 @@
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
+
+export function scission(...geometries: RecursiveArray<Geom3>): Geom3
+export function scission(...geometries: RecursiveArray<Geom3>): Array<Geom3>

package/src/operations/booleans/scission.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom3 from '../../geometries/geom3/index.js'
 
 import { scissionGeom3 } from './scissionGeom3.js'
@@ -7,6 +5,8 @@ import { scissionGeom3 } from './scissionGeom3.js'
 /**
  * Scission (divide) the given geometry into the component pieces.
  *
+ * NOTE: Currently only 3D geometries are supported.
+ *
  * @param {...Object} objects - list of geometries
  * @returns {Array} list of pieces from each geometry
  * @alias module:modeling/booleans.scission
@@ -26,13 +26,11 @@ import { scissionGeom3 } from './scissionGeom3.js'
  *      +-------+            +-------+
  */
 export const scission = (...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     // if (path2.isA(object)) return path2.transform(matrix, object)
     // if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return scissionGeom3(object)
+    if (Array.isArray(object)) return scission(...object)
     return object
   })
   return results.length === 1 ? results[0] : results

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

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../../geometries/index.js'
 
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { cube, torus } from '../../primitives/index.js'
 
 import { scission, union } from './index.js'
@@ -42,6 +44,10 @@ test('scission: scission of complex geom3 produces expected geometry', (t) => {
   t.is(result1.length, 2)
   t.notThrows.skip(() => geom3.validate(result1[0]))
   t.notThrows.skip(() => geom3.validate(result1[1]))
+  t.is(measureArea(result1[0]), 7720.0306508548)
+  t.is(measureArea(result1[1]), 3860.0153254273987)
+  t.is(measureVolume(result1[0]), 18745.166004060953)
+  t.is(measureVolume(result1[1]), 9372.583002030477)
 
   const rc1 = geom3.toPolygons(result1[0]).length
   const rc2 = geom3.toPolygons(result1[1]).length

package/src/operations/booleans/subtract.js

@@ -1,5 +1,5 @@
 import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
-import { flatten } from '../../utils/flatten.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -13,11 +13,11 @@ import { subtractGeom3 } from './subtractGeom3.js'
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {Geom2|geom3} a new geometry
+ * @returns {Geom2|Geom3} a new geometry
  * @alias module:modeling/booleans.subtract
  *
  * @example
- * let myshape = subtract(cuboid({size: [5,5,5]}), cuboid({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = subtract(cuboid({size: 5}), cuboid({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+            +-------+
@@ -30,9 +30,9 @@ import { subtractGeom3 } from './subtractGeom3.js'
  *      +-------+
  */
 export const subtract = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('subtract wrong number of arguments')
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('subtract arguments must be the same geometry type')
   }

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

@@ -4,11 +4,11 @@ import { geom2, geom3 } from '../../geometries/index.js'
 
 import { subtract } from './index.js'
 
-test('subtract error wrong number of arguments', (t) => {
-  const message = 'subtract wrong number of arguments'
-  t.throws(() => subtract(), { message })
-  t.throws(() => subtract([]), { message })
-  t.throws(() => subtract([[], []]), { message })
+test('subtract empty arguments', (t) => {
+  t.is(subtract(), undefined)
+  t.is(subtract([]), undefined)
+  t.is(subtract([[], []]), undefined)
+  t.is(subtract(null, null), undefined)
 })
 
 test('subtract error different geometry types', (t) => {
@@ -20,6 +20,5 @@ test('subtract error non-geometries', (t) => {
   const message = 'subtract unsupported geometry type'
   t.throws(() => subtract([1, 2, 3], [4, 5, 6]), { message })
   t.throws(() => subtract([], [123]), { message })
-  t.throws(() => subtract("one", "two"), { message })
-  t.throws(() => subtract(null, null), { message })
+  t.throws(() => subtract('one', 'two'), { message })
 })

package/src/operations/booleans/subtractGeom2.js

@@ -1,17 +1,13 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { DIFFERENCE } from './martinez/operation.js'
 import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing space in the first geometry but
  * not in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom2} geometries - list of geometries
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new 2D geometry
  */
-export const subtractGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const subtractGeom2 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = boolean(newGeometry, geometry, DIFFERENCE)

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

@@ -6,7 +6,7 @@ import { geom2 } from '../../geometries/index.js'
 
 import { measureArea } from '../../measurements/index.js'
 
-import { circle, rectangle } from '../../primitives/index.js'
+import { circle, rectangle, square } from '../../primitives/index.js'
 
 import { center } from '../transforms/index.js'
 
@@ -75,3 +75,27 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   t.is(obs.length, 0)
   t.deepEqual(obs, exp)
 })
+
+test('subtract with undefined/null values', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})
+
+test('subtract of nested arrays', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})

package/src/operations/booleans/subtractGeom3.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { retessellate } from '../modifiers/retessellate.js'
 
 import { subtractGeom3Sub } from './subtractGeom3Sub.js'
@@ -7,12 +5,10 @@ import { subtractGeom3Sub } from './subtractGeom3Sub.js'
 /*
  * Return a new 3D geometry representing space in this geometry but not in the given geometries.
  * Neither this geometry nor the given geometries are modified.
- * @param {...geom3} geometries - list of geometries
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new 3D geometry
  */
-export const subtractGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const subtractGeom3 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = subtractGeom3Sub(newGeometry, geometry)

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

@@ -4,7 +4,7 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { sphere, cuboid } from '../../primitives/index.js'
 
@@ -69,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(measureArea(result1), 44.053756306589825)
   t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -79,6 +80,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(measureArea(result2), 44.053756306589825)
   t.is(measureVolume(result2), 25.751611331979678)
   t.is(obs.length, 32)
 
@@ -102,6 +104,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(measureArea(result3), 96)
   t.is(measureVolume(result3), 63)
   t.is(obs.length, 12)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -110,6 +113,7 @@ 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(measureArea(result4), 0)
   t.is(measureVolume(result4), 0)
   t.is(obs.length, 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()