@jscad/modeling 2.5.3 → 2.7.1

package/src/maths/plane/fromPoints.js

@@ -10,17 +10,39 @@ const vec3 = require('../vec3')
  * @returns {plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */
-const fromPoints = (out, a, b, c) => {
-  const ba = vec3.subtract(vec3.create(), b, a)
-  const ca = vec3.subtract(vec3.create(), c, a)
-  vec3.cross(ba, ba, ca)
-  vec3.normalize(ba, ba) // normal part
-  const w = vec3.dot(ba, a)
+const fromPoints = (out, ...vertices) => {
+  const len = vertices.length
 
-  out[0] = ba[0]
-  out[1] = ba[1]
-  out[2] = ba[2]
-  out[3] = w
+  // Calculate normal vector for a single vertex
+  // Inline to avoid allocations
+  const ba = vec3.create()
+  const ca = vec3.create()
+  const vertexNormal = (index) => {
+    const a = vertices[index]
+    const b = vertices[(index + 1) % len]
+    const c = vertices[(index + 2) % len]
+    vec3.subtract(ba, b, a) // ba = b - a
+    vec3.subtract(ca, c, a) // ca = c - a
+    vec3.cross(ba, ba, ca) // ba = ba x ca
+    vec3.normalize(ba, ba)
+    return ba
+  }
+
+  out[0] = 0
+  out[1] = 0
+  out[2] = 0
+  if (len === 3) {
+    // optimization for triangles, which are always coplanar
+    vec3.copy(out, vertexNormal(0))
+  } else {
+    // sum of vertex normals
+    vertices.forEach((v, i) => {
+      vec3.add(out, out, vertexNormal(i))
+    })
+    // renormalize normal vector
+    vec3.normalize(out, out)
+  }
+  out[3] = vec3.dot(out, vertices[0])
   return out
 }
 

package/src/maths/plane/fromPoints.test.js

@@ -13,4 +13,8 @@ test('plane: fromPoints() should return a new plane with correct values', (t) =>
   // planes created from the same points results in an invalid plane
   const obs3 = fromPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
   t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // polygon with co-linear vertices
+  const obs4 = fromPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
 })

package/src/measurements/index.js

@@ -1,6 +1,5 @@
 /**
  * All shapes (primitives or the results of operations) can be measured, e.g. calculate volume, etc.
- * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/measurements
  * @example
  * const { measureArea, measureBoundingBox, measureVolume } = require('@jscad/modeling').measurements
@@ -12,6 +11,10 @@ module.exports = {
   measureAggregateVolume: require('./measureAggregateVolume'),
   measureArea: require('./measureArea'),
   measureBoundingBox: require('./measureBoundingBox'),
+  measureBoundingSphere: require('./measureBoundingSphere'),
+  measureCenter: require('./measureCenter'),
+  measureCenterOfMass: require('./measureCenterOfMass'),
+  measureDimensions: require('./measureDimensions'),
   measureEpsilon: require('./measureEpsilon'),
   measureVolume: require('./measureVolume')
 }

package/src/measurements/measureBoundingBox.test.js

@@ -4,6 +4,8 @@ const { geom2, geom3, path2 } = require('../geometries')
 
 const { line, rectangle, cuboid } = require('../primitives')
 
+const { mirror } = require('../operations/transforms')
+
 const { measureBoundingBox } = require('./index')
 
 test('measureBoundingBox (single objects)', (t) => {
@@ -56,3 +58,9 @@ test('measureBoundingBox (multiple objects)', (t) => {
   allbounds = measureBoundingBox(aline, arect, acube, o)
   t.deepEqual(allbounds, [[[10, 10, 0], [15, 15, 0]], [[-5, -10, 0], [5, 10, 0]], [[-1, -1, -1], [1, 1, 1]], [[0, 0, 0], [0, 0, 0]]])
 })
+
+test('measureBoundingBox invert', (t) => {
+  const acube = mirror({}, cuboid())
+  const cbounds = measureBoundingBox(acube)
+  t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
+})

package/src/measurements/measureBoundingSphere.js

@@ -0,0 +1,146 @@
+const flatten = require('../utils/flatten')
+
+const vec2 = require('../maths/vec2')
+const vec3 = require('../maths/vec3')
+
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+const path2 = require('../geometries/path2')
+const poly3 = require('../geometries/poly3')
+
+const cacheOfBoundingSpheres = new WeakMap()
+
+/*
+ * Measure the bounding sphere of the given (path2) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfPath2 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const points = path2.toPoints(geometry)
+
+  if (points.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    const temp = vec3.create()
+    points.forEach((point) => {
+      vec3.add(centroid, centroid, vec3.fromVec2(temp, point, 0))
+      numPoints++
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    points.forEach((point) => {
+      radius = Math.max(radius, vec2.squaredDistance(centroid, point))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/*
+ * Measure the bounding sphere of the given (geom2) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfGeom2 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const sides = geom2.toSides(geometry)
+
+  if (sides.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    const temp = vec3.create()
+    sides.forEach((side) => {
+      vec3.add(centroid, centroid, vec3.fromVec2(temp, side[0], 0))
+      numPoints++
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    sides.forEach((side) => {
+      radius = Math.max(radius, vec2.squaredDistance(centroid, side[0]))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/*
+ * Measure the bounding sphere of the given (geom3) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfGeom3 = (geometry) => {
+  let boundingSphere = cacheOfBoundingSpheres.get(geometry)
+  if (boundingSphere !== undefined) return boundingSphere
+
+  const centroid = vec3.create()
+  let radius = 0
+
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length > 0) {
+    // calculate the centriod of the geometry
+    let numPoints = 0
+    polygons.forEach((polygon) => {
+      poly3.toPoints(polygon).forEach((point) => {
+        vec3.add(centroid, centroid, point)
+        numPoints++
+      })
+    })
+    vec3.scale(centroid, centroid, 1 / numPoints)
+
+    // find the farthest point from the centroid
+    polygons.forEach((polygon) => {
+      poly3.toPoints(polygon).forEach((point) => {
+        radius = Math.max(radius, vec3.squaredDistance(centroid, point))
+      })
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  boundingSphere = [centroid, radius]
+  cacheOfBoundingSpheres.set(geometry, boundingSphere)
+
+  return boundingSphere
+}
+
+/**
+ * Measure the (aproximate) bounding sphere of the given geometries.
+ * @see https://en.wikipedia.org/wiki/Bounding_sphere
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the bounding sphere for each geometry, i.e. [centroid, radius]
+ * @alias module:modeling/measurements.measureBoundingSphere
+ *
+ * @example
+ * let bounds = measureBoundingSphere(cube())
+ */
+const measureBoundingSphere = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return measureBoundingSphereOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureBoundingSphereOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureBoundingSphereOfGeom3(geometry)
+    return [[0, 0, 0], 0]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureBoundingSphere

package/src/measurements/measureBoundingSphere.test.js

@@ -0,0 +1,59 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, ellipsoid } = require('../primitives')
+
+const { measureBoundingSphere } = require('./index')
+
+test('measureBoundingSphere (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const aellipsoid = ellipsoid({ radius: [5, 10, 15], 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 lbounds = measureBoundingSphere(aline)
+  const rbounds = measureBoundingSphere(arect)
+  const cbounds = measureBoundingSphere(aellipsoid)
+
+  const p2bounds = measureBoundingSphere(apath2)
+  const g2bounds = measureBoundingSphere(ageom2)
+  const g3bounds = measureBoundingSphere(ageom3)
+
+  const nbounds = measureBoundingSphere(n)
+  const obounds = measureBoundingSphere(o)
+  const xbounds = measureBoundingSphere(x)
+
+  t.deepEqual(lbounds, [[12.5, 12.5, 0], 3.5355339059327378])
+  t.deepEqual(rbounds, [[0, 0, 0], 1.4142135623730951])
+  t.deepEqual(cbounds, [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15])
+
+  t.deepEqual(p2bounds, [[0, 0, 0], 0])
+  t.deepEqual(g2bounds, [[0, 0, 0], 0])
+  t.deepEqual(g3bounds, [[0, 0, 0], 0])
+
+  t.deepEqual(nbounds, [[0, 0, 0], 0])
+  t.deepEqual(obounds, [[0, 0, 0], 0])
+  t.deepEqual(xbounds, [[0, 0, 0], 0])
+})
+
+test('measureBoundingSphere (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const aellipsoid = ellipsoid({ radius: [5, 10, 15], center: [5, 5, 5] })
+  const o = {}
+
+  let allbounds = measureBoundingSphere(aline, arect, aellipsoid, o)
+  t.deepEqual(allbounds, [[[12.5, 12.5, 0], 3.5355339059327378], [[0, 0, 0], 1.4142135623730951], [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15], [[0, 0, 0], 0]])
+
+  // test caching
+  allbounds = measureBoundingSphere(aline, arect, aellipsoid, o)
+  t.deepEqual(allbounds, [[[12.5, 12.5, 0], 3.5355339059327378], [[0, 0, 0], 1.4142135623730951], [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15], [[0, 0, 0], 0]])
+})

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.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 tetrahedon
+    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.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+
+  allcenters = measureCenterOfMass(aline, arect, asphere, o)
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+})

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.js

@@ -8,25 +8,19 @@ const measureBoundingBox = require('./measureBoundingBox')
  * Measure the epsilon of the given (path2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfPath2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+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) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+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) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
-}
+const measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
 
 /**
  * Measure the epsilon of the given geometries.

package/src/operations/booleans/reTesselateCoplanarPolygons.js

@@ -309,7 +309,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
           const polygon = poly3.fromPointsAndPlane(vertices3d, plane) // TODO support shared
 
           // if we let empty polygon out, next retesselate will crash
-          if(polygon.vertices.length) destpolygons.push(polygon)
+          if (polygon.vertices.length) destpolygons.push(polygon)
         }
       }
     } // if(yindex > 0)