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

package/src/operations/minkowski/minkowskiSum.test.js

@@ -0,0 +1,199 @@
+import test from 'ava'
+
+import { geom3 } from '../../geometries/index.js'
+import { cuboid, sphere, torus } from '../../primitives/index.js'
+import { subtract } from '../booleans/index.js'
+import { measureBoundingBox } from '../../measurements/index.js'
+
+import { minkowskiSum } from './index.js'
+
+test('minkowskiSum: throws for non-geom3 inputs', (t) => {
+  t.throws(() => minkowskiSum('invalid', cuboid()), { message: /requires geom3/ })
+  t.throws(() => minkowskiSum(cuboid(), 'invalid'), { message: /requires geom3/ })
+})
+
+test('minkowskiSum: throws for wrong number of geometries', (t) => {
+  t.throws(() => minkowskiSum(), { message: /exactly two/ })
+  t.throws(() => minkowskiSum(cuboid()), { message: /exactly two/ })
+  t.throws(() => minkowskiSum(cuboid(), cuboid(), cuboid()), { message: /exactly two/ })
+})
+
+test('minkowskiSum: cube + cube produces correct bounds', (t) => {
+  // Cube1: size 10 (±5 from origin)
+  // Cube2: size 4 (±2 from origin)
+  // Minkowski sum should be size 14 (±7 from origin)
+  const cube1 = cuboid({ size: [10, 10, 10] })
+  const cube2 = cuboid({ size: [4, 4, 4] })
+
+  const result = minkowskiSum(cube1, cube2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measureBoundingBox(result)
+  // Allow small tolerance for floating point
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][1] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[0][2] - (-7)) < 0.001)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][1] - 7) < 0.001)
+  t.true(Math.abs(bounds[1][2] - 7) < 0.001)
+})
+
+test('minkowskiSum: cube + sphere produces correct bounds', (t) => {
+  // Cube: size 10 (±5 from origin)
+  // Sphere: radius 2
+  // Minkowski sum should be ±7 from origin
+  const cube = cuboid({ size: [10, 10, 10] })
+  const sph = sphere({ radius: 2, segments: 16 })
+
+  const result = minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measureBoundingBox(result)
+  // Allow small tolerance
+  t.true(Math.abs(bounds[0][0] - (-7)) < 0.1)
+  t.true(Math.abs(bounds[1][0] - 7) < 0.1)
+})
+
+test('minkowskiSum: sphere + sphere produces correct bounds', (t) => {
+  // Sphere1: radius 3
+  // Sphere2: radius 2
+  // Minkowski sum should be a sphere-like shape with radius ~5
+  const sph1 = sphere({ radius: 3, segments: 16 })
+  const sph2 = sphere({ radius: 2, segments: 16 })
+
+  const result = minkowskiSum(sph1, sph2)
+
+  t.notThrows(() => geom3.validate(result))
+
+  const bounds = measureBoundingBox(result)
+  // Should be approximately ±5
+  t.true(Math.abs(bounds[0][0] - (-5)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 5) < 0.2)
+})
+
+test('minkowskiSum: empty geometry returns empty', (t) => {
+  const empty = geom3.create()
+  const cube = cuboid({ size: [10, 10, 10] })
+
+  const result = minkowskiSum(empty, cube)
+
+  t.notThrows(() => geom3.validate(result))
+  t.is(geom3.toPolygons(result).length, 0)
+})
+
+test('minkowskiSum: result is convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  const sph = sphere({ radius: 2, segments: 12 })
+
+  const result = minkowskiSum(cube, sph)
+
+  t.notThrows(() => geom3.validate(result))
+  t.true(geom3.isConvex(result))
+})
+
+// Non-convex tests
+
+test('minkowskiSum: non-convex + convex produces valid geometry', (t) => {
+  // Create L-shaped non-convex geometry
+  const big = cuboid({ size: [10, 10, 10] })
+  const corner = cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+  const lShape = subtract(big, corner)
+
+  t.false(geom3.isConvex(lShape))
+
+  const sph = sphere({ radius: 1, segments: 8 })
+
+  const result = minkowskiSum(lShape, sph)
+
+  t.true(geom3.toPolygons(result).length > 0)
+  t.true(geom3.isA(result))
+})
+
+test('minkowskiSum: non-convex + convex produces correct bounds', (t) => {
+  // Cube with hole through it
+  const cube = cuboid({ size: [10, 10, 10] })
+  const hole = cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = subtract(cube, hole)
+
+  t.false(geom3.isConvex(cubeWithHole))
+
+  // Offset by sphere of radius 1
+  const sph = sphere({ radius: 1, segments: 8 })
+  const result = minkowskiSum(cubeWithHole, sph)
+
+  t.true(geom3.isA(result))
+
+  const bounds = measureBoundingBox(result)
+
+  // Original cube is ±5, plus sphere radius 1 = ±6
+  t.true(Math.abs(bounds[0][0] - (-6)) < 0.2)
+  t.true(Math.abs(bounds[1][0] - 6) < 0.2)
+})
+
+test('minkowskiSum: convex + non-convex swaps operands', (t) => {
+  // Minkowski sum is commutative, so A⊕B = B⊕A
+  const cube = cuboid({ size: [10, 10, 10] })
+  const hole = cuboid({ size: [4, 4, 20] })
+  const cubeWithHole = subtract(cube, hole)
+
+  const sph = sphere({ radius: 1, segments: 8 })
+
+  // convex + non-convex should work (swaps internally)
+  const result = minkowskiSum(sph, cubeWithHole)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+})
+
+test('minkowskiSum: throws for two non-convex geometries', (t) => {
+  const cube1 = cuboid({ size: [10, 10, 10] })
+  const hole1 = cuboid({ size: [4, 4, 20] })
+  const nonConvex1 = subtract(cube1, hole1)
+
+  const cube2 = cuboid({ size: [8, 8, 8] })
+  const hole2 = cuboid({ size: [3, 3, 16] })
+  const nonConvex2 = subtract(cube2, hole2)
+
+  t.throws(() => minkowskiSum(nonConvex1, nonConvex2), { message: /two non-convex/ })
+})
+
+test('minkowskiSum: torus + sphere preserves hole (face-local apex)', (t) => {
+  // Torus with innerRadius=3 (tube radius) and outerRadius=8 (distance to tube center)
+  // At z=0, the torus extends from radius 5 to 11 (8-3 to 8+3)
+  // Adding sphere of radius 1 should give 4 to 12
+  const torusShape = torus({
+    innerRadius: 3,
+    outerRadius: 8,
+    innerSegments: 16,
+    outerSegments: 24
+  })
+
+  const sph = sphere({ radius: 1, segments: 8 })
+
+  t.false(geom3.isConvex(torusShape))
+
+  const result = minkowskiSum(torusShape, sph)
+
+  t.true(geom3.isA(result))
+  t.true(geom3.toPolygons(result).length > 0)
+
+  // Check that the hole is preserved by examining vertices at z≈0
+  const polygons = geom3.toPolygons(result)
+  let minRadius = Infinity
+
+  for (const poly of polygons) {
+    for (const v of poly.vertices) {
+      if (Math.abs(v[2]) < 0.5) {
+        const r = Math.sqrt(v[0] * v[0] + v[1] * v[1])
+        if (r < minRadius) minRadius = r
+      }
+    }
+  }
+
+  // With face-local apex, hole should be preserved
+  // Inner radius should be around 4 (8-3-1 = 4)
+  // If centroid-based (buggy), hole would be filled and minRadius would be ~0
+  t.true(minRadius > 3, `hole should be preserved, got minRadius=${minRadius}`)
+})

package/src/operations/modifiers/generalize.test.js

@@ -15,7 +15,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply no modifications
   let result = generalize({}, geometry1)
-  let pts = geom3.toPoints(result)
+  let pts = geom3.toVertices(result)
   let exp = [
     [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
@@ -35,7 +35,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply snap only
   result = generalize({ snap: true }, geometry1)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(result)
   exp = [
     [[-1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [-1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
       [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, -3.1415821816142815]],
@@ -55,7 +55,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply triangulate only
   result = generalize({ triangulate: true }, geometry1)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(result)
   exp = [
     [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
@@ -89,7 +89,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply simplify only (triangles => quads)
   result = generalize({ simplify: true }, geometry2)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(result)
   exp = [
     [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
@@ -109,7 +109,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 })
 
 test('generalize: generalize of a geom3 with T junctions produces an expected geom3', (t) => {
-  const geometry1 = geom3.fromPoints(
+  const geometry1 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -132,7 +132,7 @@ test('generalize: generalize of a geom3 with T junctions produces an expected ge
   )
 
   const result = generalize({ snap: true, triangulate: true }, geometry1)
-  const pts = geom3.toPoints(result)
+  const pts = geom3.toVertices(result)
   const exp = [
     [[-1, 0, 0.2], [-1, -1, -1], [-1, -1, 1]],
     [[-1, 0, 0.2], [-1, -1, 1], [-1, 0, 1]],

package/src/operations/modifiers/insertTjunctions.test.js

@@ -11,7 +11,7 @@ import { insertTjunctions } from './insertTjunctions.js'
 test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [2, 2, 2] })
-  const geometry3 = geom3.fromPoints(
+  const geometry3 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -24,7 +24,7 @@ test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
       [[-1, 1, 1], [-1, -1, 1], [0, 0, 1]]
     ]
   )
-  const geometry4 = geom3.fromPoints(
+  const geometry4 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -121,6 +121,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
     //   at the left and right side of the polygon
     // Iterate over all polygons that have a corner at this y coordinate:
     const polygonIndexesWithCorner = yCoordinateToPolygonIndexes.get(yCoordinate)
+    let removeCount = 0 // track removals to filter at end (avoids O(n²) splice)
     for (let activePolygonIndex = 0; activePolygonIndex < activePolygons.length; ++activePolygonIndex) {
       const activePolygon = activePolygons[activePolygonIndex]
       const polygonIndex = activePolygon.polygonIndex
@@ -144,9 +145,9 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         }
         if ((newLeftVertexIndex !== activePolygon.leftVertexIndex) && (newLeftVertexIndex === newRightVertexIndex)) {
           // We have increased leftVertexIndex or decreased rightVertexIndex, and now they point to the same vertex
-          // This means that this is the bottom point of the polygon. We'll remove it:
-          activePolygons.splice(activePolygonIndex, 1)
-          --activePolygonIndex
+          // This means that this is the bottom point of the polygon, so Mark it for removal
+          activePolygon.remove = true
+          removeCount++
         } else {
           activePolygon.leftVertexIndex = newLeftVertexIndex
           activePolygon.rightVertexIndex = newRightVertexIndex
@@ -161,6 +162,12 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         }
       } // if polygon has corner here
     } // for activePolygonIndex
+
+    // Filter out marked polygons in single pass (O(n) instead of O(n²) splice)
+    if (removeCount > 0) {
+      activePolygons = activePolygons.filter((p) => !p.remove)
+    }
+
     let nextYcoordinate
     if (yIndex >= yCoordinates.length - 1) {
       // last row, all polygons must be finished here:

package/src/operations/modifiers/reTesselateCoplanarPolygons.test.js

@@ -16,7 +16,7 @@ const rotatePoly3 = (angles, polygon) => {
   return poly3.transform(matrix, polygon)
 }
 
-test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
+test('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
   const polyA = poly3.create([[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]])
   const polyB = poly3.create([[5, -5, 0], [8, 0, 0], [5, 5, 0]])
   const polyC = poly3.create([[-5, 5, 0], [-8, 0, 0], [-5, -5, 0]])
@@ -68,3 +68,38 @@ test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) =>
   obs = reTesselateCoplanarPolygons([polyH, polyI, polyJ, polyK, polyL])
   t.is(obs.length, 1)
 })
+
+// Test for mark-and-filter optimization: multiple polygons that reach their
+// bottom point at the same y-coordinate (triggering the removal code path)
+test('retessellateCoplanarPolygons: should correctly handle multiple polygon removals', (t) => {
+  // Create multiple triangular polygons that all end at the same y-coordinate
+  // This exercises the mark-and-filter removal optimization
+  const poly1 = poly3.create([[0, 0, 0], [2, 0, 0], [1, 3, 0]]) // triangle pointing up
+  const poly2 = poly3.create([[3, 0, 0], [5, 0, 0], [4, 3, 0]]) // triangle pointing up
+  const poly3a = poly3.create([[6, 0, 0], [8, 0, 0], [7, 3, 0]]) // triangle pointing up
+
+  // These polygons share the same plane and have vertices at y=0 and y=3
+  // During retessellation, all three will be active and then removed at y=3
+  const obs = reTesselateCoplanarPolygons([poly1, poly2, poly3a])
+
+  // Each triangle should be preserved (they don't overlap)
+  t.is(obs.length, 3)
+
+  // Verify each polygon has 3 vertices (triangles)
+  obs.forEach((polygon) => {
+    t.is(polygon.vertices.length, 3)
+  })
+})
+
+// Test for mark-and-filter with overlapping polygons that get merged
+test('retessellateCoplanarPolygons: should merge adjacent polygons with shared edges', (t) => {
+  // Two adjacent squares sharing an edge at x=5
+  const poly1 = poly3.create([[0, 0, 0], [5, 0, 0], [5, 5, 0], [0, 5, 0]])
+  const poly2 = poly3.create([[5, 0, 0], [10, 0, 0], [10, 5, 0], [5, 5, 0]])
+
+  const obs = reTesselateCoplanarPolygons([poly1, poly2])
+
+  // Should merge into a single rectangle
+  t.is(obs.length, 1)
+  t.is(obs[0].vertices.length, 4) // rectangle has 4 vertices
+})

package/src/operations/modifiers/retessellate.js

@@ -24,8 +24,10 @@ export const retessellate = (geometry) => {
   const destPolygons = []
   classified.forEach((group) => {
     if (Array.isArray(group)) {
-      const reTessellateCoplanarPolygons = reTesselateCoplanarPolygons(group)
-      destPolygons.push(...reTessellateCoplanarPolygons)
+      const coplanarPolygons = reTesselateCoplanarPolygons(group)
+      for (let i = 0; i < coplanarPolygons.length; i++) {
+        destPolygons.push(coplanarPolygons[i])
+      }
     } else {
       destPolygons.push(group)
     }

package/src/operations/modifiers/retessellate.test.js

@@ -82,15 +82,15 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
     [[10.0, -5.0, -5.0], [10.0, 5.0, -5.0], [10.0, 5.0, 5.0], [10.0, -5.0, 5.0]] // end
   ]
 
-  const obj1 = geom3.fromPoints(box1)
-  const obj2 = geom3.fromPoints(box1.concat(box2)) // combined geometry
-  const obj3 = geom3.fromPoints(box3)
-  const obj4 = geom3.fromPoints(box4)
-  const obj5 = geom3.fromPoints(box5)
+  const obj1 = geom3.fromVertices(box1)
+  const obj2 = geom3.fromVertices(box1.concat(box2)) // combined geometry
+  const obj3 = geom3.fromVertices(box3)
+  const obj4 = geom3.fromVertices(box4)
+  const obj5 = geom3.fromVertices(box5)
 
   // one solid geometry
   const ret1 = retessellate(obj1)
-  const pts1 = geom3.toPoints(ret1)
+  const pts1 = geom3.toVertices(ret1)
   const exp1 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
@@ -103,7 +103,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two non-overlapping geometries
   const ret2 = retessellate(obj2)
-  const pts2 = geom3.toPoints(ret2)
+  const pts2 = geom3.toVertices(ret2)
   const exp2 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
@@ -122,7 +122,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two touching geometries (faces)
   const ret3 = retessellate(obj3)
-  const pts3 = geom3.toPoints(ret3)
+  const pts3 = geom3.toVertices(ret3)
   const exp3 = [
     [[-5, 5, 15], [-5, 5, -5], [-5, -5, -5], [-5, -5, 15]],
     [[5, -5, 15], [5, -5, -5], [5, 5, -5], [5, 5, 15]],
@@ -135,7 +135,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two overlapping geometries
   const ret4 = retessellate(obj4)
-  const pts4 = geom3.toPoints(ret4)
+  const pts4 = geom3.toVertices(ret4)
   const exp4 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[-5, -5, -5], [5, -5, -5], [5, -5, 5], [-5, -5, 5]],
@@ -160,7 +160,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // coplanar polygons
   const ret5 = retessellate(obj5)
-  const pts5 = geom3.toPoints(ret5)
+  const pts5 = geom3.toVertices(ret5)
   const exp5 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[10, -5, -5], [10, -5, 5], [-5, -5, 5], [-5, -5, -5]],

package/src/operations/modifiers/snap.test.js

@@ -25,31 +25,40 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
 
   pts = path2.toPoints(results[1])
   exp = [
-    [0.5, 0], [0.383022221559489, 0.3213938048432696],
-    [0.08682408883346521, 0.492403876506104], [-0.2499999999999999, 0.43301270189221935],
-    [-0.46984631039295416, 0.17101007166283444], [-0.4698463103929542, -0.17101007166283433],
-    [-0.2500000000000002, -0.43301270189221924], [0.08682408883346499, -0.49240387650610407],
-    [0.3830222215594889, -0.3213938048432698]
+    [0.5, 0],
+    [0.35355000000000003, 0.35355000000000003],
+    [0, 0.5],
+    [-0.35355000000000003, 0.35355000000000003],
+    [-0.5, 0],
+    [-0.35355000000000003, -0.35355000000000003],
+    [0, -0.5],
+    [0.35355000000000003, -0.35355000000000003]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[2])
   exp = [
-    [0.6666666666666666, 0], [0.5106962954126519, 0.4285250731243595],
-    [0.11576545177795361, 0.6565385020081387], [-0.33333333333333315, 0.5773502691896257],
-    [-0.6264617471906055, 0.22801342888377923], [-0.6264617471906055, -0.2280134288837791],
-    [-0.3333333333333336, -0.5773502691896256], [0.1157654517779533, -0.6565385020081387],
-    [0.5106962954126518, -0.4285250731243597]
+    [0.6666666666666666, 0],
+    [0.4714, 0.4714],
+    [0, 0.6666666666666666],
+    [-0.4714, 0.4714],
+    [-0.6666666666666666, 0],
+    [-0.4714, -0.4714],
+    [0, -0.6666666666666666],
+    [0.4714, -0.4714]
   ]
   t.true(comparePoints(pts, exp))
 
   pts = path2.toPoints(results[3])
   exp = [
-    [1570.7979271820118, 0], [1203.3061290889411, 1009.6890116376164],
-    [272.7710864950155, 1546.9412033856784], [-785.3989635910059, 1360.3552181729126],
-    [-1476.0772155839566, 537.2521917480618], [-1476.0772155839566, -537.2521917480618],
-    [-785.3989635910059, -1360.3552181729126], [272.7710864950155, -1546.9412033856784],
-    [1203.3061290889411, -1009.6890116376164]
+    [1570.7963267948967, 0],
+    [1110.7100826766714, 1110.7100826766714],
+    [0, 1570.7963267948967],
+    [-1110.7100826766714, 1110.7100826766714],
+    [-1570.7963267948967, 0],
+    [-1110.7100826766714, -1110.7100826766714],
+    [0, -1570.7963267948967],
+    [1110.7100826766714, -1110.7100826766714]
   ]
   t.true(comparePoints(pts, exp))
 })
@@ -117,11 +126,11 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const results = snap(geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 4)
 
-  let pts = geom3.toPoints(results[0])
+  let pts = geom3.toVertices(results[0])
   let exp = []
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[1])
+  pts = geom3.toVertices(results[1])
   exp = [
     [[-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5]],
     [[0.5, -0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [0.5, -0.5, 0.5]],
@@ -132,7 +141,7 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   ]
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[2])
+  pts = geom3.toVertices(results[2])
   exp = [
     [[-0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [-0.6666666666666667, -0.6666666666666667, 0.6666666666666667],
       [-0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, -0.6666666666666667]],
@@ -149,7 +158,7 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   ]
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[3])
+  pts = geom3.toVertices(results[3])
   exp = [
     [[-1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [-1570.7963267948967, -1570.7963267948967, 1570.7963267948967],
       [-1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, -1570.7963267948967]],

package/src/operations/offsets/offsetGeom3.test.js

@@ -19,7 +19,7 @@ test('offset: offset empty geom3', (t) => {
   t.is(measureArea(result), 0)
   t.is(measureVolume(result), 0)
   t.is(geom3.toPolygons(result).length, 0)
-  t.is(geom3.toPoints(result).length, 0)
+  t.is(geom3.toVertices(result).length, 0)
 })
 
 test('offset: offset geom3 preserves color', (t) => {
@@ -37,10 +37,10 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
     [[-5, -5, -5], [-5, 15, -5], [15, 15, -5], [15, -5, -5]],
     [[-5, -5, 15], [15, -5, 15], [15, 15, 15], [-5, 15, 15]]
   ]
-  const geometry = geom3.fromPoints(polygonsAsPoints)
+  const geometry = geom3.fromVertices(polygonsAsPoints)
 
   const obs = offset({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   const exp0 = [
     [-7, -5, -5],
     [-7, -5, 15],
@@ -62,15 +62,14 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
 
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = offset({ delta: 5 }, geometry2)
-  const pts2 = geom3.toPoints(obs2)
+  const pts2 = geom3.toVertices(obs2)
   t.notThrows.skip(() => geom3.validate(obs2))
   t.is(measureArea(obs), 3178.8059464475555)
   t.is(measureVolume(obs), 13504.574121271067)
   t.is(pts2.length, 864)
 })
 
-test('offsetGeom3: offset completes properly, issue 876', async (t) => {
-  setTimeout(() => t.fail(), 1000)
+test('offsetGeom3: offset completes properly, issue 876', (t) => {
   const polies = [
     poly3.create([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
     poly3.create([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
@@ -90,9 +89,8 @@ test('offsetGeom3: offset completes properly, issue 876', async (t) => {
 
   const sub = geom3.create(polies)
 
-  return new Promise((resolve, reject) => {
-    offset({ delta: 1.3, corners: 'round', segments: 12 }, sub)
-    t.pass()
-    resolve()
-  })
+  const obs = offset({ delta: 1.3, corners: 'round', segments: 12 }, sub)
+  t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 524.9674760547548)
+  t.is(measureVolume(obs), 604.0599465573156)
 })

package/src/operations/transforms/center.test.js

@@ -53,11 +53,11 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // center about X
   let centered = center({ axes: [true, false, false] }, geometry)
-  let pts = geom3.toPoints(centered)
+  let pts = geom3.toVertices(centered)
   let exp = [
     [[-5, -7, -12], [-5, -7, 18], [-5, 13, 18], [-5, 13, -12]],
     [[5, -7, -12], [5, 13, -12], [5, 13, 18], [5, -7, 18]],
@@ -71,14 +71,14 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerX(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Y
   centered = center({ axes: [false, true, false] }, geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   exp = [
     [[-2, -10, -12], [-2, -10, 18], [-2, 10, 18], [-2, 10, -12]],
     [[8, -10, -12], [8, 10, -12], [8, 10, 18], [8, -10, 18]],
@@ -92,14 +92,14 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerY(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Z
   centered = center({ axes: [false, false, true] }, geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   exp = [
     [[-2, -7, -15], [-2, -7, 15], [-2, 13, 15], [-2, 13, -15]],
     [[8, -7, -15], [8, 13, -15], [8, 13, 15], [8, -7, 15]],
@@ -113,7 +113,7 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerZ(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))