@jbroll/jscad-modeling 2.12.7

package/src/geometries/poly3/fromPoints.js

@@ -0,0 +1,25 @@
+const vec3 = require('../../maths/vec3')
+
+const create = require('./create')
+
+/**
+ * Create a polygon from the given points.
+ *
+ * @param {Array} points - list of points (3D)
+ * @returns {poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.fromPoints
+ *
+ * @example
+ * const points = [
+ *   [0,  0, 0],
+ *   [0, 10, 0],
+ *   [0, 10, 10]
+ * ]
+ * const polygon = fromPoints(points)
+ */
+const fromPoints = (points) => {
+  const vertices = points.map((point) => vec3.clone(point))
+  return create(vertices)
+}
+
+module.exports = fromPoints

package/src/geometries/poly3/fromPoints.test.js

@@ -0,0 +1,15 @@
+const test = require('ava')
+
+const { fromPoints } = require('./index')
+
+const { comparePolygons } = require('../../../test/helpers/index')
+
+test('poly3: fromPoints() should return a new poly3 with correct values', (t) => {
+  const exp1 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
+  const obs1 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  t.true(comparePolygons(obs1, exp1))
+
+  const exp2 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
+  const obs2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]]) // opposite orientation
+  t.true(comparePolygons(obs2, exp2))
+})

package/src/geometries/poly3/fromPointsAndPlane.d.ts

@@ -0,0 +1,7 @@
+import Poly3 from './type'
+import Vec3 from '../../maths/vec3/type'
+import Plane from '../../maths/plane/type'
+
+export default fromPointsAndPlane
+
+declare function fromPointsAndPlane(vertices: Array<Vec3>, plane: Plane): Poly3

package/src/geometries/poly3/fromPointsAndPlane.js

@@ -0,0 +1,17 @@
+const create = require('./create')
+
+/**
+ * Create a polygon from the given vertices and plane.
+ * NOTE: No checks are performed on the parameters.
+ * @param {Array} vertices - list of vertices (3D)
+ * @param {plane} plane - plane of the polygon
+ * @returns {poly3} a new polygon
+ * @alias module:modeling/geometries/poly3.fromPointsAndPlane
+ */
+const fromPointsAndPlane = (vertices, plane) => {
+  const poly = create(vertices)
+  poly.plane = plane // retain the plane for later use
+  return poly
+}
+
+module.exports = fromPointsAndPlane

package/src/geometries/poly3/index.d.ts

@@ -0,0 +1,19 @@
+export { default as clone } from './clone'
+export { default as create } from './create'
+export { default as fromPoints } from './fromPoints'
+export { default as fromPointsAndPlane } from './fromPointsAndPlane'
+export { default as invert } from './invert'
+export { default as isA } from './isA'
+export { default as isConvex } from './isConvex'
+export { default as measureArea } from './measureArea'
+export { default as measureBoundingBox } from './measureBoundingBox'
+export { default as measureBoundingSphere } from './measureBoundingSphere'
+export { default as measureSignedVolume } from './measureSignedVolume'
+export { default as plane } from './plane'
+export { default as toPoints } from './toPoints'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+export { default as validate } from './validate'
+
+export { default as Poly3 } from './type'
+export as namespace poly3

package/src/geometries/poly3/index.js

@@ -0,0 +1,29 @@
+/**
+ * Represents a convex 3D polygon consisting of a list of ordered vertices.
+ * @see {@link poly3} for data structure information.
+ * @module modeling/geometries/poly3
+ *
+ * @example
+ * poly3.create([[0,0,0], [4,0,0], [4,3,12]])
+ *
+ * @example
+ * {"vertices": [[0,0,0], [4,0,0], [4,3,12]]}
+ */
+module.exports = {
+  clone: require('./clone'),
+  create: require('./create'),
+  fromPoints: require('./fromPoints'),
+  fromPointsAndPlane: require('./fromPointsAndPlane'),
+  invert: require('./invert'),
+  isA: require('./isA'),
+  isConvex: require('./isConvex'),
+  measureArea: require('./measureArea'),
+  measureBoundingBox: require('./measureBoundingBox'),
+  measureBoundingSphere: require('./measureBoundingSphere'),
+  measureSignedVolume: require('./measureSignedVolume'),
+  plane: require('./plane'),
+  toPoints: require('./toPoints'),
+  toString: require('./toString'),
+  transform: require('./transform'),
+  validate: require('./validate')
+}

package/src/geometries/poly3/invert.d.ts

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

package/src/geometries/poly3/invert.js

@@ -0,0 +1,21 @@
+const plane = require('../../maths/plane')
+const create = require('./create')
+
+/**
+ * Invert the give polygon to face the opposite direction.
+ *
+ * @param {poly3} polygon - the polygon to invert
+ * @returns {poly3} a new poly3
+ * @alias module:modeling/geometries/poly3.invert
+ */
+const invert = (polygon) => {
+  const vertices = polygon.vertices.slice().reverse()
+  const inverted = create(vertices)
+  if (polygon.plane) {
+    // Flip existing plane to save recompute
+    inverted.plane = plane.flip(plane.create(), polygon.plane)
+  }
+  return inverted
+}
+
+module.exports = invert

package/src/geometries/poly3/invert.test.js

@@ -0,0 +1,18 @@
+const test = require('ava')
+
+const { invert, fromPoints } = require('./index')
+
+const { comparePolygons } = require('../../../test/helpers/index')
+
+test('poly3: invert() should return a new poly3 with correct values', (t) => {
+  const exp1 = { vertices: [[1, 1, 0], [1, 0, 0], [0, 0, 0]] }
+  const org1 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const ret1 = invert(org1)
+  t.true(comparePolygons(ret1, exp1))
+
+  const exp2 = { vertices: [[0, 0, 0], [1, 0, 0], [1, 1, 0]] }
+  const org2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  const ret2 = invert(org2)
+  t.true(comparePolygons(ret2, exp2))
+  t.false(comparePolygons(ret2, org2)) // the original should NOT change
+})

package/src/geometries/poly3/isA.d.ts

@@ -0,0 +1,5 @@
+import Poly3 from './type'
+
+export default isA
+
+declare function isA(object: any): object is Poly3

package/src/geometries/poly3/isA.js

@@ -0,0 +1,18 @@
+/**
+ * Determine if the given object is a polygon.
+ * @param {Object} object - the object to interrogate
+ * @returns {Boolean} true if the object matches a poly3
+ * @alias module:modeling/geometries/poly3.isA
+ */
+const isA = (object) => {
+  if (object && typeof object === 'object') {
+    if ('vertices' in object) {
+      if (Array.isArray(object.vertices)) {
+        return true
+      }
+    }
+  }
+  return false
+}
+
+module.exports = isA

package/src/geometries/poly3/isA.test.js

@@ -0,0 +1,19 @@
+const test = require('ava')
+
+const { isA, create, fromPoints } = require('./index')
+
+test('isA: identifies created poly3', (t) => {
+  const p1 = create()
+  const p2 = fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  t.true(isA(p1))
+  t.true(isA(p2))
+})
+
+test('isA: identifies non poly3', (t) => {
+  const p1 = null
+  const p2 = {}
+  const p3 = { vertices: 1 }
+  t.false(isA(p1))
+  t.false(isA(p2))
+  t.false(isA(p3))
+})

package/src/geometries/poly3/isConvex.d.ts

@@ -0,0 +1,5 @@
+import Poly3 from './type'
+
+export default isConvex
+
+declare function isConvex(polygon: Poly3): boolean

package/src/geometries/poly3/isConvex.js

@@ -0,0 +1,44 @@
+const plane = require('../../maths/plane')
+const vec3 = require('../../maths/vec3')
+
+/**
+ * Check whether the given polygon is convex.
+ * @param {poly3} polygon - the polygon to interrogate
+ * @returns {Boolean} true if convex
+ * @alias module:modeling/geometries/poly3.isConvex
+ */
+const isConvex = (polygon) => areVerticesConvex(polygon.vertices)
+
+const areVerticesConvex = (vertices) => {
+  const numvertices = vertices.length
+  if (numvertices > 2) {
+    // note: plane ~= normal point
+    const normal = plane.fromPoints(plane.create(), ...vertices)
+    let prevprevpos = vertices[numvertices - 2]
+    let prevpos = vertices[numvertices - 1]
+    for (let i = 0; i < numvertices; i++) {
+      const pos = vertices[i]
+      if (!isConvexPoint(prevprevpos, prevpos, pos, normal)) {
+        return false
+      }
+      prevprevpos = prevpos
+      prevpos = pos
+    }
+  }
+  return true
+}
+
+// calculate whether three points form a convex corner
+//  prevpoint, point, nextpoint: the 3 coordinates (Vector3D instances)
+//  normal: the normal vector of the plane
+const isConvexPoint = (prevpoint, point, nextpoint, normal) => {
+  const crossproduct = vec3.cross(
+    vec3.create(),
+    vec3.subtract(vec3.create(), point, prevpoint),
+    vec3.subtract(vec3.create(), nextpoint, point)
+  )
+  const crossdotnormal = vec3.dot(crossproduct, normal)
+  return crossdotnormal >= 0
+}
+
+module.exports = isConvex

package/src/geometries/poly3/isConvex.test.js

@@ -0,0 +1,24 @@
+const test = require('ava')
+
+const { isConvex, create, fromPoints } = require('./index')
+
+test('poly3: isConvex() should return correct values', (t) => {
+  const ply1 = create()
+  t.true(isConvex(ply1))
+
+  const ply2 = fromPoints([[1, 1, 0], [1, 0, 0], [0, 0, 0]])
+  t.true(isConvex(ply2))
+
+  const points2ccw = [[0, 0, 3], [10, 10, 3], [0, 5, 3]]
+  const ply3 = fromPoints(points2ccw)
+  t.true(isConvex(ply3))
+
+  const points2cw = [[0, 0, 3], [-10, 10, 3], [0, 5, 3]]
+  const ply4 = fromPoints(points2cw)
+  t.true(isConvex(ply4))
+
+  // V-shape
+  const pointsV = [[0, 0, 3], [-10, 10, 3], [0, 5, 3], [10, 10, 3]]
+  const ply5 = fromPoints(pointsV)
+  t.false(isConvex(ply5))
+})

package/src/geometries/poly3/measureArea.d.ts

@@ -0,0 +1,5 @@
+import Poly3 from './type'
+
+export default measureArea
+
+declare function measureArea(polygon: Poly3): number

package/src/geometries/poly3/measureArea.js

@@ -0,0 +1,83 @@
+const plane = require('./plane')
+
+/**
+ * Measure the area of the given polygon.
+ * @see 2000 softSurfer http://geomalgorithms.com
+ * @param {poly3} polygon - the polygon to measure
+ * @return {Number} area of the polygon
+ * @alias module:modeling/geometries/poly3.measureArea
+ */
+const measureArea = (polygon) => {
+  const n = polygon.vertices.length
+  if (n < 3) {
+    return 0 // degenerate polygon
+  }
+  const vertices = polygon.vertices
+
+  // calculate a normal vector
+  const normal = plane(polygon)
+
+  // determine direction of projection
+  const ax = Math.abs(normal[0])
+  const ay = Math.abs(normal[1])
+  const az = Math.abs(normal[2])
+
+  if (ax + ay + az === 0) {
+    // normal does not exist
+    return 0
+  }
+
+  let coord = 3 // ignore Z coordinates
+  if ((ax > ay) && (ax > az)) {
+    coord = 1 // ignore X coordinates
+  } else
+  if (ay > az) {
+    coord = 2 // ignore Y coordinates
+  }
+
+  let area = 0
+  let h = 0
+  let i = 1
+  let j = 2
+  switch (coord) {
+    case 1: // ignore X coordinates
+      // compute area of 2D projection
+      for (i = 1; i < n; i++) {
+        h = i - 1
+        j = (i + 1) % n
+        area += (vertices[i][1] * (vertices[j][2] - vertices[h][2]))
+      }
+      area += (vertices[0][1] * (vertices[1][2] - vertices[n - 1][2]))
+      // scale to get area
+      area /= (2 * normal[0])
+      break
+
+    case 2: // ignore Y coordinates
+      // compute area of 2D projection
+      for (i = 1; i < n; i++) {
+        h = i - 1
+        j = (i + 1) % n
+        area += (vertices[i][2] * (vertices[j][0] - vertices[h][0]))
+      }
+      area += (vertices[0][2] * (vertices[1][0] - vertices[n - 1][0]))
+      // scale to get area
+      area /= (2 * normal[1])
+      break
+
+    case 3: // ignore Z coordinates
+    default:
+      // compute area of 2D projection
+      for (i = 1; i < n; i++) {
+        h = i - 1
+        j = (i + 1) % n
+        area += (vertices[i][0] * (vertices[j][1] - vertices[h][1]))
+      }
+      area += (vertices[0][0] * (vertices[1][1] - vertices[n - 1][1]))
+      // scale to get area
+      area /= (2 * normal[2])
+      break
+  }
+  return area
+}
+
+module.exports = measureArea

package/src/geometries/poly3/measureArea.test.js

@@ -0,0 +1,111 @@
+const test = require('ava')
+const { measureArea, create, invert, fromPoints, transform } = require('./index')
+
+const mat4 = require('../../maths/mat4')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+
+test('poly3: measureArea() should return correct values', (t) => {
+  let ply1 = create()
+  let ret1 = measureArea(ply1)
+  t.is(ret1, 0.0)
+
+  // simple triangle
+  let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
+  let ret2 = measureArea(ply2)
+  t.is(ret2, 50.0)
+
+  // simple square
+  let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
+  let ret3 = measureArea(ply3)
+  t.is(ret3, 100.0)
+
+  // V-shape
+  const points = [
+    [0, 3, 0],
+    [0, 5, 0],
+    [0, 8, 2],
+    [0, 6, 5],
+    [0, 8, 6],
+    [0, 5, 6],
+    [0, 5, 2],
+    [0, 2, 5],
+    [0, 1, 3],
+    [0, 3, 3]
+  ]
+  let ply4 = fromPoints(points)
+  let ret4 = measureArea(ply4)
+  t.is(ret4, 19.5)
+
+  // colinear vertices non-zero area
+  const ply5 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0]])
+  const ret5 = measureArea(ply5)
+  t.is(ret5, 1)
+
+  // colinear vertices empty area
+  const ply6 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+  const ret6 = measureArea(ply6)
+  t.is(ret6, 0)
+
+  // duplicate vertices empty area
+  const ply7 = fromPoints([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+  const ret7 = measureArea(ply7)
+  t.is(ret7, 0)
+
+  // rotated to various angles
+  let rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
+  ply1 = transform(rotation, ply1)
+  ply2 = transform(rotation, ply2)
+  ply3 = transform(rotation, ply3)
+  ply4 = transform(rotation, ply4)
+  ret1 = measureArea(ply1)
+  ret2 = measureArea(ply2)
+  ret3 = measureArea(ply3)
+  ret4 = measureArea(ply4)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
+
+  rotation = mat4.fromYRotation(mat4.create(), (45 * 0.017453292519943295))
+  ply1 = transform(rotation, ply1)
+  ply2 = transform(rotation, ply2)
+  ply3 = transform(rotation, ply3)
+  ply4 = transform(rotation, ply4)
+  ret1 = measureArea(ply1)
+  ret2 = measureArea(ply2)
+  ret3 = measureArea(ply3)
+  ret4 = measureArea(ply4)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
+
+  rotation = mat4.fromXRotation(mat4.create(), (45 * 0.017453292519943295))
+  ply1 = transform(rotation, ply1)
+  ply2 = transform(rotation, ply2)
+  ply3 = transform(rotation, ply3)
+  ply4 = transform(rotation, ply4)
+  ret1 = measureArea(ply1)
+  ret2 = measureArea(ply2)
+  ret3 = measureArea(ply3)
+  ret4 = measureArea(ply4)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
+
+  // inverted
+  ply1 = invert(ply1)
+  ply2 = invert(ply2)
+  ply3 = invert(ply3)
+  ply4 = invert(ply4)
+  ret1 = measureArea(ply1)
+  ret2 = measureArea(ply2)
+  ret3 = measureArea(ply3)
+  ret4 = measureArea(ply4)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON * 2)
+})

package/src/geometries/poly3/measureBoundingBox.d.ts

@@ -0,0 +1,6 @@
+import Poly3 from './type'
+import Vec3 from '../../maths/vec3/type'
+
+export default measureBoundingBox
+
+declare function measureBoundingBox(polygon: Poly3): [Vec3, Vec3]

package/src/geometries/poly3/measureBoundingBox.js

@@ -0,0 +1,20 @@
+const vec3 = require('../../maths/vec3')
+
+/**
+ * @param {poly3} polygon - the polygon to measure
+ * @returns {Array} an array of two vectors (3D);  minimum and maximum coordinates
+ * @alias module:modeling/geometries/poly3.measureBoundingBox
+ */
+const measureBoundingBox = (polygon) => {
+  const vertices = polygon.vertices
+  const numvertices = vertices.length
+  const min = numvertices === 0 ? vec3.create() : vec3.clone(vertices[0])
+  const max = vec3.clone(min)
+  for (let i = 1; i < numvertices; i++) {
+    vec3.min(min, min, vertices[i])
+    vec3.max(max, max, vertices[i])
+  }
+  return [min, max]
+}
+
+module.exports = measureBoundingBox

package/src/geometries/poly3/measureBoundingBox.test.js

@@ -0,0 +1,70 @@
+const test = require('ava')
+const { measureBoundingBox, create, fromPoints, transform } = require('./index')
+
+const mat4 = require('../../maths/mat4')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('poly3: measureBoundingBox() should return correct values', (t) => {
+  let ply1 = create()
+  let exp1 = [[0, 0, 0], [0, 0, 0]]
+  let ret1 = measureBoundingBox(ply1)
+  t.true(compareVectors(ret1[0], exp1[0]))
+  t.true(compareVectors(ret1[1], exp1[1]))
+
+  // simple triangle
+  let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
+  let exp2 = [[0, 0, 0], [0, 10, 10]]
+  let ret2 = measureBoundingBox(ply2)
+  t.true(compareVectors(ret2[0], exp2[0]))
+  t.true(compareVectors(ret2[1], exp2[1]))
+
+  // simple square
+  let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
+  let exp3 = [[0, 0, 0], [0, 10, 10]]
+  let ret3 = measureBoundingBox(ply3)
+  t.true(compareVectors(ret3[0], exp3[0]))
+  t.true(compareVectors(ret3[1], exp3[1]))
+
+  // V-shape
+  const points = [
+    [0, 3, 0],
+    [0, 5, 0],
+    [0, 8, 2],
+    [0, 6, 5],
+    [0, 8, 6],
+    [0, 5, 6],
+    [0, 5, 2],
+    [0, 2, 5],
+    [0, 1, 3],
+    [0, 3, 3]
+  ]
+  let ply4 = fromPoints(points)
+  let exp4 = [[0, 1, 0], [0, 8, 6]]
+  let ret4 = measureBoundingBox(ply4)
+  t.true(compareVectors(ret4[0], exp4[0]))
+  t.true(compareVectors(ret4[1], exp4[1]))
+
+  // rotated to various angles
+  const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
+  ply1 = transform(rotation, ply1)
+  ply2 = transform(rotation, ply2)
+  ply3 = transform(rotation, ply3)
+  ply4 = transform(rotation, ply4)
+  ret1 = measureBoundingBox(ply1)
+  ret2 = measureBoundingBox(ply2)
+  ret3 = measureBoundingBox(ply3)
+  ret4 = measureBoundingBox(ply4)
+  exp1 = [[0, 0, 0], [0, 0, 0]]
+  t.true(compareVectors(ret1[0], exp1[0]))
+  t.true(compareVectors(ret1[1], exp1[1]))
+  exp2 = [[-7.071067811865475, 0, 0], [0, 7.0710678118654755, 10]]
+  t.true(compareVectors(ret2[0], exp2[0]))
+  t.true(compareVectors(ret2[1], exp2[1]))
+  exp3 = [[-7.071067811865475, 0, 0], [0, 7.0710678118654755, 10]]
+  t.true(compareVectors(ret3[0], exp3[0]))
+  t.true(compareVectors(ret3[1], exp3[1]))
+  exp4 = [[-5.65685424949238, 0.7071067811865476, 0], [-0.7071067811865475, 5.656854249492381, 6]]
+  t.true(compareVectors(ret4[0], exp4[0]))
+  t.true(compareVectors(ret4[1], exp4[1]))
+})

package/src/geometries/poly3/measureBoundingSphere.d.ts

@@ -0,0 +1,6 @@
+import Poly3 from './type'
+import Vec4 from '../../maths/vec4/type'
+
+export default measureBoundingSphere
+
+declare function measureBoundingSphere(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -0,0 +1,56 @@
+const vec4 = require('../../maths/vec4')
+
+const cache = new WeakMap()
+
+/**
+ * Measure the bounding sphere of the given polygon.
+ * @param {poly3} polygon - the polygon to measure
+ * @returns {vec4} the computed bounding sphere; center point (3D) and radius
+ * @alias module:modeling/geometries/poly3.measureBoundingSphere
+ */
+const measureBoundingSphere = (polygon) => {
+  const boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
+
+  const vertices = polygon.vertices
+  const out = vec4.create()
+
+  if (vertices.length === 0) {
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
+    out[3] = 0
+    return out
+  }
+
+  // keep a list of min/max vertices by axis
+  let minx = vertices[0]
+  let miny = minx
+  let minz = minx
+  let maxx = minx
+  let maxy = minx
+  let maxz = minx
+
+  vertices.forEach((v) => {
+    if (minx[0] > v[0]) minx = v
+    if (miny[1] > v[1]) miny = v
+    if (minz[2] > v[2]) minz = v
+    if (maxx[0] < v[0]) maxx = v
+    if (maxy[1] < v[1]) maxy = v
+    if (maxz[2] < v[2]) maxz = v
+  })
+
+  out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
+  out[1] = (miny[1] + maxy[1]) * 0.5
+  out[2] = (minz[2] + maxz[2]) * 0.5
+  const x = out[0] - maxx[0]
+  const y = out[1] - maxy[1]
+  const z = out[2] - maxz[2]
+  out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
+
+  cache.set(polygon, out)
+
+  return out
+}
+
+module.exports = measureBoundingSphere