@jscad/modeling 2.9.2 → 2.9.5

package/src/operations/extrusions/extrudeRotate.test.js

@@ -11,7 +11,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
 
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -22,18 +22,18 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   let geometry3 = extrudeRotate({ segments: 4, angle: Math.PI / 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
-    [[10, 4.898587196589413e-16, 8], [26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8]],
-    [[10, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [10, 4.898587196589413e-16, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [26, -4.898587196589413e-16, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
-    [[7.071067811865476, 7.0710678118654755, -8], [7.071067811865476, 7.0710678118654755, 8], [18.384776310850242, 18.384776310850235, 8]],
-    [[18.384776310850242, 18.384776310850235, 8], [18.384776310850242, 18.384776310850235, -8], [7.071067811865476, 7.0710678118654755, -8]],
-    [[26, 4.898587196589413e-16, 8], [10, 4.898587196589413e-16, 8], [10, -4.898587196589413e-16, -8]],
-    [[10, -4.898587196589413e-16, -8], [26, -4.898587196589413e-16, -8], [26, 4.898587196589413e-16, 8]]
+    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
+    [[7.0710678118654755, 7.071067811865475, -8], [7.0710678118654755, 7.071067811865475, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[18.38477631085024, 18.384776310850235, 8], [18.38477631085024, 18.384776310850235, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, 8], [10, 0, 8], [10, 0, -8]],
+    [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
@@ -61,7 +61,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, 18.384776310850235, 8],
     [-11.803752993228215, 23.166169628897567, 8]
   ]
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 
@@ -72,7 +72,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, -18.384776310850235, 8],
     [23.166169628897567, 11.803752993228215, 8]
   ]
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 })
@@ -83,26 +83,26 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 512)
 
   // test overlapping edges
   geometry2 = geom2.fromPoints([[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 64)
 
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.fromPoints([[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 80)
 })
 
@@ -113,16 +113,16 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   let obs = extrudeRotate({ segments: 4, angle: Math.PI / 2 }, geometry)
   let pts = geom3.toPoints(obs)
   let exp = [
-    [[0, 4.898587196589413e-16, 8], [7, 4.898587196589413e-16, 8], [-6.123233995736767e-17, 7, 8]],
-    [[7, -4.898587196589413e-16, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [9.184850993605148e-16, 7, -8]],
-    [[7, 4.898587196589413e-16, 8], [7, -4.898587196589413e-16, -8], [9.184850993605148e-16, 7, -8]],
-    [[7, 4.898587196589413e-16, 8], [9.184850993605148e-16, 7, -8], [-6.123233995736767e-17, 7, 8]],
-    [[4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589413e-16, 2.999519565323715e-32, 8], [-6.123233995736767e-17, 7, 8]],
-    [[-6.123233995736767e-17, 7, 8], [9.184850993605148e-16, 7, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8]],
-    [[0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8], [7, 4.898587196589413e-16, 8]]
+    [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
+    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [0, 7, -8], [0, 7, 8]],
+    [[0, 0, -8], [0, 0, 8], [0, 7, 8]],
+    [[0, 7, 8], [0, 7, -8], [0, 0, -8]],
+    [[7, 0, 8], [0, 0, 8], [0, 0, -8]],
+    [[0, 0, -8], [7, 0, -8], [7, 0, 8]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -132,26 +132,26 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   obs = extrudeRotate({ segments: 8, angle: Math.PI / 2 }, geometry)
   pts = geom3.toPoints(obs)
   exp = [
-    [[1, -4.898587196589413e-16, -8], [3.4638242249419727e-16, -3.4638242249419736e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, -4.898587196589413e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [0.7071067811865479, 0.7071067811865471, -8], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [2, 2.4492935982947064e-16, 4], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [1.414213562373095, 1.4142135623730951, 4], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, 4.898587196589413e-16, 8], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0.7071067811865479, 0.7071067811865471, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [0.7071067811865479, 0.7071067811865471, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [5.51091059616309e-16, 1, -8], [-1.2246467991473532e-16, 2, 4]],
-    [[0.7071067811865472, 0.7071067811865478, 8], [1.414213562373095, 1.4142135623730951, 4], [-1.2246467991473532e-16, 2, 4]],
-    [[0.7071067811865472, 0.7071067811865478, 8], [-1.2246467991473532e-16, 2, 4], [-4.286263797015736e-16, 1, 8]],
-    [[-3.4638242249419727e-16, 3.4638242249419736e-16, 8], [0.7071067811865472, 0.7071067811865478, 8], [-4.286263797015736e-16, 1, 8]],
-    [[5.51091059616309e-16, 1, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[-4.898587196589415e-16, 2.9995195653237163e-32, 8], [-4.286263797015738e-16, 1, 8], [-1.2246467991473544e-16, 2, 4]],
-    [[-1.2246467991473544e-16, 2, 4], [5.51091059616309e-16, 1, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8], [1, -4.898587196589413e-16, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, -4.898587196589413e-16, -8], [2, 2.4492935982947064e-16, 4]]
+    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [2, 0, 4], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0, 1, -8], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [1.4142135623730951, 1.414213562373095, 4], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [0, 2, 4], [0, 1, 8]],
+    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
+    [[0, 1, -8], [0, 0, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 1, 8], [0, 2, 4]],
+    [[0, 2, 4], [0, 1, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 0, -8], [1, 0, -8]],
+    [[2, 0, 4], [1, 0, 8], [0, 0, 8]],
+    [[0, 0, 8], [1, 0, -8], [2, 0, 4]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/extrusions/extrudeWalls.js

@@ -64,11 +64,11 @@ const extrudeWalls = (slice0, slice1) => {
   edges0.forEach((edge0, i) => {
     const edge1 = edges1[i]
 
-    const poly0 = poly3.fromPoints([edge0[0], edge0[1], edge1[1]])
+    const poly0 = poly3.create([edge0[0], edge0[1], edge1[1]])
     const poly0area = poly3.measureArea(poly0)
     if (Number.isFinite(poly0area) && poly0area > EPSAREA) walls.push(poly0)
 
-    const poly1 = poly3.fromPoints([edge0[0], edge1[1], edge1[0]])
+    const poly1 = poly3.create([edge0[0], edge1[1], edge1[0]])
     const poly1area = poly3.measureArea(poly1)
     if (Number.isFinite(poly1area) && poly1area > EPSAREA) walls.push(poly1)
   })

package/src/operations/extrusions/project.js

@@ -11,7 +11,6 @@ const poly3 = require('../../geometries/poly3')
 const measureEpsilon = require('../../measurements/measureEpsilon')
 
 const unionGeom2 = require('../booleans/unionGeom2')
-const unionGeom3 = require('../booleans/unionGeom3')
 
 const projectGeom3 = (options, geometry) => {
   // create a plane from the options, and verify
@@ -27,32 +26,30 @@ const projectGeom3 = (options, geometry) => {
 
   // project the polygons to the plane
   const polygons = geom3.toPolygons(geometry)
-  const projpolys = []
+  let projpolys = []
   for (let i = 0; i < polygons.length; i++) {
     const newpoints = polygons[i].vertices.map((v) => plane.projectionOfPoint(projplane, v))
     const newpoly = poly3.create(newpoints)
-    // only keep projections that have a measurable area
-    if (poly3.measureArea(newpoly) < epsilonArea) continue
     // only keep projections that face the same direction as the plane
     const newplane = poly3.plane(newpoly)
     if (!aboutEqualNormals(projplane, newplane)) continue
+    // only keep projections that have a measurable area
+    if (poly3.measureArea(newpoly) < epsilonArea) continue
     projpolys.push(newpoly)
   }
-  // union the projected polygons to eliminate overlaying polygons
-  let projection = geom3.create(projpolys)
-  projection = unionGeom3(projection, projection)
-  // rotate the projection to lay on X/Y axes if necessary
+
+  // rotate the polygons to lay on X/Y axes if necessary
   if (!aboutEqualNormals(projplane, [0, 0, 1])) {
     const rotation = mat4.fromVectorRotation(mat4.create(), projplane, [0, 0, 1])
-    projection = geom3.transform(rotation, projection)
+    projpolys = projpolys.map((p) => poly3.transform(rotation, p))
   }
 
-  // convert the projection (polygons) into a series of 2D geometry
-  const projections2D = geom3.toPolygons(projection).map((p) => geom2.fromPoints(poly3.toPoints(p)))
-  // union the 2D geometries to obtain the outline of the projection
-  projection = unionGeom2(projections2D)
+  // sort the polygons to allow the union to ignore small pieces efficiently
+  projpolys = projpolys.sort((a, b) => poly3.measureArea(b) - poly3.measureArea(a))
 
-  return projection
+  // convert polygons to geometry, and union all pieces into a single geometry
+  const projgeoms = projpolys.map((p) => geom2.fromPoints(p.vertices))
+  return unionGeom2(projgeoms)
 }
 
 /**

package/src/operations/extrusions/project.test.js

@@ -26,14 +26,14 @@ test('project (defaults)', (t) => {
   t.notThrows(() => geom2.validate(result))
   const pts = geom2.toPoints(result)
   const exp = [
-    [0, -2.9999933333333333],
     [0, -5.000013333333333],
-    [0, 5.000013333333333],
     [5.000013333333333, 0],
+    [-5.000013333333333, 0],
     [0, 2.9999933333333333],
     [-2.9999933333333333, 0],
+    [0, -2.9999933333333333],
     [2.9999933333333333, 0],
-    [-5.000013333333333, 0]
+    [0, 5.000013333333333]
   ]
   t.true(comparePoints(pts, exp))
 })
@@ -43,40 +43,40 @@ test('project (X and Y axis)', (t) => {
   t.notThrows(() => geom2.validate(result))
   let pts = geom2.toPoints(result)
   let exp = [
-    [-1.0000200000000001, -3.999986666666667],
-    [-0.8314600000000001, 4.555553333333334],
-    [-0.9807933333333334, -4.1951],
-    [-0.7070933333333335, 4.707126666666667],
-    [-0.9238600000000001, -4.382700000000001],
-    [-0.5555666666666668, 4.831446666666667],
-    [-0.8314600000000001, -4.555553333333334],
-    [-0.3826666666666667, 4.923893333333334],
-    [-0.7070933333333335, -4.707126666666667],
-    [-0.19511333333333336, 4.98078],
-    [-0.5555666666666668, -4.831446666666667],
-    [0, 5.000006666666668],
-    [-0.3826666666666667, -4.923893333333334],
-    [0.19511333333333336, 4.98078],
     [-0.19511333333333336, -4.98078],
-    [0.3826666666666667, 4.923893333333334],
     [0, -5.000006666666668],
-    [0.5555666666666668, 4.831446666666667],
+    [0, 5.000006666666668],
+    [0.3826666666666667, 4.923893333333334],
+    [-0.3826666666666667, -4.923893333333334],
     [0.19511333333333336, -4.98078],
-    [0.7070933333333335, 4.707126666666667],
+    [-0.19511333333333336, 4.98078],
+    [-0.5555666666666668, -4.831446666666667],
+    [0.5555666666666668, 4.831446666666667],
+    [-0.3826666666666667, 4.923893333333334],
     [0.3826666666666667, -4.923893333333334],
-    [0.8314600000000001, 4.555553333333334],
+    [0.7070933333333335, 4.707126666666667],
+    [-0.7070933333333335, -4.707126666666667],
     [0.5555666666666668, -4.831446666666667],
-    [0.9238600000000001, 4.382700000000001],
+    [-0.5555666666666668, 4.831446666666667],
+    [0.8314600000000001, 4.555553333333334],
+    [-0.8314600000000001, -4.555553333333334],
     [0.7070933333333335, -4.707126666666667],
-    [0.9807933333333334, 4.1951],
+    [-0.7070933333333335, 4.707126666666667],
+    [-0.9238600000000001, -4.382700000000001],
+    [0.9238600000000001, 4.382700000000001],
+    [-0.8314600000000001, 4.555553333333334],
     [0.8314600000000001, -4.555553333333334],
+    [0.9807933333333334, 4.1951],
+    [-0.9807933333333334, -4.1951],
+    [0.9238600000000001, -4.382700000000001],
+    [-0.9238600000000001, 4.382700000000001],
     [1.0000200000000001, 3.999986666666667],
+    [-1.0000200000000001, -3.999986666666667],
     [1.0000200000000001, -3.999986666666667],
-    [0.9238600000000001, -4.382700000000001],
-    [0.9807933333333334, -4.1951],
     [-1.0000200000000001, 3.999986666666667],
     [-0.9807933333333334, 4.1951],
-    [-0.9238600000000001, 4.382700000000001]
+    [0.9807933333333334, -4.1951],
+    [0.19511333333333336, 4.98078]
   ]
   t.true(comparePoints(pts, exp))
 
@@ -84,40 +84,40 @@ test('project (X and Y axis)', (t) => {
   t.notThrows(() => geom2.validate(result))
   pts = geom2.toPoints(result)
   exp = [
-    [3.999986666666667, -1.0000200000000001],
-    [-4.555553333333334, -0.8314600000000001],
-    [4.1951, -0.9807933333333334],
-    [-4.707126666666667, -0.7070933333333335],
-    [4.382700000000001, -0.9238600000000001],
-    [-4.831446666666667, -0.5555666666666668],
-    [4.555553333333334, -0.8314600000000001],
-    [-4.923893333333334, -0.3826666666666667],
-    [4.707126666666667, -0.7070933333333335],
-    [-4.98078, -0.19511333333333336],
-    [4.831446666666667, -0.5555666666666668],
-    [-5.000006666666668, 0],
-    [4.923893333333334, -0.3826666666666667],
-    [-4.98078, 0.19511333333333336],
     [4.98078, -0.19511333333333336],
-    [-4.923893333333334, 0.3826666666666667],
     [5.000006666666668, 0],
-    [-4.831446666666667, 0.5555666666666668],
+    [-5.000006666666668, 0],
+    [-4.923893333333334, 0.3826666666666667],
+    [4.923893333333334, -0.3826666666666667],
     [4.98078, 0.19511333333333336],
-    [-4.707126666666667, 0.7070933333333335],
+    [-4.98078, -0.19511333333333336],
+    [4.831446666666667, -0.5555666666666668],
+    [-4.831446666666667, 0.5555666666666668],
+    [-4.923893333333334, -0.3826666666666667],
     [4.923893333333334, 0.3826666666666667],
-    [-4.555553333333334, 0.8314600000000001],
+    [-4.707126666666667, 0.7070933333333335],
+    [4.707126666666667, -0.7070933333333335],
     [4.831446666666667, 0.5555666666666668],
-    [-4.382700000000001, 0.9238600000000001],
+    [-4.831446666666667, -0.5555666666666668],
+    [4.555553333333334, -0.8314600000000001],
+    [-4.555553333333334, 0.8314600000000001],
     [4.707126666666667, 0.7070933333333335],
-    [-4.1951, 0.9807933333333334],
+    [-4.707126666666667, -0.7070933333333335],
+    [4.382700000000001, -0.9238600000000001],
+    [-4.382700000000001, 0.9238600000000001],
+    [-4.555553333333334, -0.8314600000000001],
     [4.555553333333334, 0.8314600000000001],
+    [-4.1951, 0.9807933333333334],
+    [4.1951, -0.9807933333333334],
+    [4.382700000000001, 0.9238600000000001],
+    [-4.382700000000001, -0.9238600000000001],
+    [3.999986666666667, -1.0000200000000001],
     [-3.999986666666667, 1.0000200000000001],
     [3.999986666666667, 1.0000200000000001],
-    [4.382700000000001, 0.9238600000000001],
-    [4.1951, 0.9807933333333334],
     [-3.999986666666667, -1.0000200000000001],
+    [4.1951, 0.9807933333333334],
     [-4.1951, -0.9807933333333334],
-    [-4.382700000000001, -0.9238600000000001]
+    [-4.98078, 0.19511333333333336]
   ]
   t.true(comparePoints(pts, exp))
 })

package/src/operations/extrusions/slice/repair.js

@@ -0,0 +1,62 @@
+const vec3 = require('../../../maths/vec3')
+const create = require('./create')
+
+/*
+ * Mend gaps in a 2D slice to make it a closed polygon
+ */
+const repair = (slice) => {
+  if (!slice.edges) return slice
+  let edges = slice.edges
+  const vertexMap = new Map() // string key to vertex map
+  const edgeCount = new Map() // count of (in - out) edges
+
+  // Remove self-edges
+  edges = edges.filter((e) => !vec3.equals(e[0], e[1]))
+
+  // build vertex and edge count maps
+  edges.forEach((edge) => {
+    const inKey = edge[0].toString()
+    const outKey = edge[1].toString()
+    vertexMap.set(inKey, edge[0])
+    vertexMap.set(outKey, edge[1])
+    edgeCount.set(inKey, (edgeCount.get(inKey) || 0) + 1) // in
+    edgeCount.set(outKey, (edgeCount.get(outKey) || 0) - 1) // out
+  })
+
+  // find vertices which are missing in or out edges
+  const missingIn = []
+  const missingOut = []
+  edgeCount.forEach((count, vertex) => {
+    if (count < 0) missingIn.push(vertex)
+    if (count > 0) missingOut.push(vertex)
+  })
+
+  // pairwise distance of bad vertices
+  missingIn.forEach((key1) => {
+    const v1 = vertexMap.get(key1)
+
+    // find the closest vertex that is missing an out edge
+    let bestDistance = Infinity
+    let bestReplacement
+    missingOut.forEach((key2) => {
+      const v2 = vertexMap.get(key2)
+      const distance = vec3.distance(v1, v2)
+      if (distance < bestDistance) {
+        bestDistance = distance
+        bestReplacement = v2
+      }
+    })
+    console.warn(`slice.repair: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
+
+    // merge broken vertices
+    edges = edges.map((edge) => {
+      if (edge[0].toString() === key1) return [bestReplacement, edge[1]]
+      if (edge[1].toString() === key1) return [edge[0], bestReplacement]
+      return edge
+    })
+  })
+
+  return create(edges)
+}
+
+module.exports = repair

package/src/operations/hulls/hullChain.test.js

@@ -12,14 +12,14 @@ test('hullChain (two, geom2)', (t) => {
   let obs = hullChain(geometry1, geometry1)
   let pts = geom2.toPoints(obs)
 
-    t.notThrows(() => geom2.validate(obs))
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // different
   obs = hullChain(geometry1, geometry2)
   pts = geom2.toPoints(obs)
 
-    t.notThrows(() => geom2.validate(obs))
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 6)
 })
 
@@ -33,7 +33,7 @@ test('hullChain (three, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   // the sides change based on the bestplane chosen in trees/Node.js
-    t.notThrows(() => geom2.validate(obs))
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 10)
 
   // closed
@@ -41,7 +41,7 @@ test('hullChain (three, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   // the sides change based on the bestplane chosen in trees/Node.js
-    t.notThrows(() => geom2.validate(obs))
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 10)
 })
 

package/src/operations/hulls/hullGeom2.js

@@ -3,6 +3,7 @@ const flatten = require('../../utils/flatten')
 const geom2 = require('../../geometries/geom2')
 
 const hullPoints2 = require('./hullPoints2')
+const toUniquePoints = require('./toUniquePoints')
 
 /*
  * Create a convex hull of the given geom2 geometries.
@@ -13,28 +14,15 @@ const hullGeom2 = (...geometries) => {
   geometries = flatten(geometries)
 
   // extract the unique points from the geometries
-  const uniquepoints = []
-  const found = new Map()
-  for (let g = 0; g < geometries.length; g++) {
-    const sides = geom2.toSides(geometries[g])
-    for (let s = 0; s < sides.length; s++) {
-      const side = sides[s]
-      const point = side[0]
-      const id = `${point[0]},${point[1]}`
-      if (found.has(id)) continue
-      uniquepoints.push(point)
-      found.set(id, true)
-    }
-  }
-  found.clear()
-
-  const hullpoints = hullPoints2(uniquepoints)
+  const unique = toUniquePoints(geometries)
+
+  const hullPoints = hullPoints2(unique)
 
   // NOTE: more than three points are required to create a new geometry
-  if (hullpoints.length < 3) return geom2.create()
+  if (hullPoints.length < 3) return geom2.create()
 
   // assemble a new geometry from the list of points
-  return geom2.fromPoints(hullpoints)
+  return geom2.fromPoints(hullPoints)
 }
 
 module.exports = hullGeom2

package/src/operations/hulls/hullGeom3.js

@@ -4,6 +4,7 @@ const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
 const quickhull = require('./quickhull')
+const toUniquePoints = require('./toUniquePoints')
 
 /*
  * Create a convex hull of the given geometries (geom3).
@@ -16,26 +17,12 @@ const hullGeom3 = (...geometries) => {
   if (geometries.length === 1) return geometries[0]
 
   // extract the unique vertices from the geometries
-  const uniquevertices = []
-  const found = new Map()
-  for (let g = 0; g < geometries.length; ++g) {
-    const polygons = geom3.toPolygons(geometries[g])
-    for (let p = 0; p < polygons.length; ++p) {
-      const vertices = polygons[p].vertices
-      for (let v = 0; v < vertices.length; ++v) {
-        const id = `${vertices[v]}`
-        if (found.has(id)) continue
-        uniquevertices.push(vertices[v])
-        found.set(id, true)
-      }
-    }
-  }
-  found.clear()
-
-  const faces = quickhull(uniquevertices, { skipTriangulation: true })
+  const unique = toUniquePoints(geometries)
+
+  const faces = quickhull(unique, { skipTriangulation: true })
 
   const polygons = faces.map((face) => {
-    const vertices = face.map((index) => uniquevertices[index])
+    const vertices = face.map((index) => unique[index])
     return poly3.create(vertices)
   })
 

package/src/operations/hulls/hullPath2.js

@@ -3,6 +3,7 @@ const flatten = require('../../utils/flatten')
 const path2 = require('../../geometries/path2')
 
 const hullPoints2 = require('./hullPoints2')
+const toUniquePoints = require('./toUniquePoints')
 
 /*
  * Create a convex hull of the given geometries (path2).
@@ -13,23 +14,12 @@ const hullPath2 = (...geometries) => {
   geometries = flatten(geometries)
 
   // extract the unique points from the geometries
-  const uniquepoints = []
-  const found = new Set()
-  geometries.forEach((geometry) => {
-    const points = path2.toPoints(geometry)
-    points.forEach((point) => {
-      const key = point.toString()
-      if (!found.has(key)) {
-        uniquepoints.push(point)
-        found.add(key)
-      }
-    })
-  })
+  const unique = toUniquePoints(geometries)
 
-  const hullpoints = hullPoints2(uniquepoints)
+  const hullPoints = hullPoints2(unique)
 
   // assemble a new geometry from the list of points
-  return path2.fromPoints({ closed: true }, hullpoints)
+  return path2.fromPoints({ closed: true }, hullPoints)
 }
 
 module.exports = hullPath2