@jbroll/jscad-modeling 2.12.7

package/src/measurements/measureAggregateEpsilon.test.js

@@ -0,0 +1,28 @@
+const test = require('ava')
+const { EPS } = require('../maths/constants')
+
+const { cube, square } = require('../primitives')
+const measureAggregateEpsilon = require('./measureAggregateEpsilon')
+
+test('measureAggregateEpsilon (single objects)', (t) => {
+  const aCube = cube({ size: 4, center: [4, 10, 20] })
+  const calculatedEpsilon = measureAggregateEpsilon(aCube)
+  const expectedEpsilon = EPS * 4
+  t.is(calculatedEpsilon, expectedEpsilon)
+})
+
+test('measureAggregateEpsilon (multiple objects)', (t) => {
+  const highCube = cube({ size: 4, center: [-40, 100, 20] })
+  const lowCube = cube({ size: 60, center: [20, -10, 20] })
+  const calculatedEpsilon = measureAggregateEpsilon(highCube, lowCube)
+  const expectedEpsilon = EPS * 98
+  t.is(calculatedEpsilon, expectedEpsilon)
+})
+
+test('measureAggregateEpsilon (multiple 2D objects)', (t) => {
+  const highCube = cube({ size: 4, center: [-42, 100, 20] })
+  const lowCube = square({ size: 60, center: [20, -10, 0] })
+  const calculatedEpsilon = measureAggregateEpsilon(highCube, lowCube)
+  const expectedEpsilon = EPS * 86
+  t.is(calculatedEpsilon, expectedEpsilon)
+})

package/src/measurements/measureAggregateVolume.d.ts

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

package/src/measurements/measureAggregateVolume.js

@@ -0,0 +1,26 @@
+const flatten = require('../utils/flatten')
+
+const measureVolume = require('./measureVolume')
+
+/**
+ * Measure the total (aggregate) volume for the given geometries.
+ * Note: This measurement will not account for overlapping geometry
+ * @param {...Object} geometries - the geometries to measure.
+ * @return {Number} the volume for the group of geometry.
+ * @alias module:modeling/measurements.measureAggregateVolume
+ *
+ * @example
+ * let totalVolume = measureAggregateVolume(sphere(),cube())
+ */
+const measureAggregateVolume = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('measureAggregateVolume: no geometries supplied')
+  const volumes = measureVolume(geometries)
+  if (geometries.length === 1) {
+    return volumes
+  }
+  const result = 0
+  return volumes.reduce((result, volume) => result + volume, result)
+}
+
+module.exports = measureAggregateVolume

package/src/measurements/measureAggregateVolume.test.js

@@ -0,0 +1,21 @@
+const test = require('ava')
+
+const { cube, cuboid } = require('../primitives')
+const measureAggregateVolume = require('./measureAggregateVolume')
+
+test('measureAggregateVolume (single objects)', (t) => {
+  const aCube = cube({ size: 4, center: [4, 10, 20] })
+  const volume = measureAggregateVolume(aCube)
+  t.is(volume, 64)
+})
+
+test('measureAggregateVolume (multiple objects)', (t) => {
+  const cube1 = cube({ size: 4, center: [4, -10, 20] })
+  const cuboid2 = cuboid({ size: [1, 4, 10], center: [0, -20, 20] })
+
+  let volume = measureAggregateVolume(cube1, cuboid2)
+  t.is(volume, 104)
+
+  volume = measureAggregateVolume([cube1, cuboid2])
+  t.is(volume, 104)
+})

package/src/measurements/measureArea.d.ts

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

package/src/measurements/measureArea.js

@@ -0,0 +1,80 @@
+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 area of the given geometry.
+ * NOTE: paths are infinitely narrow and do not have an area
+ *
+ * @param {path2} geometry - geometry to measure
+ * @returns {Number} area of the geometry
+ */
+const measureAreaOfPath2 = () => 0
+
+/*
+ * Measure the area of the given geometry.
+ * For a counter clockwise rotating geometry (about Z) the area is positive, otherwise negative.
+ *
+ * @see http://paulbourke.net/geometry/polygonmesh/
+ * @param {geom2} geometry - 2D geometry to measure
+ * @returns {Number} area of the geometry
+ */
+const measureAreaOfGeom2 = (geometry) => {
+  let area = cache.get(geometry)
+  if (area) return area
+
+  const sides = geom2.toSides(geometry)
+  area = sides.reduce((area, side) => area + (side[0][0] * side[1][1] - side[0][1] * side[1][0]), 0)
+  area *= 0.5
+
+  cache.set(geometry, area)
+
+  return area
+}
+
+/*
+ * Measure the area of the given geometry.
+ *
+ * @param {geom3} geometry - 3D geometry to measure
+ * @returns {Number} area of the geometry
+ */
+const measureAreaOfGeom3 = (geometry) => {
+  let area = cache.get(geometry)
+  if (area) return area
+
+  const polygons = geom3.toPolygons(geometry)
+  area = polygons.reduce((area, polygon) => area + poly3.measureArea(polygon), 0)
+
+  cache.set(geometry, area)
+
+  return area
+}
+
+/**
+ * Measure the area of the given geometries.
+ * @param {...Objects} geometries - the geometries to measure
+ * @return {Number|Array} the area, or a list of areas for each geometry
+ * @alias module:modeling/measurements.measureArea
+ *
+ * @example
+ * let area = measureArea(sphere())
+ */
+const measureArea = (...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 measureAreaOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureAreaOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureAreaOfGeom3(geometry)
+    return 0
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureArea

package/src/measurements/measureArea.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureArea } = require('./index')
+
+test('measureArea: 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 larea = measureArea(aline)
+  const rarea = measureArea(arect)
+  const carea = measureArea(acube)
+
+  const p2area = measureArea(apath2)
+  const g2area = measureArea(ageom2)
+  const g3area = measureArea(ageom3)
+
+  const narea = measureArea(n)
+  const oarea = measureArea(o)
+  const xarea = measureArea(x)
+
+  t.is(larea, 0)
+  t.is(rarea, 4) // 2x2
+  t.is(carea, 24) // 2x2x6
+
+  t.is(p2area, 0)
+  t.is(g2area, 0)
+  t.is(g3area, 0)
+
+  t.is(narea, 0)
+  t.is(oarea, 0)
+  t.is(xarea, 0)
+})
+
+test('measureArea (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid({ size: [10, 20, 40] })
+  const o = {}
+
+  let allarea = measureArea(aline, arect, acube, o)
+  t.deepEqual(allarea, [0, 200, 2800, 0])
+
+  allarea = measureArea(aline, arect, acube, o)
+  t.deepEqual(allarea, [0, 200, 2800, 0])
+})

package/src/measurements/measureBoundingBox.d.ts

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

package/src/measurements/measureBoundingBox.js

@@ -0,0 +1,134 @@
+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 cache = new WeakMap()
+
+/*
+ * Measure the min and max bounds of the given (path2) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfPath2 = (geometry) => {
+  let boundingBox = cache.get(geometry)
+  if (boundingBox) return boundingBox
+
+  const points = path2.toPoints(geometry)
+
+  let minpoint
+  if (points.length === 0) {
+    minpoint = vec2.create()
+  } else {
+    minpoint = vec2.clone(points[0])
+  }
+  let maxpoint = vec2.clone(minpoint)
+
+  points.forEach((point) => {
+    vec2.min(minpoint, minpoint, point)
+    vec2.max(maxpoint, maxpoint, point)
+  })
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
+
+  boundingBox = [minpoint, maxpoint]
+
+  cache.set(geometry, boundingBox)
+
+  return boundingBox
+}
+
+/*
+ * Measure the min and max bounds of the given (geom2) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfGeom2 = (geometry) => {
+  let boundingBox = cache.get(geometry)
+  if (boundingBox) return boundingBox
+
+  const points = geom2.toPoints(geometry)
+
+  let minpoint
+  if (points.length === 0) {
+    minpoint = vec2.create()
+  } else {
+    minpoint = vec2.clone(points[0])
+  }
+  let maxpoint = vec2.clone(minpoint)
+
+  points.forEach((point) => {
+    vec2.min(minpoint, minpoint, point)
+    vec2.max(maxpoint, maxpoint, point)
+  })
+
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
+
+  boundingBox = [minpoint, maxpoint]
+
+  cache.set(geometry, boundingBox)
+
+  return boundingBox
+}
+
+/*
+ * Measure the min and max bounds of the given (geom3) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfGeom3 = (geometry) => {
+  let boundingBox = cache.get(geometry)
+  if (boundingBox) return boundingBox
+
+  const polygons = geom3.toPolygons(geometry)
+
+  let minpoint = vec3.create()
+  if (polygons.length > 0) {
+    const points = poly3.toPoints(polygons[0])
+    vec3.copy(minpoint, points[0])
+  }
+  let maxpoint = vec3.clone(minpoint)
+
+  polygons.forEach((polygon) => {
+    poly3.toPoints(polygon).forEach((point) => {
+      vec3.min(minpoint, minpoint, point)
+      vec3.max(maxpoint, maxpoint, point)
+    })
+  })
+
+  minpoint = [minpoint[0], minpoint[1], minpoint[2]]
+  maxpoint = [maxpoint[0], maxpoint[1], maxpoint[2]]
+
+  boundingBox = [minpoint, maxpoint]
+
+  cache.set(geometry, boundingBox)
+
+  return boundingBox
+}
+
+/**
+ * Measure the min and max bounds of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the min and max bounds, or a list of bounds for each geometry
+ * @alias module:modeling/measurements.measureBoundingBox
+ *
+ * @example
+ * let bounds = measureBoundingBox(sphere())
+ */
+const measureBoundingBox = (...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 measureBoundingBoxOfPath2(geometry)
+    if (geom2.isA(geometry)) return measureBoundingBoxOfGeom2(geometry)
+    if (geom3.isA(geometry)) return measureBoundingBoxOfGeom3(geometry)
+    return [[0, 0, 0], [0, 0, 0]]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureBoundingBox

package/src/measurements/measureBoundingBox.test.js

@@ -0,0 +1,66 @@
+const test = require('ava')
+
+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) => {
+  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 = measureBoundingBox(aline)
+  const rbounds = measureBoundingBox(arect)
+  const cbounds = measureBoundingBox(acube)
+
+  const p2bounds = measureBoundingBox(apath2)
+  const g2bounds = measureBoundingBox(ageom2)
+  const g3bounds = measureBoundingBox(ageom3)
+
+  const nbounds = measureBoundingBox(n)
+  const obounds = measureBoundingBox(o)
+  const xbounds = measureBoundingBox(x)
+
+  t.deepEqual(lbounds, [[10, 10, 0], [15, 15, 0]])
+  t.deepEqual(rbounds, [[-1, -1, 0], [1, 1, 0]])
+  t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
+
+  t.deepEqual(p2bounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(g2bounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(g3bounds, [[0, 0, 0], [0, 0, 0]])
+
+  t.deepEqual(nbounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(obounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(xbounds, [[0, 0, 0], [0, 0, 0]])
+})
+
+test('measureBoundingBox (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid()
+  const o = {}
+
+  let 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]]])
+
+  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.d.ts

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

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 centroid 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 centroid 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 centroid 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 (approximate) 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.d.ts

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