@jbroll/jscad-modeling 2.12.7

package/src/operations/booleans/subtract.js

@@ -0,0 +1,47 @@
+const flatten = require('../../utils/flatten')
+const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+
+const subtractGeom2 = require('./subtractGeom2')
+const subtractGeom3 = require('./subtractGeom3')
+
+/**
+ * Return a new geometry representing space in the first geometry but
+ * not in all subsequent geometries.
+ * 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
+ * @alias module:modeling/booleans.subtract
+ *
+ * @example
+ * let myshape = subtract(cuboid({size: 5}), cuboid({size: 5, center: [3,3,3]}))
+ *
+ * @example
+ * +-------+            +-------+
+ * |       |            |       |
+ * |   A   |            |       |
+ * |    +--+----+   =   |    +--+
+ * +----+--+    |       +----+
+ *      |   B   |
+ *      |       |
+ *      +-------+
+ */
+const subtract = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  if (!areAllShapesTheSameType(geometries)) {
+    throw new Error('only subtract of the types are supported')
+  }
+
+  const geometry = geometries[0]
+  // if (path.isA(geometry)) return pathsubtract(matrix, geometries)
+  if (geom2.isA(geometry)) return subtractGeom2(geometries)
+  if (geom3.isA(geometry)) return subtractGeom3(geometries)
+  return geometry
+}
+
+module.exports = subtract

package/src/operations/booleans/subtractGeom2.js

@@ -0,0 +1,27 @@
+const flatten = require('../../utils/flatten')
+
+const geom3 = require('../../geometries/geom3')
+
+const measureEpsilon = require('../../measurements/measureEpsilon')
+
+const fromFakePolygons = require('./fromFakePolygons')
+const to3DWalls = require('./to3DWalls')
+const subtractGeom3 = require('./subtractGeom3')
+
+/*
+ * 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
+ * @returns {geom2} new 2D geometry
+ */
+const subtract = (...geometries) => {
+  geometries = flatten(geometries)
+  const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry))
+
+  const newgeom3 = subtractGeom3(newgeometries)
+  const epsilon = measureEpsilon(newgeom3)
+
+  return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3))
+}
+
+module.exports = subtract

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

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 0)
+  t.deepEqual(obs, exp)
+})

package/src/operations/booleans/subtractGeom3.js

@@ -0,0 +1,25 @@
+const flatten = require('../../utils/flatten')
+
+const retessellate = require('../modifiers/retessellate')
+
+const subtractSub = require('./subtractGeom3Sub')
+
+/*
+ * 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
+ * @returns {geom3} new 3D geometry
+ */
+const subtract = (...geometries) => {
+  geometries = flatten(geometries)
+
+  let newgeometry = geometries.shift()
+  geometries.forEach((geometry) => {
+    newgeometry = subtractSub(newgeometry, geometry)
+  })
+
+  newgeometry = retessellate(newgeometry)
+  return newgeometry
+}
+
+module.exports = subtract

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

@@ -0,0 +1,109 @@
+const test = require('ava')
+
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const { geom3 } = require('../../geometries')
+
+const { sphere, cuboid } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom3 objects produces expected geometry', (t) => {
+  const geometry1 = sphere({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom3.toPoints(result1)
+  let exp = [
+    [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
+      [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
+    [[1.4142135623730951, 0, 1.414213562373095], [1.0000000000000002, -1, 1.414213562373095],
+      [1.4142135623730951, -1.414213562373095, 0], [2, 0, 0]],
+    [[1.4142135623730951, 0, -1.414213562373095], [1.0000000000000002, -1, -1.414213562373095], [1.2246467991473532e-16, 0, -2]],
+    [[1.2246467991473532e-16, 0, 2], [1.0000000000000002, -1, 1.414213562373095], [1.4142135623730951, 0, 1.414213562373095]],
+    [[1.4142135623730951, -1.414213562373095, 0], [1.2246467991473532e-16, -2, 0],
+      [8.659560562354934e-17, -1.4142135623730951, -1.414213562373095], [1.0000000000000002, -1, -1.414213562373095]],
+    [[1.0000000000000002, -1, 1.414213562373095], [8.659560562354934e-17, -1.4142135623730951, 1.414213562373095],
+      [1.2246467991473532e-16, -2, 0], [1.4142135623730951, -1.414213562373095, 0]],
+    [[1.0000000000000002, -1, -1.414213562373095], [8.659560562354934e-17, -1.4142135623730951, -1.414213562373095], [8.659560562354934e-17, -8.659560562354932e-17, -2]],
+    [[8.659560562354934e-17, -8.659560562354932e-17, 2], [8.659560562354934e-17, -1.4142135623730951, 1.414213562373095], [1.0000000000000002, -1, 1.414213562373095]],
+    [[1.2246467991473532e-16, -2, 0], [-1.414213562373095, -1.4142135623730951, 0],
+      [-1, -1.0000000000000002, -1.414213562373095], [8.659560562354934e-17, -1.4142135623730951, -1.414213562373095]],
+    [[8.659560562354934e-17, -1.4142135623730951, 1.414213562373095], [-1, -1.0000000000000002, 1.414213562373095],
+      [-1.414213562373095, -1.4142135623730951, 0], [1.2246467991473532e-16, -2, 0]],
+    [[8.659560562354934e-17, -1.4142135623730951, -1.414213562373095], [-1, -1.0000000000000002, -1.414213562373095], [7.498798913309288e-33, -1.2246467991473532e-16, -2]],
+    [[7.498798913309288e-33, -1.2246467991473532e-16, 2], [-1, -1.0000000000000002, 1.414213562373095], [8.659560562354934e-17, -1.4142135623730951, 1.414213562373095]],
+    [[-1.414213562373095, -1.4142135623730951, 0], [-2, -2.4492935982947064e-16, 0],
+      [-1.4142135623730951, -1.7319121124709868e-16, -1.414213562373095], [-1, -1.0000000000000002, -1.414213562373095]],
+    [[-1, -1.0000000000000002, 1.414213562373095], [-1.4142135623730951, -1.7319121124709868e-16, 1.414213562373095],
+      [-2, -2.4492935982947064e-16, 0], [-1.414213562373095, -1.4142135623730951, 0]],
+    [[-1, -1.0000000000000002, -1.414213562373095], [-1.4142135623730951, -1.7319121124709868e-16, -1.414213562373095], [-8.659560562354932e-17, -8.659560562354934e-17, -2]],
+    [[-8.659560562354932e-17, -8.659560562354934e-17, 2], [-1.4142135623730951, -1.7319121124709868e-16, 1.414213562373095], [-1, -1.0000000000000002, 1.414213562373095]],
+    [[-2, -2.4492935982947064e-16, 0], [-1.4142135623730954, 1.414213562373095, 0],
+      [-1.0000000000000002, 1, -1.414213562373095], [-1.4142135623730951, -1.7319121124709868e-16, -1.414213562373095]],
+    [[-1.4142135623730951, -1.7319121124709868e-16, 1.414213562373095], [-1.0000000000000002, 1, 1.414213562373095],
+      [-1.4142135623730954, 1.414213562373095, 0], [-2, -2.4492935982947064e-16, 0]],
+    [[-1.4142135623730951, -1.7319121124709868e-16, -1.414213562373095], [-1.0000000000000002, 1, -1.414213562373095], [-1.2246467991473532e-16, -1.4997597826618576e-32, -2]],
+    [[-1.2246467991473532e-16, -1.4997597826618576e-32, 2], [-1.0000000000000002, 1, 1.414213562373095], [-1.4142135623730951, -1.7319121124709868e-16, 1.414213562373095]],
+    [[-1.4142135623730954, 1.414213562373095, 0], [-3.6739403974420594e-16, 2, 0],
+      [-2.59786816870648e-16, 1.4142135623730951, -1.414213562373095], [-1.0000000000000002, 1, -1.414213562373095]],
+    [[-1.0000000000000002, 1, 1.414213562373095], [-2.59786816870648e-16, 1.4142135623730951, 1.414213562373095],
+      [-3.6739403974420594e-16, 2, 0], [-1.4142135623730954, 1.414213562373095, 0]],
+    [[-1.0000000000000002, 1, -1.414213562373095], [-2.59786816870648e-16, 1.4142135623730951, -1.414213562373095], [-8.659560562354935e-17, 8.659560562354932e-17, -2]],
+    [[-8.659560562354935e-17, 8.659560562354932e-17, 2], [-2.59786816870648e-16, 1.4142135623730951, 1.414213562373095], [-1.0000000000000002, 1, 1.414213562373095]],
+    [[-3.6739403974420594e-16, 2, 0], [1.4142135623730947, 1.4142135623730954, 0],
+      [0.9999999999999998, 1.0000000000000002, -1.414213562373095], [-2.59786816870648e-16, 1.4142135623730951, -1.414213562373095]],
+    [[-2.59786816870648e-16, 1.4142135623730951, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095],
+      [1.4142135623730947, 1.4142135623730954, 0], [-3.6739403974420594e-16, 2, 0]],
+    [[-2.59786816870648e-16, 1.4142135623730951, -1.414213562373095], [0.9999999999999998, 1.0000000000000002, -1.414213562373095], [-2.2496396739927864e-32, 1.2246467991473532e-16, -2]],
+    [[-2.2496396739927864e-32, 1.2246467991473532e-16, 2], [0.9999999999999998, 1.0000000000000002, 1.414213562373095], [-2.59786816870648e-16, 1.4142135623730951, 1.414213562373095]],
+    [[1.4142135623730947, 1.4142135623730954, 0], [2, 4.898587196589413e-16, 0],
+      [1.4142135623730951, 3.4638242249419736e-16, -1.414213562373095], [0.9999999999999998, 1.0000000000000002, -1.414213562373095]],
+    [[0.9999999999999998, 1.0000000000000002, 1.414213562373095], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095],
+      [2, 4.898587196589413e-16, 0], [1.4142135623730947, 1.4142135623730954, 0]],
+    [[0.9999999999999998, 1.0000000000000002, -1.414213562373095], [1.4142135623730951, 3.4638242249419736e-16, -1.414213562373095], [8.65956056235493e-17, 8.659560562354935e-17, -2]],
+    [[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(obs.length, 32)
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom3.toPoints(result2)
+  t.notThrows.skip(() => geom3.validate(result2))
+  t.is(obs.length, 32)
+
+  // subtract of two partially overlapping objects
+  const geometry3 = cuboid({ size: [18, 18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom3.toPoints(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]],
+    [[8, 8, 12], [12, 8, 12], [12, 12, 12], [8, 12, 12]],
+    [[9, 8, 8], [9, 8, 9], [9, 9, 9], [9, 9, 8]],
+    [[8, 9, 8], [9, 9, 8], [9, 9, 9], [8, 9, 9]],
+    [[8, 8, 9], [8, 9, 9], [9, 9, 9], [9, 8, 9]],
+    [[8, 12, 12], [8, 12, 9], [8, 8, 9], [8, 8, 12]],
+    [[8, 12, 9], [8, 12, 8], [8, 9, 8], [8, 9, 9]],
+    [[8, 8, 12], [8, 8, 9], [12, 8, 9], [12, 8, 12]],
+    [[9, 8, 9], [9, 8, 8], [12, 8, 8], [12, 8, 9]],
+    [[12, 12, 8], [12, 9, 8], [8, 9, 8], [8, 12, 8]],
+    [[12, 9, 8], [12, 8, 8], [9, 8, 8], [9, 9, 8]]
+  ]
+  t.notThrows.skip(() => geom3.validate(result3))
+  t.is(obs.length, 12)
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom3.toPoints(result4)
+  t.notThrows(() => geom3.validate(result4))
+  t.is(obs.length, 0)
+})

package/src/operations/booleans/subtractGeom3Sub.js

@@ -0,0 +1,31 @@
+const geom3 = require('../../geometries/geom3')
+
+const mayOverlap = require('./mayOverlap')
+const { Tree } = require('./trees')
+
+/*
+ * 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
+ */
+const subtractGeom3Sub = (geometry1, geometry2) => {
+  if (!mayOverlap(geometry1, geometry2)) {
+    return geom3.clone(geometry1)
+  }
+
+  const a = new Tree(geom3.toPolygons(geometry1))
+  const b = new Tree(geom3.toPolygons(geometry2))
+
+  a.invert()
+  a.clipTo(b)
+  b.clipTo(a, true)
+  a.addPolygons(b.allPolygons())
+  a.invert()
+
+  const newpolygons = a.allPolygons()
+  return geom3.create(newpolygons)
+}
+
+module.exports = subtractGeom3Sub

package/src/operations/booleans/to3DWalls.js

@@ -0,0 +1,36 @@
+const vec3 = require('../../maths/vec3')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+/*
+ * Create a polygon (wall) from the given Z values and side.
+ */
+const to3DWall = (z0, z1, side) => {
+  const points = [
+    vec3.fromVec2(vec3.create(), side[0], z0),
+    vec3.fromVec2(vec3.create(), side[1], z0),
+    vec3.fromVec2(vec3.create(), side[1], z1),
+    vec3.fromVec2(vec3.create(), side[0], z1)
+  ]
+  return poly3.create(points)
+}
+
+/*
+ * Create a 3D geometry with walls, as constructed from the given options and geometry.
+ *
+ * @param {Object} options - options with Z offsets
+ * @param {geom2} geometry - geometry used as base of walls
+ * @return {geom3} the new geometry
+ */
+const to3DWalls = (options, geometry) => {
+  const sides = geom2.toSides(geometry)
+
+  const polygons = sides.map((side) => to3DWall(options.z0, options.z1, side))
+
+  const result = geom3.create(polygons)
+  return result
+}
+
+module.exports = to3DWalls

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

@@ -0,0 +1,144 @@
+const plane = require('../../../maths/plane')
+const poly3 = require('../../../geometries/poly3')
+
+// # 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.
+// 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 {
+  constructor (parent) {
+    this.plane = null
+    this.front = null
+    this.back = null
+    this.polygontreenodes = []
+    this.parent = parent
+  }
+
+  // Convert solid space to empty space and empty space to solid space.
+  invert () {
+    const queue = [this]
+    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)
+      const temp = node.front
+      node.front = node.back
+      node.back = temp
+    }
+  }
+
+  // clip polygontreenodes to our plane
+  // calls remove() for all clipped PolygonTreeNodes
+  clipPolygons (polygontreenodes, alsoRemovecoplanarFront) {
+    let current = { node: this, polygontreenodes: polygontreenodes }
+    let node
+    const stack = []
+
+    do {
+      node = current.node
+      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()) {
+            // 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)
+          }
+        }
+
+        if (node.front && (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)) {
+          // add back node for further splitting
+          stack.push({ node: node.back, polygontreenodes: backnodes })
+        } else {
+          // remove all back nodes from processing
+          for (let i = 0; i < numbacknodes; i++) {
+            backnodes[i].remove()
+          }
+        }
+      }
+      current = stack.pop()
+    } while (current !== undefined)
+  }
+
+  // Remove all polygons in this BSP tree that are inside the other BSP tree
+  // `tree`.
+  clipTo (tree, alsoRemovecoplanarFront) {
+    let node = this
+    const stack = []
+    do {
+      if (node.polygontreenodes.length > 0) {
+        tree.rootnode.clipPolygons(node.polygontreenodes, alsoRemovecoplanarFront)
+      }
+      if (node.front) stack.push(node.front)
+      if (node.back) stack.push(node.back)
+      node = stack.pop()
+    } while (node !== undefined)
+  }
+
+  addPolygonTreeNodes (newpolygontreenodes) {
+    let current = { node: this, polygontreenodes: newpolygontreenodes }
+    const stack = []
+    do {
+      const node = current.node
+      const polygontreenodes = current.polygontreenodes
+
+      if (polygontreenodes.length === 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)
+      }
+      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)
+      }
+
+      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 })
+      }
+      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
+
+        if (stopCondition) node.back.polygontreenodes = backnodes
+        else stack.push({ node: node.back, polygontreenodes: backnodes })
+      }
+
+      current = stack.pop()
+    } while (current !== undefined)
+  }
+}
+
+module.exports = Node