@jscad/modeling 3.0.4-alpha.0 → 3.0.5-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "3.0.4-alpha.0",
+  "version": "3.0.5-alpha.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -11,10 +11,10 @@
   "module": "dist/jscad-modeling.es.js",
   "scripts": {
     "build": "rollup --config",
-    "coverage": "c8 --all --reporter=html --reporter=text pnpm test",
+    "coverage": "c8 --all --reporter=html --reporter=text npm test",
     "test": "ava 'src/**/*.test.js' --verbose --timeout 2m",
     "test:tsd": "tsd",
-    "version": "pnpm run build && git add dist"
+    "version": "npm run build && git add dist"
   },
   "contributors": [
     {
@@ -63,5 +63,5 @@
     "c8": "^10.1.0",
     "rollup": "^4.52.0"
   },
-  "gitHead": "1de52a2b7b6bd31134fd0b72a2842f31ecf8f237"
+  "gitHead": "942d9a5eab2f234f2e1c617d5896e0230f353330"
 }

package/rollup.config.js

@@ -2,7 +2,7 @@ import * as fs from 'fs'
 
 import terser from '@rollup/plugin-terser'
 
-const {name, version, license} = JSON.parse(fs.readFileSync('package.json'))
+const { name, version, license } = JSON.parse(fs.readFileSync('package.json'))
 
 export default {
   input: 'src/index.js',

package/src/colors/colorize.js

@@ -1,6 +1,8 @@
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 
 const colorGeom2 = (color, object) => {
@@ -21,6 +23,18 @@ const colorPath2 = (color, object) => {
   return newPath2
 }
 
+const colorPath3 = (color, object) => {
+  const newPath3 = path3.clone(object)
+  newPath3.color = color
+  return newPath3
+}
+
+const colorSlice = (color, object) => {
+  const newSlice = slice.clone(object)
+  newSlice.color = color
+  return newSlice
+}
+
 const colorPoly3 = (color, object) => {
   const newPoly = poly3.clone(object)
   newPoly.color = color
@@ -46,9 +60,11 @@ export const colorize = (color, ...objects) => {
   if (color.length === 3) color = [color[0], color[1], color[2], 1.0] // add alpha
 
   const results = objects.map((object) => {
-    if (geom2.isA(object)) return colorGeom2(color, object)
     if (geom3.isA(object)) return colorGeom3(color, object)
+    if (geom2.isA(object)) return colorGeom2(color, object)
     if (path2.isA(object)) return colorPath2(color, object)
+    if (path3.isA(object)) return colorPath3(color, object)
+    if (slice.isA(object)) return colorSlice(color, object)
     if (poly3.isA(object)) return colorPoly3(color, object)
     if (Array.isArray(object)) return colorize(color, ...object)
 

package/src/geometries/geom2/fromPoints.d.ts

@@ -0,0 +1,4 @@
+import type { Geom2 } from './type.d.ts'
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+declare function fromPoints(points: Array<Vec2>): Geom2

package/src/geometries/geom2/fromPoints.js

@@ -0,0 +1,28 @@
+import * as vec2 from '../../maths/vec2/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a new 2D geometry from the given points.
+ *
+ * The direction (rotation) of the points is not relevant,
+ * as the points can define a convex or a concave polygon.
+ *
+ * The geometry must not self intersect, i.e. the sides cannot cross.
+ * @param {Array} points - list of points in 2D space
+ * @returns {geom2} a new geometry
+ * @alias module:modeling/geom2.fromPoints
+ */
+export const fromPoints = (points) => {
+  if (!Array.isArray(points)) {
+    throw new Error('the given points must be an array')
+  }
+  const length = points.length
+  if (length < 3) {
+    throw new Error('the given points must define a closed geometry with three or more points')
+  }
+  // adjust length if the given points are closed by the same point
+  if (vec2.equals(points[0], points[length - 1])) points = points.slice(0, -1)
+
+  return create([points])
+}

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

@@ -0,0 +1,22 @@
+import test from 'ava'
+
+import { fromPoints } from './index.js'
+
+test('fromPoints: creates populated geom2', (t) => {
+  const points = [[0, 0], [1, 0], [0, 1]]
+  const expected = {
+    outlines: [[[0, 0], [1, 0], [0, 1]]],
+    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  t.deepEqual(fromPoints(points), expected)
+
+  const points2 = [[0, 0], [1, 0], [0, 1], [0, 0]]
+  t.deepEqual(fromPoints(points2), expected)
+})
+
+test('fromPoints: throws for improper points', (t) => {
+  t.throws(() => fromPoints(), { instanceOf: Error })
+  t.throws(() => fromPoints(0, 0), { instanceOf: Error })
+  t.throws(() => fromPoints([]), { instanceOf: Error })
+  t.throws(() => fromPoints([[0, 0]]), { instanceOf: Error })
+})

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

@@ -1,5 +1,6 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
 export { fromSides } from './fromSides.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/geom2/index.js

@@ -26,6 +26,7 @@
  */
 export { clone } from './clone.js'
 export { create } from './create.js'
+export { fromPoints } from './fromPoints.js'
 export { fromSides } from './fromSides.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/path3/clone.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function clone(geometry: Path3): Path3

package/src/geometries/path3/clone.js

@@ -0,0 +1,11 @@
+/**
+ * Performs a shallow clone of the give geometry.
+ *
+ * @param {Path3} geometry - the geometry to clone
+ * @returns {Path3} a new path
+ * @alias module:modeling/path3.clone
+ *
+ * @example
+ * let newPath = path3.clone(oldPath)
+ */
+export const clone = (geometry) => Object.assign({}, geometry)

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

@@ -1,3 +1,4 @@
+export { clone } from './clone.js'
 export { close } from './close.js'
 export { concat } from './concat.js'
 export { create } from './create.js'

package/src/geometries/path3/index.js

@@ -24,6 +24,7 @@
  * }
  */
 
+export { clone } from './clone.js'
 export { close } from './close.js'
 export { concat } from './concat.js'
 export { create } from './create.js'

package/src/geometries/poly2/type.d.ts

@@ -1,7 +1,3 @@
 import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export declare interface Poly2 {
-  points: Array<Vec2>
-}
-
-export default Poly2
+export declare interface Poly2 { points: Array<Vec2> }

package/src/geometries/slice/fromOutlines.d.ts

@@ -0,0 +1,5 @@
+import type { Vec2 } from '../../maths/types.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+export function fromOutlines(outlines: Array<Array<Vec2>>): Slice

package/src/geometries/slice/fromOutlines.js

@@ -0,0 +1,16 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a slice from the given outlines.
+ *
+ * @param {Array} outlines - where each outline is an array of ordered points
+ * @returns {Slice} a new slice
+ * @alias module:modeling/slice.fromOutlines
+ */
+export const fromOutlines = (outlines) => {
+  // Convert from 2D points to 3D vertices
+  const contours = outlines.map((outline) => outline.map((point) => vec3.fromVec2(vec3.create(), point)))
+  return create(contours)
+}

package/src/geometries/slice/fromOutlines.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { fromOutlines } from './index.js'
+
+test('slice: fromOutlines() should return a new slice with correct values', (t) => {
+  const exp1 = {
+    contours: [
+      [[0, 0, 0], [1, 0, 0], [1, 1, 0]],
+      [[2, 2, 0], [3, 1, 0], [3, 3, 0]]
+    ]
+  }
+  const obs1 = fromOutlines([
+    [[0, 0], [1, 0], [1, 1]],
+    [[2, 2], [3, 1], [3, 3]]
+  ])
+  t.deepEqual(obs1, exp1)
+})

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

@@ -2,7 +2,7 @@ export { calculatePlane } from './calculatePlane.js'
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { equals } from './equals.js'
-export { fromGeom2 } from './fromGeom2.js'
+export { fromOutlines } from './fromOutlines.js'
 export { fromVertices } from './fromVertices.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/slice/index.js

@@ -26,7 +26,7 @@ export { calculatePlane } from './calculatePlane.js'
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { equals } from './equals.js'
-export { fromGeom2 } from './fromGeom2.js'
+export { fromOutlines } from './fromOutlines.js'
 export { fromVertices } from './fromVertices.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/maths/plane/fromNormalAndPoint.js

@@ -18,12 +18,10 @@ import * as vec3 from '../vec3/index.js'
  * @alias module:modeling/maths/plane.fromNormalAndPoint
  */
 export const fromNormalAndPoint = (out, normal, point) => {
-  const u = vec3.normalize(vec3.create(), normal)
-  const w = vec3.dot(point, u)
+  // normalize to out
+  vec3.normalize(out, normal)
+  // calculate distance
+  out[3] = vec3.dot(point, out)
 
-  out[0] = u[0]
-  out[1] = u[1]
-  out[2] = u[2]
-  out[3] = w
   return out
 }

package/src/maths/plane/fromPoints.js

@@ -1,10 +1,13 @@
 import * as vec3 from '../vec3/index.js'
 
+const ba = vec3.create()
+const ca = vec3.create()
+
 /**
  * Create a plane from the given points.
  *
  * @param {Plane} out - receiving plane
- * @param {Array} vertices - points on the plane
+ * @param {Array} vertices - list of points on the plane
  * @returns {Plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */
@@ -13,8 +16,6 @@ export const fromPoints = (out, ...vertices) => {
 
   // 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]
@@ -26,18 +27,18 @@ export const fromPoints = (out, ...vertices) => {
     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
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
     vertices.forEach((v, i) => {
       vec3.add(out, out, vertexNormal(i))
     })
-    // renormalize normal vector
+    // normalize sum
     vec3.normalize(out, out)
   }
   out[3] = vec3.dot(out, vertices[0])

package/src/maths/plane/fromPointsRandom.js

@@ -15,26 +15,26 @@ import * as vec3 from '../vec3/index.js'
  * @alias module:modeling/maths/plane.fromPointsRandom
  */
 export const fromPointsRandom = (out, a, b, c) => {
-  let ba = vec3.subtract(vec3.create(), b, a)
-  let ca = vec3.subtract(vec3.create(), c, a)
+  const ba = vec3.subtract(vec3.create(), b, a)
+  const ca = vec3.subtract(vec3.create(), c, a)
   if (vec3.length(ba) < EPS) {
-    ba = vec3.orthogonal(ba, ca)
+    vec3.orthogonal(ba, ca)
   }
   if (vec3.length(ca) < EPS) {
-    ca = vec3.orthogonal(ca, ba)
+    vec3.orthogonal(ca, ba)
   }
-  let normal = vec3.cross(vec3.create(), ba, ca)
+
+  // calculate plane normal
+  const normal = vec3.cross(out, ba, ca)
   if (vec3.length(normal) < EPS) {
     // this would mean that ba == ca.negated()
-    ca = vec3.orthogonal(ca, ba)
-    normal = vec3.cross(normal, ba, ca)
+    vec3.orthogonal(ca, ba)
+    vec3.cross(normal, ba, ca)
   }
-  normal = vec3.normalize(normal, normal)
-  const w = vec3.dot(normal, a)
+  vec3.normalize(normal, normal)
+
+  // and distance
+  out[3] = vec3.dot(normal, a)
 
-  out[0] = normal[0]
-  out[1] = normal[1]
-  out[2] = normal[2]
-  out[3] = w
   return out
 }

package/src/measurements/measureAggregateEpsilon.js

@@ -3,6 +3,8 @@ import { flatten } from '../utils/flatten.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 
 import { measureAggregateBoundingBox } from './measureAggregateBoundingBox.js'
 import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
@@ -23,7 +25,7 @@ export const measureAggregateEpsilon = (...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)
+    if (geom3.isA(geometry || path3.isA(geometry) || slice.isA(geometry))) return Math.max(dimensions, 3)
     return 0
   }, dimensions)
   return calculateEpsilonFromBounds(bounds, dimensions)

package/src/measurements/measureAggregateEpsilon.test.js

@@ -13,7 +13,7 @@ test('measureAggregateEpsilon (single objects)', (t) => {
   t.is(calculatedEpsilon, expectedEpsilon)
 })
 
-test('measureAggregateEpsilon (multiple objects)', (t) => {
+test('measureAggregateEpsilon (multiple 3D 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)

package/src/measurements/measureArea.js

@@ -3,6 +3,7 @@ import { flatten } from '../utils/flatten.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -12,10 +13,10 @@ 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
+ * @param {Path2|Path3} geometry - geometry to measure
  * @returns {number} area of the geometry
  */
-const measureAreaOfPath2 = () => 0
+const measureAreaOfPath = () => 0
 
 /*
  * Measure the area of the given geometry.
@@ -87,9 +88,10 @@ export const measureArea = (...geometries) => {
   geometries = flatten(geometries)
 
   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)
+    if (geom2.isA(geometry)) return measureAreaOfGeom2(geometry)
+    if (path2.isA(geometry)) return measureAreaOfPath(geometry)
+    if (path3.isA(geometry)) return measureAreaOfPath(geometry)
     if (slice.isA(geometry)) return measureAreaOfSlice(geometry)
     return 0
   })

package/src/measurements/measureArea.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, cuboid } from '../primitives/index.js'
 
@@ -12,6 +12,7 @@ test('measureArea: single objects', (t) => {
   const acube = cuboid()
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -25,6 +26,7 @@ test('measureArea: single objects', (t) => {
   const carea = measureArea(acube)
 
   const p2area = measureArea(apath2)
+  const p3area = measureArea(apath3)
   const g2area = measureArea(ageom2)
   const g3area = measureArea(ageom3)
   const slarea = measureArea(aslice)
@@ -38,6 +40,7 @@ test('measureArea: single objects', (t) => {
   t.is(carea, 24) // 2x2x6
 
   t.is(p2area, 0)
+  t.is(p3area, 0)
   t.is(g2area, 0)
   t.is(g3area, 0)
   t.is(slarea, 0)

package/src/measurements/measureBoundingBox.js

@@ -6,6 +6,7 @@ import * as vec3 from '../maths/vec3/index.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -70,6 +71,18 @@ const measureBoundingBoxOfPath2 = (geometry) => {
   return boundingBox
 }
 
+/*
+ * Measure the min and max bounds of the given (path3) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfPath3 = (geometry) => {
+  const boundingBox = []
+  path3.toVertices(geometry).forEach((vertice) => {
+    expand3(boundingBox, vertice)
+  })
+  return boundingBox
+}
+
 /*
  * Measure the min and max bounds of the given (geom2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
@@ -123,9 +136,10 @@ export const measureBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)
-    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom2)
     if (geom3.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom3)
+    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom2)
+    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)
+    if (path3.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath3)
     if (slice.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfSlice)
     return [[0, 0, 0], [0, 0, 0]]
   })

package/src/measurements/measureBoundingBox.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, cuboid } from '../primitives/index.js'
 
@@ -14,6 +14,7 @@ test('measureBoundingBox (single objects)', (t) => {
   const acube = cuboid()
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -27,6 +28,7 @@ test('measureBoundingBox (single objects)', (t) => {
   const cbounds = measureBoundingBox(acube)
 
   const p2bounds = measureBoundingBox(apath2)
+  const p3bounds = measureBoundingBox(apath3)
   const g2bounds = measureBoundingBox(ageom2)
   const g3bounds = measureBoundingBox(ageom3)
   const slbounds = measureBoundingBox(aslice)
@@ -40,6 +42,7 @@ test('measureBoundingBox (single objects)', (t) => {
   t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
 
   t.deepEqual(p2bounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(p3bounds, [[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(slbounds, [[0, 0, 0], [0, 0, 0]])

package/src/measurements/measureBoundingSphere.js

@@ -6,6 +6,7 @@ import * as vec3 from '../maths/vec3/index.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -60,6 +61,33 @@ const measureBoundingSphereOfPoints = (points) => {
   return [centroid, radius]
 }
 
+/*
+ * Measure the bounding sphere of the given 2D points.
+ * @return {[[x, y, z], radius]} the bounding sphere for the points
+ */
+const measureBoundingSphereOfVertices = (vertices) => {
+  const centroid = vec3.create()
+  let radius = 0
+
+  if (vertices.length > 0) {
+    // calculate the centroid of the vertices
+    let numVertices = 0
+    vertices.forEach((vertex) => {
+      vec3.add(centroid, centroid, vertex)
+      numVertices++
+    })
+    vec3.scale(centroid, centroid, 1 / numVertices)
+
+    // find the farthest vertex from the centroid
+    vertices.forEach((vertex) => {
+      radius = Math.max(radius, vec3.squaredDistance(centroid, vertex))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  return [centroid, radius]
+}
+
 /*
  * Measure the bounding sphere of the given (path2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
@@ -106,36 +134,16 @@ const measureBoundingSphereOfGeom3 = (geometry) => {
 }
 
 /*
- * Measure the bounding sphere of the given (geom3) geometry.
+ * Measure the bounding sphere of the given (slice) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfSlice = (geometry) => {
-  const centroid = vec3.create()
-  let radius = 0
-  let numVertices = 0
+const measureBoundingSphereOfPath3 = (geometry) => measureBoundingSphereOfVertices(path3.toVertices(geometry))
 
-  // calculate the centroid of the geometry
-  geometry.contours.forEach((contour) => {
-    contour.forEach((vertex) => {
-      vec3.add(centroid, centroid, vertex)
-      numVertices++
-    })
-  })
-
-  if (numVertices > 0) {
-    vec3.scale(centroid, centroid, 1 / numVertices)
-
-    // find the farthest vertex from the centroid
-    geometry.contours.forEach((contour) => {
-      contour.forEach((vertex) => {
-        radius = Math.max(radius, vec3.squaredDistance(centroid, vertex))
-      })
-    })
-    radius = Math.sqrt(radius)
-  }
-
-  return [centroid, radius]
-}
+/*
+ * Measure the bounding sphere of the given (slice) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfSlice = (geometry) => measureBoundingSphereOfVertices(slice.toVertices(geometry))
 
 /**
  * Measure the (approximate) bounding sphere of the given geometries.
@@ -151,9 +159,10 @@ export const measureBoundingSphere = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath2)
-    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom2)
     if (geom3.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom3)
+    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom2)
+    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath2)
+    if (path3.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath3)
     if (slice.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfSlice)
     return [[0, 0, 0], 0]
   })

package/src/measurements/measureBoundingSphere.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, ellipsoid } from '../primitives/index.js'
 
@@ -12,6 +12,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   const aellipsoid = ellipsoid({ radius: [5, 10, 15], center: [5, 5, 5] })
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -25,6 +26,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   const cbounds = measureBoundingSphere(aellipsoid)
 
   const p2bounds = measureBoundingSphere(apath2)
+  const p3bounds = measureBoundingSphere(apath3)
   const g2bounds = measureBoundingSphere(ageom2)
   const g3bounds = measureBoundingSphere(ageom3)
   const slbounds = measureBoundingSphere(aslice)
@@ -38,6 +40,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   t.deepEqual(cbounds, [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15])
 
   t.deepEqual(p2bounds, [[0, 0, 0], 0])
+  t.deepEqual(p3bounds, [[0, 0, 0], 0])
   t.deepEqual(g2bounds, [[0, 0, 0], 0])
   t.deepEqual(g3bounds, [[0, 0, 0], 0])
   t.deepEqual(slbounds, [[0, 0, 0], 0])