@jscad/modeling 2.7.0 → 2.8.0

package/src/operations/booleans/unionGeom3Sub.js

@@ -7,7 +7,7 @@ const { Tree } = require('./trees')
  * Return a new 3D geometry representing the space in the given geometries.
  * @param {geom3} geometry1 - geometry to union
  * @param {geom3} geometry2 - geometry to union
- * @returns {goem3} new 3D geometry
+ * @returns {geom3} new 3D geometry
  */
 const unionSub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {

package/src/operations/expansions/expand.js

@@ -10,12 +10,14 @@ const expandPath2 = require('./expandPath2')
 
 /**
  * Expand the given geometry using the given options.
+ * Both internal and external space is expanded for 2D and 3D shapes.
+ *
  * Note: Contract is expand using a negative delta.
  * @param {Object} options - options for expand
  * @param {Number} [options.delta=1] - delta (+/-) of expansion
  * @param {String} [options.corners='edge'] - type of corner to create after expanding; edge, chamfer, round
  * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {...Objects} geometry - the list of geometry to expand
+ * @param {...Objects} objects - the geometries to expand
  * @return {Object|Array} new geometry, or list of new geometries
  * @alias module:modeling/expansions.expand
  *

package/src/operations/expansions/expand.test.js

@@ -120,7 +120,7 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = expand({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
-  t.is(pts2.length, 2065)
+  t.is(pts2.length, 1612)
 })
 
 test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
@@ -151,59 +151,27 @@ test('expand (options): offsetting of a complex geom2 produces expected offset g
   const obs = expand({ delta: 2, corners: 'edge' }, geometry)
   const pts = geom2.toPoints(obs)
   const exp = [
-    [-77, -77],
-    [-75, -77],
-    [75, -77],
     [77, -77],
-    [77, -75],
-    [77, 75],
     [77, 77],
-    [75, 77],
-    [40, 77],
     [38, 77],
-    [38, 75],
     [38, 2],
     [-38, 2],
-    [-38, 75],
     [-37.99999999999999, 77],
-    [-40, 77],
-    [-75, 77],
     [-77, 77],
-    [-77, 75],
-    [17, -40],
     [16.999999999999996, -42],
-    [15, -42],
-    [8, -42],
     [6, -42],
-    [6, -40],
     [6, -27],
     [-6, -27],
-    [-6, -40],
     [-6.000000000000001, -42],
-    [-8, -42],
-    [-15, -42],
     [-17, -42],
-    [-17, -40],
-    [-17, -10],
     [-16.999999999999996, -8],
-    [-15, -8],
-    [15, -8],
     [17, -8.000000000000004],
-    [17, -10],
-    [-4, -19],
     [-4, -21],
-    [-2, -21],
-    [1.9999999999999998, -21],
     [3.9999999999999996, -21],
-    [4, -19],
-    [4, -15],
     [4, -13],
-    [2, -13],
-    [-1.9999999999999998, -13],
     [-4, -13],
-    [-4, -15],
-    [-77, -75]
+    [-77, -77]
   ]
-  t.is(pts.length, 52)
+  t.is(pts.length, 20)
   t.true(comparePoints(pts, exp))
 })

package/src/operations/expansions/expandShell.js

@@ -15,37 +15,43 @@ const unionGeom3Sub = require('../booleans/unionGeom3Sub')
 
 const extrudePolygon = require('./extrudePolygon')
 
+/**
+ * Collect all planes adjacent to each vertex
+ */
 const mapPlaneToVertex = (map, vertex, plane) => {
-  const i = map.findIndex((item) => vec3.equals(item[0], vertex))
-  if (i < 0) {
+  const key = vertex.toString()
+  if (!map.has(key)) {
     const entry = [vertex, [plane]]
-    map.push(entry)
-    return map.length
+    map.set(key, entry)
+  } else {
+    const planes = map.get(key)[1]
+    planes.push(plane)
   }
-  const planes = map[i][1]
-  planes.push(plane)
-  return i
 }
 
+/**
+ * Collect all planes adjacent to each edge.
+ * Combine undirected edges, no need for duplicate cylinders.
+ */
 const mapPlaneToEdge = (map, edge, plane) => {
-  const i = map.findIndex((item) => (vec3.equals(item[0], edge[0]) && vec3.equals(item[1], edge[1])) || (vec3.equals(item[0], edge[1]) && vec3.equals(item[1], edge[0])))
-  if (i < 0) {
+  const key0 = edge[0].toString()
+  const key1 = edge[1].toString()
+  // Sort keys to make edges undirected
+  const key = key0 < key1 ? `${key0},${key1}` : `${key1},${key0}`
+  if (!map.has(key)) {
     const entry = [edge, [plane]]
-    map.push(entry)
-    return map.length
+    map.set(key, entry)
+  } else {
+    const planes = map.get(key)[1]
+    planes.push(plane)
   }
-  const planes = map[i][1]
-  planes.push(plane)
-  return i
 }
 
 const addUniqueAngle = (map, angle) => {
   const i = map.findIndex((item) => item === angle)
   if (i < 0) {
     map.push(angle)
-    return map.length
   }
-  return i
 }
 
 /*
@@ -65,8 +71,8 @@ const expandShell = (options, geometry) => {
   const { delta, segments } = Object.assign({ }, defaults, options)
 
   let result = geom3.create()
-  const vertices2planes = [] // contents: [vertex, [plane, ...]]
-  const edges2planes = [] // contents: [[vertex, vertex], [plane, ...]]
+  const vertices2planes = new Map() // {vertex: [vertex, [plane, ...]]}
+  const edges2planes = new Map() // {edge: [[vertex, vertex], [plane, ...]]}
 
   const v1 = vec3.create()
   const v2 = vec3.create()

package/src/operations/expansions/offset.js

@@ -8,11 +8,12 @@ const offsetPath2 = require('./offsetPath2')
 
 /**
  * Create offset geometry from the given geometry using the given options.
+ * Offsets from internal and external space are created.
  * @param {Object} options - options for offset
  * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
  * @param {String} [options.corners='edge'] - type of corner to create after offseting; edge, chamfer, round
  * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {...Object} geometry - the list of geometry to offset
+ * @param {...Object} objects - the geometries to offset
  * @return {Object|Array} new geometry, or list of new geometries
  * @alias module:modeling/expansions.offset
  *

package/src/operations/expansions/offset.test.js

@@ -46,7 +46,7 @@ test('offset: offsetting a bent line produces expected geometry', (t) => {
   // offset it by -2.
   offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
-  t.is(offsetPoints.length, 7)
+  t.is(offsetPoints.length, 5)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [10, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
 })
@@ -124,20 +124,12 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
   let pts = path2.toPoints(obs)
   let exp = [
     [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
     [-5, 6]
   ]
   t.true(comparePoints(pts, exp))
@@ -145,26 +137,14 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
   obs = offset({ delta: 1, corners: 'edge' }, closeline)
   pts = path2.toPoints(obs)
   exp = [
-    [-6, -6],
-    [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
-    [-5, 6],
     [-6, 6],
-    [-6, 5],
-    [-6, -5]
+    [-6, -6]
   ]
   t.true(comparePoints(pts, exp))
 
@@ -175,12 +155,8 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [4.5, -4.5],
     [4.5, 4.5],
     [3.5, 4.5],
-    [3.5, -3.061616997868383e-17],
     [3.4999999999999996, -0.5],
-    [3, -0.5],
-    [-3, -0.5],
     [-3.5, -0.4999999999999996],
-    [-3.5, 3.061616997868383e-17],
     [-3.5, 4.5],
     [-5, 4.5]
   ]
@@ -193,12 +169,8 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [4.5, -4.5],
     [4.5, 4.5],
     [3.5, 4.5],
-    [3.5, -3.061616997868383e-17],
     [3.4999999999999996, -0.5],
-    [3, -0.5],
-    [-3, -0.5],
     [-3.5, -0.4999999999999996],
-    [-3.5, 3.061616997868383e-17],
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
@@ -373,26 +345,14 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
   obs = offset({ delta: 1, corners: 'edge' }, geometry)
   pts = geom2.toPoints(obs)
   exp = [
-    [-6, -6],
-    [-5, -6],
-    [5, -6],
     [6, -6],
-    [6, -5],
-    [6, 5],
     [6, 6],
-    [5, 6],
-    [3, 6],
     [2, 6],
-    [2, 5],
     [2, 1],
     [-2, 1],
-    [-2, 5],
     [-1.9999999999999996, 6],
-    [-3, 6],
-    [-5, 6],
     [-6, 6],
-    [-6, 5],
-    [-6, -5]
+    [-6, -6]
   ]
   t.true(comparePoints(pts, exp))
 
@@ -422,78 +382,54 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
 
 test('offset (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
   const geometry = geom2.create([
-    [[-75.00000, 75.00000], [-75.00000, -75.00000]],
-    [[-75.00000, -75.00000], [75.00000, -75.00000]],
-    [[75.00000, -75.00000], [75.00000, 75.00000]],
-    [[-40.00000, 75.00000], [-75.00000, 75.00000]],
-    [[75.00000, 75.00000], [40.00000, 75.00000]],
-    [[40.00000, 75.00000], [40.00000, 0.00000]],
-    [[40.00000, 0.00000], [-40.00000, 0.00000]],
-    [[-40.00000, 0.00000], [-40.00000, 75.00000]],
-    [[15.00000, -10.00000], [15.00000, -40.00000]],
-    [[-15.00000, -10.00000], [15.00000, -10.00000]],
-    [[-15.00000, -40.00000], [-15.00000, -10.00000]],
-    [[-8.00000, -40.00000], [-15.00000, -40.00000]],
-    [[15.00000, -40.00000], [8.00000, -40.00000]],
-    [[-8.00000, -25.00000], [-8.00000, -40.00000]],
-    [[8.00000, -25.00000], [-8.00000, -25.00000]],
-    [[8.00000, -40.00000], [8.00000, -25.00000]],
-    [[-2.00000, -15.00000], [-2.00000, -19.00000]],
-    [[-2.00000, -19.00000], [2.00000, -19.00000]],
-    [[2.00000, -19.00000], [2.00000, -15.00000]],
-    [[2.00000, -15.00000], [-2.00000, -15.00000]]
+    [[-75, 75], [-75, -75]],
+    [[-75, -75], [75, -75]],
+    [[75, -75], [75, 75]],
+    [[-40, 75], [-75, 75]],
+    [[75, 75], [40, 75]],
+    [[40, 75], [40, 0]],
+    [[40, 0], [-40, 0]],
+    [[-40, 0], [-40, 75]],
+    [[15, -10], [15, -40]],
+    [[-15, -10], [15, -10]],
+    [[-15, -40], [-15, -10]],
+    [[-8, -40], [-15, -40]],
+    [[15, -40], [8, -40]],
+    [[-8, -25], [-8, -40]],
+    [[8, -25], [-8, -25]],
+    [[8, -40], [8, -25]],
+    [[-2, -15], [-2, -19]],
+    [[-2, -19], [2, -19]],
+    [[2, -19], [2, -15]],
+    [[2, -15], [-2, -15]]
   ])
 
   // expand +
   const obs = offset({ delta: 2, corners: 'edge' }, geometry)
   const pts = geom2.toPoints(obs)
   const exp = [
-    [-77, -77],
-    [-75, -77],
-    [75, -77],
     [77, -77],
-    [77, -75],
-    [77, 75],
     [77, 77],
-    [75, 77],
-    [40, 77],
     [38, 77],
-    [38, 75],
     [38, 2],
     [-38, 2],
-    [-38, 75],
     [-37.99999999999999, 77],
-    [-40, 77],
-    [-75, 77],
     [-77, 77],
-    [-77, 75],
     [13, -12],
     [13, -38],
     [10, -38],
-    [10, -25],
     [10, -23],
-    [8, -23],
-    [-8, -23],
     [-10, -23],
-    [-10, -25],
     [-10, -38],
     [-13, -38],
     [-13, -12],
-    [-4, -19],
     [-4, -21],
-    [-2, -21],
-    [1.9999999999999998, -21],
     [3.9999999999999996, -21],
-    [4, -19],
-    [4, -15],
     [4, -13],
-    [2, -13],
-    [-1.9999999999999998, -13],
     [-4, -13],
-    [-4, -15],
-    [-77, -75]
+    [-77, -77]
   ]
-  t.is(pts.length, 44)
+  t.is(pts.length, 20)
   t.true(comparePoints(pts, exp))
 })
 

package/src/operations/expansions/offsetFromPoints.js

@@ -34,7 +34,7 @@ const offsetFromPoints = (options, points) => {
   delta = Math.abs(delta) // sign is no longer required
 
   let previousSegment = null
-  const newPoints = []
+  let newPoints = []
   const newCorners = []
   const of = vec2.create()
   const n = points.length
@@ -94,6 +94,10 @@ const offsetFromPoints = (options, points) => {
   // generate corners if necessary
 
   if (corners === 'edge') {
+    // map for fast point index lookup
+    const pointIndex = new Map() // {point: index}
+    newPoints.forEach((point, index) => pointIndex.set(point, index))
+
     // create edge corners
     const line0 = line2.create()
     const line1 = line2.create()
@@ -103,16 +107,17 @@ const offsetFromPoints = (options, points) => {
       const ip = line2.intersectPointOfLines(line0, line1)
       if (Number.isFinite(ip[0]) && Number.isFinite(ip[1])) {
         const p0 = corner.s0[1]
-        let i = newPoints.findIndex((point) => vec2.equals(p0, point))
-        i = (i + 1) % newPoints.length
-        newPoints.splice(i, 0, ip)
+        const i = pointIndex.get(p0)
+        newPoints[i] = ip
+        newPoints[(i + 1) % newPoints.length] = undefined
       } else {
         // paralell segments, drop one
         const p0 = corner.s1[0]
-        const i = newPoints.findIndex((point) => vec2.equals(p0, point))
-        newPoints.splice(i, 1)
+        const i = pointIndex.get(p0)
+        newPoints[i] = undefined
       }
     })
+    newPoints = newPoints.filter((p) => p !== undefined)
   }
 
   if (corners === 'round') {

package/src/operations/extrusions/extrudeLinear.js

@@ -1,16 +1,20 @@
 const flatten = require('../../utils/flatten')
 
 const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
 
 const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
+const extrudeLinearPath2 = require('./extrudeLinearPath2')
 
 /**
  * Extrude the given geometry in an upward linear direction using the given options.
+ * Accepts path2 or geom2 objects as input. Paths must be closed.
+ *
  * @param {Object} options - options for extrude
- * @param {Array} [options.height=1] the height of the extrusion
+ * @param {Number} [options.height=1] the height of the extrusion
  * @param {Number} [options.twistAngle=0] the final rotation (RADIANS) about the origin of the shape (if any)
  * @param {Integer} [options.twistSteps=1] the resolution of the twist about the axis (if any)
- * @param {...Object} geometry - the list of geometry to extrude
+ * @param {...Object} objects - the geometries to extrude
  * @return {Object|Array} the extruded geometry, or a list of extruded geometry
  * @alias module:modeling/extrusions.extrudeLinear
  *
@@ -31,7 +35,7 @@ const extrudeLinear = (options, ...objects) => {
   options = { offset: [0, 0, height], twistAngle: twistAngle, twistSteps: twistSteps }
 
   const results = objects.map((object) => {
-    // if (path.isA(object)) return pathextrude(options, object)
+    if (path2.isA(object)) return extrudeLinearPath2(options, object)
     if (geom2.isA(object)) return extrudeLinearGeom2(options, object)
     // if (geom3.isA(object)) return geom3.extrude(options, object)
     return object

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

@@ -2,7 +2,7 @@ const test = require('ava')
 
 const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom2, geom3, path2 } = require('../../geometries')
 
 const { extrudeLinear } = require('./index')
 
@@ -166,3 +166,27 @@ test('extrudeLinear (holes)', (t) => {
   t.is(pts.length, 24)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('extrudeLinear (path2)', (t) => {
+  const geometry2 = path2.fromPoints({ closed: true }, [[0, 0], [12, 0], [6, 10]])
+  const geometry3 = extrudeLinear({ height: 15 }, geometry2)
+  t.true(geom3.isA(geometry3))
+  const pts = geom3.toPoints(geometry3)
+  const exp = [
+    [[6, 10, 0], [0, 0, 0], [0, 0, 15]],
+    [[6, 10, 0], [0, 0, 15], [6, 10, 15]],
+    [[0, 0, 0], [12, 0, 0], [12, 0, 15]],
+    [[0, 0, 0], [12, 0, 15], [0, 0, 15]],
+    [[12, 0, 0], [6, 10, 0], [6, 10, 15]],
+    [[12, 0, 0], [6, 10, 15], [12, 0, 15]],
+    [[0, 0, 15], [11.999999999999998, 0, 15], [6, 10, 15]],
+    [[6.000000000000001, 10, 0], [12, 0, 0], [8.881784197001252e-16, 0, 0]]
+  ]
+  t.is(pts.length, 8)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('extrudeLinear (unclosed path throws error)', (t) => {
+  const geometry2 = path2.fromPoints({ closed: false }, [[0, 0], [12, 0], [6, 10]])
+  t.throws(() => extrudeLinear({}, geometry2))
+})

package/src/operations/extrusions/extrudeLinearPath2.js

@@ -0,0 +1,24 @@
+const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
+
+const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
+
+/*
+ * Extrude the given geometry using the given options.
+ *
+ * @param {Object} [options] - options for extrude
+ * @param {Array} [options.offset] - the direction of the extrusion as a 3D vector
+ * @param {Number} [options.twistAngle] - the final rotation (RADIANS) about the origin
+ * @param {Integer} [options.twistSteps] - the number of steps created to produce the twist (if any)
+ * @param {path2} geometry - the geometry to extrude
+ * @returns {geom3} the extruded 3D geometry
+*/
+const extrudePath2 = (options, geometry) => {
+  if (!geometry.isClosed) throw new Error('extruded path must be closed')
+  // Convert path2 to geom2
+  const points = path2.toPoints(geometry)
+  const geometry2 = geom2.fromPoints(points)
+  return extrudeLinearGeom2(options, geometry2)
+}
+
+module.exports = extrudePath2

package/src/operations/extrusions/extrudeRectangular.js

@@ -12,12 +12,13 @@ const extrudeRectangularGeom2 = require('./extrudeRectangularGeom2')
  * @param {Object} options - options for extrusion, if any
  * @param {Number} [options.size=1] - size of the rectangle
  * @param {Number} [options.height=1] - height of the extrusion
- * @param {...Object} geometry - the list of geometry to extrude
+ * @param {...Object} objects - the geometries to extrude
  * @return {Object|Array} the extruded object, or a list of extruded objects
  * @alias module:modeling/extrusions.extrudeRectangular
  *
  * @example
- * let mywalls = extrudeRectangular({offset: [0,0,10]}, square())
+ * let mywalls = extrudeRectangular({size: 1, height: 3}, square({size: 20}))
+ * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: Math.PI}, square({size: 20}))
  */
 const extrudeRectangular = (options, ...objects) => {
   const defaults = {

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

@@ -12,11 +12,11 @@ test('extrudeRectangular (defaults)', (t) => {
 
   let obs = extrudeRectangular({ }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 50)
+  t.is(pts.length, 34)
 
   obs = extrudeRectangular({ }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 40)
+  t.is(pts.length, 24)
 })
 
 test('extrudeRectangular (chamfer)', (t) => {

package/src/operations/extrusions/project.js

@@ -60,7 +60,7 @@ const projectGeom3 = (options, geometry) => {
  * @param {Object} options - options for project
  * @param {Array} [options.axis=[0,0,1]] the axis of the plane (default is Z axis)
  * @param {Array} [options.origin=[0,0,0]] the origin of the plane
- * @param {...Object} geometry - the list of 3D geometry to project
+ * @param {...Object} objects - the list of 3D geometry to project
  * @return {geom2|Array} the projected 2D geometry, or a list of 2D projected geometry
  * @alias module:modeling/extrusions.project
  *

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

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a slice.
- * @param {slice} object - the object to interogate
+ * Determine if the given object is a slice.
+ * @param {slice} object - the object to interrogate
  * @returns {Boolean} true if the object matches a slice
  * @alias module:modeling/extrusions/slice.isA
  */

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

@@ -60,7 +60,7 @@ const toPolygons = (slice) => {
   const wallPolygons = edges.map((edge) => toPolygon3D(splane, edge))
   const walls = geom3.create(wallPolygons)
 
-  // make an insection of the base and the walls, creating... a set of polygons!
+  // make an intersection of the base and the walls, creating... a set of polygons!
   const geometry3 = intersectGeom3Sub(base, walls)
 
   // return only those polygons from the base

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

@@ -43,7 +43,7 @@ test('hull (single, geom2)', (t) => {
   t.is(pts.length, 7)
 })
 
-test('hull (multiple, overlaping, geom2)', (t) => {
+test('hull (multiple, overlapping, geom2)', (t) => {
   const geometry1 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
   const geometry2 = geom2.fromPoints([[3, 3], [-3, 3], [-3, -3], [3, -3]])
   const geometry3 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])

package/src/operations/hulls/hullChain.js

@@ -5,7 +5,7 @@ const union = require('../booleans/union')
 const hull = require('./hull')
 
 /**
- * Create a chain of hulled geometries from the given gemetries.
+ * Create a chain of hulled geometries from the given geometries.
  * Essentially hull A+B, B+C, C+D, etc., then union the results.
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  *

package/src/operations/hulls/hullGeom2.js

@@ -30,7 +30,7 @@ const hullGeom2 = (...geometries) => {
 
   const hullpoints = hullPoints2(uniquepoints)
 
-  // NOTE: more then three points are required to create a new geometry
+  // NOTE: more than three points are required to create a new geometry
   if (hullpoints.length < 3) return geom2.create()
 
   // assemble a new geometry from the list of points

package/src/operations/hulls/hullPath2.js

@@ -1,7 +1,5 @@
 const flatten = require('../../utils/flatten')
 
-const vec2 = require('../../maths/vec2')
-
 const path2 = require('../../geometries/path2')
 
 const hullPoints2 = require('./hullPoints2')
@@ -16,11 +14,15 @@ const hullPath2 = (...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 index = uniquepoints.findIndex((unique) => vec2.equals(unique, point))
-      if (index < 0) uniquepoints.push(point)
+      const key = point.toString()
+      if (!found.has(key)) {
+        uniquepoints.push(point)
+        found.add(key)
+      }
     })
   })
 

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

@@ -0,0 +1,16 @@
+const test = require('ava')
+
+const { path2 } = require('../../geometries')
+
+const hullPath2 = require('./hullPath2')
+
+test('hullPath2', (t) => {
+  const closed = true
+  const geometry1 = path2.fromPoints({ closed }, [[0, 0], [-4, 4], [-4, -4]])
+  const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
+
+  const obs = hullPath2(geometry1, geometry2)
+  t.true(path2.isA(obs))
+  const pts = path2.toPoints(obs)
+  t.is(pts.length, 4)
+})