@jbroll/jscad-modeling 2.12.7

package/src/measurements/measureCenter.js

@@ -0,0 +1,28 @@
+const flatten = require('../utils/flatten')
+
+const measureBoundingBox = require('./measureBoundingBox')
+
+/**
+ * Measure the center of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the center point for each geometry, i.e. [X, Y, Z]
+ * @alias module:modeling/measurements.measureCenter
+ *
+ * @example
+ * let center = measureCenter(sphere())
+ */
+const measureCenter = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    const bounds = measureBoundingBox(geometry)
+    return [
+      (bounds[0][0] + ((bounds[1][0] - bounds[0][0]) / 2)),
+      (bounds[0][1] + ((bounds[1][1] - bounds[0][1]) / 2)),
+      (bounds[0][2] + ((bounds[1][2] - bounds[0][2]) / 2))
+    ]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureCenter

package/src/measurements/measureCenter.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureCenter } = require('./index')
+
+test('measureCenter (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ center: [5, 5] })
+  const acube = cuboid({ center: [-5, -5, -5] })
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lcenter = measureCenter(aline)
+  const rcenter = measureCenter(arect)
+  const ccenter = measureCenter(acube)
+
+  const p2center = measureCenter(apath2)
+  const g2center = measureCenter(ageom2)
+  const g3center = measureCenter(ageom3)
+
+  const ncenter = measureCenter(n)
+  const ocenter = measureCenter(o)
+  const xcenter = measureCenter(x)
+
+  t.deepEqual(lcenter, [12.5, 12.5, 0])
+  t.deepEqual(rcenter, [5, 5, 0])
+  t.deepEqual(ccenter, [-5, -5, -5])
+
+  t.deepEqual(p2center, [0, 0, 0])
+  t.deepEqual(g2center, [0, 0, 0])
+  t.deepEqual(g3center, [0, 0, 0])
+
+  t.deepEqual(ncenter, [0, 0, 0])
+  t.deepEqual(ocenter, [0, 0, 0])
+  t.deepEqual(xcenter, [0, 0, 0])
+})
+
+test('measureCenter (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid({ center: [-5, -5, -5] })
+  const o = {}
+
+  let allcenters = measureCenter(aline, arect, acube, o)
+  t.deepEqual(allcenters, [[12.5, 12.5, 0], [0, 0, 0], [-5, -5, -5], [0, 0, 0]])
+
+  allcenters = measureCenter(aline, arect, acube, o)
+  t.deepEqual(allcenters, [[12.5, 12.5, 0], [0, 0, 0], [-5, -5, -5], [0, 0, 0]])
+})

package/src/measurements/measureCenterOfMass.d.ts

@@ -0,0 +1,7 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureCenterOfMass
+
+declare function measureCenterOfMass(geometry: Geometry): [number, number, number]
+declare function measureCenterOfMass(...geometries: RecursiveArray<Geometry>): [number, number, number][]

package/src/measurements/measureCenterOfMass.js

@@ -0,0 +1,106 @@
+const flatten = require('../utils/flatten')
+
+const vec3 = require('../maths/vec3')
+
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+
+const cacheOfCenterOfMass = new WeakMap()
+
+/*
+ * Measure the center of mass for the given geometry.
+ *
+ * @see http://paulbourke.net/geometry/polygonmesh/
+ * @return {Array} the center of mass for the geometry
+ */
+const measureCenterOfMassGeom2 = (geometry) => {
+  let centerOfMass = cacheOfCenterOfMass.get(geometry)
+  if (centerOfMass !== undefined) return centerOfMass
+
+  const sides = geom2.toSides(geometry)
+
+  let area = 0
+  let x = 0
+  let y = 0
+  if (sides.length > 0) {
+    for (let i = 0; i < sides.length; i++) {
+      const p1 = sides[i][0]
+      const p2 = sides[i][1]
+
+      const a = p1[0] * p2[1] - p1[1] * p2[0]
+      area += a
+      x += (p1[0] + p2[0]) * a
+      y += (p1[1] + p2[1]) * a
+    }
+    area /= 2
+
+    const f = 1 / (area * 6)
+    x *= f
+    y *= f
+  }
+
+  centerOfMass = vec3.fromValues(x, y, 0)
+
+  cacheOfCenterOfMass.set(geometry, centerOfMass)
+  return centerOfMass
+}
+
+/*
+ * Measure the center of mass for the given geometry.
+ * @return {Array} the center of mass for the geometry
+ */
+const measureCenterOfMassGeom3 = (geometry) => {
+  let centerOfMass = cacheOfCenterOfMass.get(geometry)
+  if (centerOfMass !== undefined) return centerOfMass
+
+  centerOfMass = vec3.create() // 0, 0, 0
+
+  const polygons = geom3.toPolygons(geometry)
+  if (polygons.length === 0) return centerOfMass
+
+  let totalVolume = 0
+  const vector = vec3.create() // for speed
+  polygons.forEach((polygon) => {
+    // calculate volume and center of each tetrahedron
+    const vertices = polygon.vertices
+    for (let i = 0; i < vertices.length - 2; i++) {
+      vec3.cross(vector, vertices[i + 1], vertices[i + 2])
+      const volume = vec3.dot(vertices[0], vector) / 6
+
+      totalVolume += volume
+
+      vec3.add(vector, vertices[0], vertices[i + 1])
+      vec3.add(vector, vector, vertices[i + 2])
+      const weightedCenter = vec3.scale(vector, vector, 1 / 4 * volume)
+
+      vec3.add(centerOfMass, centerOfMass, weightedCenter)
+    }
+  })
+  vec3.scale(centerOfMass, centerOfMass, 1 / totalVolume)
+
+  cacheOfCenterOfMass.set(geometry, centerOfMass)
+  return centerOfMass
+}
+
+/**
+ * Measure the center of mass for the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the center of mass for each geometry, i.e. [X, Y, Z]
+ * @alias module:modeling/measurements.measureCenterOfMass
+ *
+ * @example
+ * let center = measureCenterOfMass(sphere())
+ */
+const measureCenterOfMass = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    // NOTE: center of mass for geometry path2 is not possible
+    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
+    if (geom3.isA(geometry)) return measureCenterOfMassGeom3(geometry)
+    return [0, 0, 0]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureCenterOfMass

package/src/measurements/measureCenterOfMass.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { ellipsoid, line, rectangle, cuboid } = require('../primitives')
+
+const { measureCenterOfMass } = require('./index')
+
+test('measureCenterOfMass (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ center: [5, 5] })
+  const acube = cuboid({ size: [3, 3, 3], center: [-15, -5, -10] })
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lcenter = measureCenterOfMass(aline)
+  const rcenter = measureCenterOfMass(arect)
+  const ccenter = measureCenterOfMass(acube)
+
+  const p2center = measureCenterOfMass(apath2)
+  const g2center = measureCenterOfMass(ageom2)
+  const g3center = measureCenterOfMass(ageom3)
+
+  const ncenter = measureCenterOfMass(n)
+  const ocenter = measureCenterOfMass(o)
+  const xcenter = measureCenterOfMass(x)
+
+  t.deepEqual(lcenter, [0, 0, 0])
+  t.deepEqual(rcenter, [5, 5, 0])
+  t.deepEqual(ccenter, [-15, -5, -10])
+
+  t.deepEqual(p2center, [0, 0, 0])
+  t.deepEqual(g2center, [0, 0, 0])
+  t.deepEqual(g3center, [0, 0, 0])
+
+  t.deepEqual(ncenter, [0, 0, 0])
+  t.deepEqual(ocenter, [0, 0, 0])
+  t.deepEqual(xcenter, [0, 0, 0])
+})
+
+test('measureCenterOfMass (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20], center: [10, -10] })
+  const asphere = ellipsoid({ radius: [5, 10, 15], center: [5, -5, 50] })
+  const o = {}
+
+  let allcenters = measureCenterOfMass(aline, arect, asphere, o)
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.999999999999991, -5.000000000000006, 49.999999999999915], [0, 0, 0]])
+
+  allcenters = measureCenterOfMass(aline, arect, asphere, o)
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.999999999999991, -5.000000000000006, 49.999999999999915], [0, 0, 0]])
+})

package/src/measurements/measureDimensions.d.ts

@@ -0,0 +1,7 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureDimensions
+
+declare function measureDimensions(geometry: Geometry): [number, number, number]
+declare function measureDimensions(...geometries: RecursiveArray<Geometry>): [number, number, number][]

package/src/measurements/measureDimensions.js

@@ -0,0 +1,28 @@
+const flatten = require('../utils/flatten')
+
+const measureBoundingBox = require('./measureBoundingBox')
+
+/**
+ * Measure the dimensions of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the dimensions for each geometry, i.e. [width, depth, height]
+ * @alias module:modeling/measurements.measureDimensions
+ *
+ * @example
+ * let dimensions = measureDimensions(sphere())
+ */
+const measureDimensions = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    const boundingBox = measureBoundingBox(geometry)
+    return [
+      boundingBox[1][0] - boundingBox[0][0],
+      boundingBox[1][1] - boundingBox[0][1],
+      boundingBox[1][2] - boundingBox[0][2]
+    ]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureDimensions

package/src/measurements/measureDimensions.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureDimensions } = require('./index')
+
+test('measureDimensions (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const acube = cuboid()
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lbounds = measureDimensions(aline)
+  const rbounds = measureDimensions(arect)
+  const cbounds = measureDimensions(acube)
+
+  const p2bounds = measureDimensions(apath2)
+  const g2bounds = measureDimensions(ageom2)
+  const g3bounds = measureDimensions(ageom3)
+
+  const nbounds = measureDimensions(n)
+  const obounds = measureDimensions(o)
+  const xbounds = measureDimensions(x)
+
+  t.deepEqual(lbounds, [5, 5, 0])
+  t.deepEqual(rbounds, [2, 2, 0])
+  t.deepEqual(cbounds, [2, 2, 2])
+
+  t.deepEqual(p2bounds, [0, 0, 0])
+  t.deepEqual(g2bounds, [0, 0, 0])
+  t.deepEqual(g3bounds, [0, 0, 0])
+
+  t.deepEqual(nbounds, [0, 0, 0])
+  t.deepEqual(obounds, [0, 0, 0])
+  t.deepEqual(xbounds, [0, 0, 0])
+})
+
+test('measureDimensions (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid()
+  const o = {}
+
+  let allbounds = measureDimensions(aline, arect, acube, o)
+  t.deepEqual(allbounds, [[5, 5, 0], [10, 20, 0], [2, 2, 2], [0, 0, 0]])
+
+  allbounds = measureDimensions(aline, arect, acube, o)
+  t.deepEqual(allbounds, [[5, 5, 0], [10, 20, 0], [2, 2, 2], [0, 0, 0]])
+})

package/src/measurements/measureEpsilon.d.ts

@@ -0,0 +1,8 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureEpsilon
+
+declare function measureEpsilon(geometry: Geometry): number
+declare function measureEpsilon(geometry: any): 0
+declare function measureEpsilon(...geometries: RecursiveArray<Geometry | any>): Array<number>

package/src/measurements/measureEpsilon.js

@@ -0,0 +1,48 @@
+const flatten = require('../utils/flatten')
+const { geom2, geom3, path2 } = require('../geometries')
+
+const calculateEpsilonFromBounds = require('./calculateEpsilonFromBounds')
+const measureBoundingBox = require('./measureBoundingBox')
+
+/*
+ * Measure the epsilon of the given (path2) geometry.
+ * @return {Number} the epsilon (precision) of the geometry
+ */
+const measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+
+/*
+ * Measure the epsilon of the given (geom2) geometry.
+ * @return {Number} the epsilon (precision) of the geometry
+ */
+const measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+
+/*
+ * Measure the epsilon of the given (geom3) geometry.
+ * @return {Float} the epsilon (precision) of the geometry
+ */
+const measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
+
+/**
+ * Measure the epsilon of the given geometries.
+ * Epsilon values are used in various functions to determine minimum distances between points, planes, etc.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Number|Array} the epsilon, or a list of epsilons for each geometry
+ * @alias module:modeling/measurements.measureEpsilon
+ *
+ * @example
+ * let epsilon = measureEpsilon(sphere())
+ */
+const measureEpsilon = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return measureEpsilonOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureEpsilonOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureEpsilonOfGeom3(geometry)
+    return 0
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureEpsilon

package/src/measurements/measureEpsilon.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureEpsilon } = require('./index')
+
+test('measureEpsilon (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const acube = cuboid()
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lepsilon = measureEpsilon(aline)
+  const repsilon = measureEpsilon(arect)
+  const cepsilon = measureEpsilon(acube)
+
+  const p2epsilon = measureEpsilon(apath2)
+  const g2epsilon = measureEpsilon(ageom2)
+  const g3epsilon = measureEpsilon(ageom3)
+
+  const nepsilon = measureEpsilon(n)
+  const oepsilon = measureEpsilon(o)
+  const xepsilon = measureEpsilon(x)
+
+  t.is(lepsilon, 0.00005)
+  t.is(repsilon, 0.00002)
+  t.is(cepsilon, 0.00002)
+
+  t.is(p2epsilon, 0)
+  t.is(g2epsilon, 0)
+  t.is(g3epsilon, 0)
+
+  t.is(nepsilon, 0)
+  t.is(oepsilon, 0)
+  t.is(xepsilon, 0)
+})
+
+test('measureEpsilon (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid()
+  const o = {}
+
+  let allepsilon = measureEpsilon(aline, arect, acube, o)
+  t.deepEqual(allepsilon, [0.00005, 0.00015000000000000001, 0.00002, 0.0])
+
+  allepsilon = measureEpsilon(aline, arect, acube, o)
+  t.deepEqual(allepsilon, [0.00005, 0.00015000000000000001, 0.00002, 0.0])
+})

package/src/measurements/measureVolume.d.ts

@@ -0,0 +1,8 @@
+import { Geometry } from '../geometries/types'
+import RecursiveArray from '../utils/recursiveArray'
+
+export default measureVolume
+
+declare function measureVolume(geometry: Geometry): number
+declare function measureVolume(geometry: any): 0
+declare function measureVolume(...geometries: RecursiveArray<Geometry | any>): Array<number>

package/src/measurements/measureVolume.js

@@ -0,0 +1,68 @@
+const flatten = require('../utils/flatten')
+
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+const path2 = require('../geometries/path2')
+const poly3 = require('../geometries/poly3')
+
+const cache = new WeakMap()
+
+/*
+ * Measure the volume of the given geometry.
+ * NOTE: paths are infinitely narrow and do not have an volume
+ *
+ * @param {Path2} geometry - geometry to measure
+ * @returns {Number} volume of the geometry
+ */
+const measureVolumeOfPath2 = () => 0
+
+/*
+ * Measure the volume of the given geometry.
+ * NOTE: 2D geometry are infinitely thin and do not have an volume
+ *
+ * @param {Geom2} geometry - 2D geometry to measure
+ * @returns {Number} volume of the geometry
+ */
+const measureVolumeOfGeom2 = () => 0
+
+/*
+ * Measure the volume of the given geometry.
+ *
+ * @param {Geom3} geometry - 3D geometry to measure
+ * @returns {Number} volume of the geometry
+ */
+const measureVolumeOfGeom3 = (geometry) => {
+  let volume = cache.get(geometry)
+  if (volume) return volume
+
+  const polygons = geom3.toPolygons(geometry)
+  volume = polygons.reduce((volume, polygon) => volume + poly3.measureSignedVolume(polygon), 0)
+
+  cache.set(geometry, volume)
+
+  return volume
+}
+
+/**
+ * Measure the volume of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Number|Array} the volume, or a list of volumes for each geometry
+ * @alias module:modeling/measurements.measureVolume
+ *
+ * @example
+ * let volume = measureVolume(sphere())
+ */
+const measureVolume = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return measureVolumeOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureVolumeOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureVolumeOfGeom3(geometry)
+    return 0
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureVolume

package/src/measurements/measureVolume.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureVolume } = require('./index')
+
+test('measureVolume: single objects', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const acube = cuboid()
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lvolume = measureVolume(aline)
+  const rvolume = measureVolume(arect)
+  const cvolume = measureVolume(acube)
+
+  const p2volume = measureVolume(apath2)
+  const g2volume = measureVolume(ageom2)
+  const g3volume = measureVolume(ageom3)
+
+  const nvolume = measureVolume(n)
+  const ovolume = measureVolume(o)
+  const xvolume = measureVolume(x)
+
+  t.is(lvolume, 0)
+  t.is(rvolume, 0)
+  t.is(cvolume, 7.999999999999999)
+
+  t.is(p2volume, 0)
+  t.is(g2volume, 0)
+  t.is(g3volume, 0)
+
+  t.is(nvolume, 0)
+  t.is(ovolume, 0)
+  t.is(xvolume, 0)
+})
+
+test('measureVolume (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [5, 10] })
+  const acube = cuboid({ size: [10, 20, 40] })
+  const o = {}
+
+  let allvolume = measureVolume(aline, arect, acube, o)
+  t.deepEqual(allvolume, [0, 0, 7999.999999999999, 0])
+
+  allvolume = measureVolume(aline, arect, acube, o)
+  t.deepEqual(allvolume, [0, 0, 7999.999999999999, 0])
+})

package/src/measurements/types.d.ts

@@ -0,0 +1,3 @@
+import Vec3 from '../maths/vec3/type'
+
+export type BoundingBox = [Vec3, Vec3]

package/src/operations/booleans/fromFakePolygons.js

@@ -0,0 +1,52 @@
+const vec2 = require('../../maths/vec2')
+
+const geom2 = require('../../geometries/geom2')
+
+const fromFakePolygon = (epsilon, polygon) => {
+  // this can happen based on union, seems to be residuals -
+  // return null and handle in caller
+  if (polygon.vertices.length < 4) {
+    return null
+  }
+  const vert1Indices = []
+  const points3D = polygon.vertices.filter((vertex, i) => {
+    if (vertex[2] > 0) {
+      vert1Indices.push(i)
+      return true
+    }
+    return false
+  })
+
+  if (points3D.length !== 2) {
+    throw new Error('Assertion failed: fromFakePolygon: not enough points found') // TBD remove later
+  }
+
+  const points2D = points3D.map((v3) => {
+    const x = Math.round(v3[0] / epsilon) * epsilon + 0 // no more -0
+    const y = Math.round(v3[1] / epsilon) * epsilon + 0 // no more -0
+    return vec2.fromValues(x, y)
+  })
+
+  if (vec2.equals(points2D[0], points2D[1])) return null
+
+  const d = vert1Indices[1] - vert1Indices[0]
+  if (d === 1 || d === 3) {
+    if (d === 1) {
+      points2D.reverse()
+    }
+  } else {
+    throw new Error('Assertion failed: fromFakePolygon: unknown index ordering')
+  }
+  return points2D
+}
+
+/*
+ * Convert the given polygons to a list of sides.
+ * The polygons must have only z coordinates +1 and -1, as constructed by to3DWalls().
+ */
+const fromFakePolygons = (epsilon, polygons) => {
+  const sides = polygons.map((polygon) => fromFakePolygon(epsilon, polygon)).filter((polygon) => (polygon !== null))
+  return geom2.create(sides)
+}
+
+module.exports = fromFakePolygons

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

@@ -0,0 +1,6 @@
+export { default as intersect } from './intersect'
+export { default as subtract } from './subtract'
+export { default as union } from './union'
+export { default as scission } from './scission'
+
+export as namespace booleans