@jbroll/jscad-modeling 2.12.7

package/src/maths/vec4/copy.js

@@ -0,0 +1,17 @@
+/**
+ * Create a copy of the given vector.
+ *
+ * @param {vec4} out - receiving vector
+ * @param {vec4} vector - source vector
+ * @returns {vec4} out
+ * @alias module:modeling/maths/vec4.copy
+ */
+const copy = (out, vector) => {
+  out[0] = vector[0]
+  out[1] = vector[1]
+  out[2] = vector[2]
+  out[3] = vector[3]
+  return out
+}
+
+module.exports = copy

package/src/maths/vec4/copy.test.js

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { create, copy, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec4: copy() with two params should update a vec4 with same values', (t) => {
+  const org1 = create()
+  const mat1 = fromValues(0, 0, 0, 0)
+  const ret1 = copy(org1, mat1)
+  t.true(compareVectors(org1, [0, 0, 0, 0]))
+  t.true(compareVectors(ret1, [0, 0, 0, 0]))
+  t.not(ret1, mat1)
+  t.is(ret1, org1)
+
+  const org2 = create()
+  const mat2 = fromValues(1, 2, 3, 4)
+  const ret2 = copy(org2, mat2)
+  t.true(compareVectors(org2, [1, 2, 3, 4]))
+  t.true(compareVectors(ret2, [1, 2, 3, 4]))
+  t.not(ret2, mat2)
+  t.is(ret2, org2)
+
+  const org3 = create()
+  const mat3 = fromValues(-1, -2, -3, -4)
+  const ret3 = copy(org3, mat3)
+  t.true(compareVectors(org3, [-1, -2, -3, -4]))
+  t.true(compareVectors(ret3, [-1, -2, -3, -4]))
+  t.not(ret3, mat3)
+  t.is(ret3, org3)
+})

package/src/maths/vec4/create.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default create
+
+declare function create(): Vec4

package/src/maths/vec4/create.js

@@ -0,0 +1,15 @@
+/**
+ * Represents a four dimensional vector.
+ * See fromValues().
+ * @typedef {Array} vec4
+ */
+
+/**
+ * Creates a new vector initialized to [0,0,0,0].
+ *
+ * @returns {vec4} a new vector
+ * @alias module:modeling/maths/vec4.create
+ */
+const create = () => [0, 0, 0, 0]
+
+module.exports = create

package/src/maths/vec4/create.test.js

@@ -0,0 +1,10 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec4: create() should return a vec4 with initial values', (t) => {
+  const obs = create()
+  t.true(compareVectors(obs, [0, 0, 0, 0]))
+})

package/src/maths/vec4/dot.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default dot
+
+declare function dot(a: Vec4, b: Vec4): number

package/src/maths/vec4/dot.js

@@ -0,0 +1,11 @@
+/**
+ * Calculates the dot product of the given vectors.
+ *
+ * @param {vec4} a - first vector
+ * @param {vec4} b - second vector
+ * @returns {Number} dot product
+ * @alias module:modeling/maths/vec4.dot
+ */
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]
+
+module.exports = dot

package/src/maths/vec4/dot.test.js

@@ -0,0 +1,11 @@
+const test = require('ava')
+
+const { dot, fromValues } = require('./index')
+
+test('vec4: dot() should return proper values', (t) => {
+  const vecA = fromValues(1, 2, 3, 4)
+  const vecB = fromValues(5, 6, 7, 8)
+
+  const obs = dot(vecA, vecB)
+  t.is(obs, 70)
+})

package/src/maths/vec4/equals.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default equals
+
+declare function equals(a: Vec4, b: Vec4): boolean

package/src/maths/vec4/equals.js

@@ -0,0 +1,11 @@
+/**
+ * Compare the given vectors for equality.
+ *
+ * @param {vec4} a - first vector
+ * @param {vec4} b - second vector
+ * @return {Boolean} true if vectors are equal
+ * @alias module:modeling/maths/vec4.equals
+ */
+const equals = (a, b) => ((a[0] === b[0]) && (a[1] === b[1]) && (a[2] === b[2]) && (a[3] === b[3]))
+
+module.exports = equals

package/src/maths/vec4/equals.test.js

@@ -0,0 +1,17 @@
+const test = require('ava')
+const { equals, fromValues } = require('./index')
+
+test('vec4: equals() should return correct booleans', (t) => {
+  const vec0 = fromValues(0, 0, 0, 0)
+  const vec1 = fromValues(0, 0, 0, 0)
+  t.true(equals(vec0, vec1))
+
+  const vec2 = fromValues(1, 1, 1, 1)
+  t.false(equals(vec0, vec2))
+
+  const vec3 = fromValues(0, 1, 1, 0)
+  t.false(equals(vec0, vec3))
+
+  const vec4 = fromValues(0, 0, 1, 1)
+  t.false(equals(vec0, vec4))
+})

package/src/maths/vec4/fromScalar.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default fromScalar
+
+declare function fromScalar(out: Vec4, scalar: number): Vec4

package/src/maths/vec4/fromScalar.js

@@ -0,0 +1,17 @@
+/**
+ * Create a new vector from the given scalar value.
+ *
+ * @param {vec4} out - receiving vector
+ * @param  {Number} scalar
+ * @returns {vec4} out
+ * @alias module:modeling/maths/vec4.fromScalar
+ */
+const fromScalar = (out, scalar) => {
+  out[0] = scalar
+  out[1] = scalar
+  out[2] = scalar
+  out[3] = scalar
+  return out
+}
+
+module.exports = fromScalar

package/src/maths/vec4/fromScalar.test.js

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromScalar, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec4: fromScalar() should return a new vec4 with correct values', (t) => {
+  const obs1 = fromScalar(create(), 0)
+  t.true(compareVectors(obs1, [0, 0, 0, 0]))
+
+  const obs2 = fromScalar(obs1, -5)
+  t.true(compareVectors(obs2, [-5, -5, -5, -5]))
+})

package/src/maths/vec4/fromValues.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default fromValues
+
+declare function fromValues(x: number, y: number, z: number, w: number): Vec4

package/src/maths/vec4/fromValues.js

@@ -0,0 +1,22 @@
+const create = require('./create')
+
+/**
+ * Creates a new vector with the given values.
+ *
+ * @param {Number} x - X component
+ * @param {Number} y - Y component
+ * @param {Number} z - Z component
+ * @param {Number} w - W component
+ * @returns {vec4} a new vector
+ * @alias module:modeling/maths/vec4.fromValues
+ */
+const fromValues = (x, y, z, w) => {
+  const out = create()
+  out[0] = x
+  out[1] = y
+  out[2] = z
+  out[3] = w
+  return out
+}
+
+module.exports = fromValues

package/src/maths/vec4/fromValues.test.js

@@ -0,0 +1,15 @@
+const test = require('ava')
+const { fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec4: fromValues() should return a new vec4 with correct values', (t) => {
+  const obs1 = fromValues(0, 0, 0, 0)
+  t.true(compareVectors(obs1, [0, 0, 0, 0]))
+
+  const obs2 = fromValues(5, 4, 3, 2)
+  t.true(compareVectors(obs2, [5, 4, 3, 2]))
+
+  const obs3 = fromValues(-5, -4, -3, -2)
+  t.true(compareVectors(obs3, [-5, -4, -3, -2]))
+})

package/src/maths/vec4/index.d.ts

@@ -0,0 +1,12 @@
+export { default as clone } from './clone'
+export { default as copy } from './copy'
+export { default as create } from './create'
+export { default as dot } from './dot'
+export { default as equals } from './equals'
+export { default as fromScalar } from './fromScalar'
+export { default as fromValues } from './fromValues'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+
+export { default as Vec4 } from './type'
+export as namespace vec4

package/src/maths/vec4/index.js

@@ -0,0 +1,16 @@
+/**
+ * Represents a four dimensional vector.
+ * @see {@link vec4} for data structure information.
+ * @module modeling/maths/vec4
+ */
+module.exports = {
+  clone: require('./clone'),
+  copy: require('./copy'),
+  create: require('./create'),
+  dot: require('./dot'),
+  equals: require('./equals'),
+  fromScalar: require('./fromScalar'),
+  fromValues: require('./fromValues'),
+  toString: require('./toString'),
+  transform: require('./transform')
+}

package/src/maths/vec4/toString.d.ts

@@ -0,0 +1,5 @@
+import Vec4 from './type'
+
+export default toString
+
+declare function toString(vec: Vec4): string

package/src/maths/vec4/toString.js

@@ -0,0 +1,10 @@
+/**
+ * Convert the given vector to a representative string.
+ *
+ * @param {vec4} vec - vector to convert
+ * @returns {String} representative string
+ * @alias module:modeling/maths/vec4.toString
+ */
+const toString = (vec) => `(${vec[0].toFixed(9)}, ${vec[1].toFixed(9)}, ${vec[2].toFixed(9)}, ${vec[3].toFixed(9)})`
+
+module.exports = toString

package/src/maths/vec4/transform.d.ts

@@ -0,0 +1,6 @@
+import Vec4 from './type'
+import Mat4 from '../mat4/type'
+
+export default transform
+
+declare function transform(out: Vec4, vector: Vec4, matrix: Mat4): Vec4

package/src/maths/vec4/transform.js

@@ -0,0 +1,20 @@
+/**
+ * Transform the given vector using the given matrix.
+ *
+ * @param {vec4} out - receiving vector
+ * @param {vec4} vector - vector to transform
+ * @param {mat4} matrix - matrix to transform with
+ * @returns {vec4} out
+ * @alias module:modeling/maths/vec4.transform
+ */
+const transform = (out, vector, matrix) => {
+  const [x, y, z, w] = vector
+
+  out[0] = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12] * w
+  out[1] = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13] * w
+  out[2] = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14] * w
+  out[3] = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15] * w
+  return out
+}
+
+module.exports = transform

package/src/maths/vec4/transform.test.js

@@ -0,0 +1,66 @@
+const test = require('ava')
+const { transform, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec4: transform() called with three parameters should update a vec4 with correct values', (t) => {
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const out1 = fromValues(0, 0, 0, 0)
+  const ret1 = transform(out1, [0, 0, 0, 0], identityMatrix)
+  t.true(compareVectors(out1, [0, 0, 0, 0]))
+  t.true(compareVectors(ret1, [0, 0, 0, 0]))
+
+  const out2 = fromValues(0, 0, 0, 0)
+  const ret2 = transform(out2, [3, 2, 1, 0], identityMatrix)
+  t.true(compareVectors(out2, [3, 2, 1, 0]))
+  t.true(compareVectors(ret2, [3, 2, 1, 0]))
+
+  const x = 1
+  const y = 5
+  const z = 7
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  const out3 = fromValues(0, 0, 0, 0)
+  const ret3 = transform(out3, [-1, -2, -3, 1], translationMatrix)
+  t.true(compareVectors(out3, [0, 3, 4, 1]))
+  t.true(compareVectors(ret3, [0, 3, 4, 1]))
+
+  const w = 1
+  const h = 3
+  const d = 5
+  const scaleMatrix = [
+    w, 0, 0, 0,
+    0, h, 0, 0,
+    0, 0, d, 0,
+    0, 0, 0, 1
+  ]
+
+  const out4 = fromValues(0, 0, 0, 0)
+  const ret4 = transform(out4, [1, 2, 3, 1], scaleMatrix)
+  t.true(compareVectors(out4, [1, 6, 15, 1]))
+  t.true(compareVectors(ret4, [1, 6, 15, 1]))
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), -Math.sin(r), 0, 0,
+    Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const out5 = fromValues(0, 0, 0, 0)
+  const ret5 = transform(out5, [1, 2, 3, 1], rotateZMatrix)
+  t.true(compareVectors(out5, [2, -1, 3, 1]))
+  t.true(compareVectors(ret5, [2, -1, 3, 1]))
+})

package/src/maths/vec4/type.d.ts

@@ -0,0 +1,3 @@
+export default Vec4
+
+declare type Vec4 = [number, number, number, number]

package/src/measurements/calculateEpsilonFromBounds.js

@@ -0,0 +1,11 @@
+const { EPS } = require('../maths/constants')
+
+const calculateEpsilonFromBounds = (bounds, dimensions) => {
+  let total = 0
+  for (let i = 0; i < dimensions; i++) {
+    total += bounds[1][i] - bounds[0][i]
+  }
+  return EPS * total / dimensions
+}
+
+module.exports = calculateEpsilonFromBounds

package/src/measurements/calculateEpsilonFromBounds.test.js

@@ -0,0 +1,18 @@
+const test = require('ava')
+
+const { EPS } = require('../maths/constants')
+const calculateEpsilonFromBounds = require('./calculateEpsilonFromBounds')
+
+test('calculateEpsilonFromBounds: 2 dimension', (t) => {
+  const bounds = [[-10, -100], [100, 10]]
+  const calculatedEpsilon = calculateEpsilonFromBounds(bounds, 2)
+  const expectedEpsilon = EPS * 110
+  t.is(calculatedEpsilon, expectedEpsilon)
+})
+
+test('calculateEpsilonFromBounds: 3 dimension', (t) => {
+  const bounds = [[-500, 0, -100], [0, 500, 100]]
+  const calculatedEpsilon = calculateEpsilonFromBounds(bounds, 3)
+  const expectedEpsilon = EPS * 400
+  t.is(calculatedEpsilon, expectedEpsilon)
+})

package/src/measurements/index.d.ts

@@ -0,0 +1,15 @@
+export { default as measureAggregateArea } from './measureAggregateArea'
+export { default as measureAggregateBoundingBox } from './measureAggregateBoundingBox'
+export { default as measureAggregateEpsilon } from './measureAggregateEpsilon'
+export { default as measureAggregateVolume } from './measureAggregateVolume'
+export { default as measureArea } from './measureArea'
+export { default as measureBoundingBox } from './measureBoundingBox'
+export { default as measureBoundingSphere } from './measureBoundingSphere'
+export { default as measureCenter } from './measureCenter'
+export { default as measureCenterOfMass } from './measureCenterOfMass'
+export { default as measureDimensions } from './measureDimensions'
+export { default as measureEpsilon } from './measureEpsilon'
+export { default as measureVolume } from './measureVolume'
+
+export * from './types'
+export as namespace measurements

package/src/measurements/index.js

@@ -0,0 +1,20 @@
+/**
+ * All shapes (primitives or the results of operations) can be measured, e.g. calculate volume, etc.
+ * @module modeling/measurements
+ * @example
+ * const { measureArea, measureBoundingBox, measureVolume } = require('@jscad/modeling').measurements
+ */
+module.exports = {
+  measureAggregateArea: require('./measureAggregateArea'),
+  measureAggregateBoundingBox: require('./measureAggregateBoundingBox'),
+  measureAggregateEpsilon: require('./measureAggregateEpsilon'),
+  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/measureAggregateArea.d.ts

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

package/src/measurements/measureAggregateArea.js

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

package/src/measurements/measureAggregateArea.test.js

@@ -0,0 +1,22 @@
+const test = require('ava')
+
+const { cube, cuboid } = require('../primitives')
+const measureAggregateArea = require('./measureAggregateArea')
+
+test('measureAggregateArea (single objects)', (t) => {
+  const aCube = cube({ size: 4, center: [4, 10, 20] })
+  const area = measureAggregateArea(aCube)
+  t.is(area, 4 * 4 * 6)
+})
+
+test('measureAggregateArea (multiple objects)', (t) => {
+  const cube1 = cube({ size: 4, center: [4, -10, 20] })
+  const cuboid2 = cuboid({ size: [1, 4, 10], center: [0, -20, 20] })
+
+  const expectedArea = (4 * 4 * 6) + (2 * (1 * 4 + 1 * 10 + 4 * 10))
+  let volume = measureAggregateArea(cube1, cuboid2)
+  t.is(volume, expectedArea)
+
+  volume = measureAggregateArea([cube1, cuboid2])
+  t.is(volume, expectedArea)
+})

package/src/measurements/measureAggregateBoundingBox.d.ts

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

package/src/measurements/measureAggregateBoundingBox.js

@@ -0,0 +1,30 @@
+const flatten = require('../utils/flatten')
+const vec3min = require('../maths/vec3/min')
+const vec3max = require('../maths/vec3/max')
+
+const measureBoundingBox = require('./measureBoundingBox')
+
+/**
+ * Measure the aggregated minimum and maximum bounds for the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the min and max bounds for the group of geometry, i.e. [[x,y,z],[X,Y,Z]]
+ * @alias module:modeling/measurements.measureAggregateBoundingBox
+ *
+ * @example
+ * let bounds = measureAggregateBoundingBox(sphere(),cube())
+ */
+const measureAggregateBoundingBox = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('measureAggregateBoundingBox: no geometries supplied')
+  const bounds = measureBoundingBox(geometries)
+  if (geometries.length === 1) {
+    return bounds
+  }
+  const result = [[Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE], [-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE]]
+  return bounds.reduce((result, item) => {
+    result = [vec3min(result[0], result[0], item[0]), vec3max(result[1], result[1], item[1])]
+    return result
+  }, result)
+}
+
+module.exports = measureAggregateBoundingBox

package/src/measurements/measureAggregateBoundingBox.test.js

@@ -0,0 +1,35 @@
+const test = require('ava')
+
+const { cube } = require('../primitives')
+const measureAggregateBoundingBox = require('./measureAggregateBoundingBox')
+const measureBoundingBox = require('./measureBoundingBox')
+
+test('measureAggregateBoundingBox (single objects)', (t) => {
+  const aCube = cube({ size: 4, center: [4, 10, 20] })
+  const bounds = measureAggregateBoundingBox(aCube)
+  t.deepEqual(bounds, [[2, 8, 18], [6, 12, 22]], 'Bounds were not as expected')
+})
+
+test('measureAggregateBoundingBox (multiple objects)', (t) => {
+  const cube1 = cube({ size: 4, center: [4, -10, 20] })
+  const cube2 = cube({ size: 6, center: [0, -20, 20] })
+
+  const expectedBounds = [[-3, -23, 17], [6, -8, 23]]
+  let bounds = measureAggregateBoundingBox(cube1, cube2)
+
+  t.deepEqual(bounds, expectedBounds, 'Bounds were not as expected')
+
+  bounds = measureAggregateBoundingBox([cube1, cube2])
+  t.deepEqual(bounds, expectedBounds, 'Bounds were not as expected')
+})
+
+test('measureAggregateBoundingBox (multiple objects) does not change original bounds', (t) => {
+  const cube1 = cube({ size: 4, center: [4, 10, 20] })
+  const cube2 = cube({ size: 6, center: [0, 20, 20] })
+
+  const objectBoundsBefore = JSON.stringify(measureBoundingBox(cube1, cube2))
+  measureAggregateBoundingBox(cube1, cube2)
+  const objectBoundsAfter = JSON.stringify(measureBoundingBox(cube1, cube2))
+
+  t.is(objectBoundsBefore, objectBoundsAfter, 'Individual object bounds were not changed by the operation.')
+})

package/src/measurements/measureAggregateEpsilon.d.ts

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

package/src/measurements/measureAggregateEpsilon.js

@@ -0,0 +1,29 @@
+const flatten = require('../utils/flatten')
+const measureAggregateBoundingBox = require('./measureAggregateBoundingBox')
+const calculateEpsilonFromBounds = require('./calculateEpsilonFromBounds')
+const { geom2, geom3, path2 } = require('../geometries')
+
+/**
+ * Measure the aggregated Epsilon for the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Number} the aggregated Epsilon for the whole group of geometries
+ * @alias module:modeling/measurements.measureAggregateEpsilon
+ *
+ * @example
+ * let groupEpsilon = measureAggregateEpsilon(sphere(),cube())
+ */
+const measureAggregateEpsilon = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('measureAggregateEpsilon: no geometries supplied')
+  const bounds = measureAggregateBoundingBox(geometries)
+
+  let dimensions = 0
+  dimensions = geometries.reduce((dimensions, geometry) => {
+    if (path2.isA(geometry) || geom2.isA(geometry)) return Math.max(dimensions, 2)
+    if (geom3.isA(geometry)) return Math.max(dimensions, 3)
+    return 0
+  }, dimensions)
+  return calculateEpsilonFromBounds(bounds, dimensions)
+}
+
+module.exports = measureAggregateEpsilon