@jscad/modeling 2.9.0 → 2.9.3

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

@@ -11,6 +11,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
 
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -34,15 +35,18 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[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]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 28)
 })
 
@@ -57,6 +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(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 
@@ -67,6 +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(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 })
@@ -77,22 +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(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(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.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.is(pts.length, 80)
 })
 
@@ -112,6 +122,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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]]
   ]
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -140,6 +151,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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]]
   ]
+  t.notThrows.skip(() => 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

@@ -16,108 +16,108 @@ test('project (defaults)', (t) => {
 
   const results = project({ }, geometry0, geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 5)
-  t.true(geom2.isA(results[0]))
-  t.true(geom2.isA(results[1]))
+  t.notThrows(() => geom2.validate(results[0]))
+  t.notThrows(() => geom2.validate(results[1]))
   t.is(results[2], geometry2)
   t.is(results[3], geometry3)
   t.is(results[4], geometry4)
 
   const result = project({ }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  t.notThrows(() => geom2.validate(result))
   const pts = geom2.toPoints(result)
   const exp = [
-    [0, -2.9999933333333333],
     [0, -5.000013333333333],
-    [0, 5.000013333333333],
     [5.000013333333333, 0],
-    [0, 2.9999933333333333],
+    [-5.000013333333333, 0],
     [-2.9999933333333333, 0],
     [2.9999933333333333, 0],
-    [-5.000013333333333, 0]
+    [0, 2.9999933333333333],
+    [0, -2.9999933333333333],
+    [0, 5.000013333333333]
   ]
   t.true(comparePoints(pts, exp))
 })
 
 test('project (X and Y axis)', (t) => {
   let result = project({ axis: [1, 0, 0], origin: [1, 0, 0] }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  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))
 
   result = project({ axis: [0, 1, 0], origin: [0, -1, 0] }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  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/hulls/hull.test.js

@@ -16,12 +16,14 @@ test('hull (single, geom2)', (t) => {
   let obs = hull(geometry)
   let pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 0)
 
   geometry = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 4)
 
   // convex C shape
@@ -40,6 +42,7 @@ test('hull (single, geom2)', (t) => {
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 7)
 })
 
@@ -66,23 +69,27 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   let obs = hull(geometry1, geometry1)
   let pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // one inside another
   obs = hull(geometry1, geometry2)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // one overlapping another
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 8)
 
   obs = hull(geometry2, geometry4)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 7)
 })
 
@@ -108,22 +115,27 @@ test('hull (multiple, various, geom2)', (t) => {
 
   let obs = hull(geometry1, geometry2)
   let pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 8)
 })
 
@@ -133,6 +145,7 @@ test('hull (single, path2)', (t) => {
   let obs = hull(geometry)
   let pts = path2.toPoints(obs)
 
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 0)
 
   geometry = path2.fromPoints({}, [[0, 0], [5, 0], [5, 10], [4, 1]])
@@ -140,6 +153,7 @@ test('hull (single, path2)', (t) => {
   obs = hull(geometry)
   pts = path2.toPoints(obs)
 
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 3)
 })
 
@@ -165,22 +179,27 @@ test('hull (multiple, various, path2)', (t) => {
 
   let obs = hull(geometry1, geometry2)
   let pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 8)
 })
 
@@ -190,6 +209,7 @@ test('hull (single, geom3)', (t) => {
   let obs = hull(geometry)
   let pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 0)
 
   geometry = sphere({ radius: 2, segments: 8 })
@@ -197,6 +217,7 @@ test('hull (single, geom3)', (t) => {
   obs = hull(geometry)
   pts = geom3.toPoints(obs)
 
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 32)
 })
 
@@ -214,6 +235,7 @@ test('hull (multiple, geom3)', (t) => {
     [[1, -1, 1], [-1, -1, 1], [-1, -1, -1], [1, -1, -1]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -236,6 +258,7 @@ test('hull (multiple, geom3)', (t) => {
     [[1, 1, -1], [6.5, 6.5, 3.5], [6.5, 3.5, 3.5], [1, -1, -1]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -248,6 +271,6 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const obs = hull(geometry1, geometry2, geometry3)
   const pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 160)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 92)
 })

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

@@ -12,12 +12,14 @@ test('hullChain (two, geom2)', (t) => {
   let obs = hullChain(geometry1, geometry1)
   let pts = geom2.toPoints(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.is(pts.length, 6)
 })
 
@@ -31,16 +33,16 @@ 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.is(pts.length, 10)
-  // t.is(pts.length, 11)
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
   pts = geom2.toPoints(obs)
 
   // the sides change based on the bestplane chosen in trees/Node.js
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 10)
-  // t.is(pts.length, 13)
 })
 
 test('hullChain (three, geom3)', (t) => {
@@ -73,13 +75,13 @@ test('hullChain (three, geom3)', (t) => {
   let obs = hullChain(geometry1, geometry2, geometry3)
   let pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 27)
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 23)
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
   pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 45)
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 28)
 })

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

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

@@ -10,7 +10,7 @@ test('hullPath2', (t) => {
   const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
 
   const obs = hullPath2(geometry1, geometry2)
-  t.true(path2.isA(obs))
+  t.notThrows(() => path2.validate(obs))
   const pts = path2.toPoints(obs)
   t.is(pts.length, 4)
 })