@jscad/modeling 2.7.1 → 2.9.0

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

@@ -16,25 +16,27 @@ test('extrudeFromSlices (defaults)', (t) => {
   let geometry3 = extrudeFromSlices({ }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
-    [[10.0, -10.0, 0.0], [10.0, 10.0, 0.0], [10.0, 10.0, 1.0]],
-    [[10.0, -10.0, 0.0], [10.0, 10.0, 1.0], [10.0, -10.0, 1.0]],
-    [[10.0, 10.0, 0.0], [-10.0, 10.0, 0.0], [-10.0, 10.0, 1.0]],
-    [[10.0, 10.0, 0.0], [-10.0, 10.0, 1.0], [10.0, 10.0, 1.0]],
-    [[-10.0, 10.0, 0.0], [-10.0, -10.0, 0.0], [-10.0, -10.0, 1.0]],
-    [[-10.0, 10.0, 0.0], [-10.0, -10.0, 1.0], [-10.0, 10.0, 1.0]],
-    [[-10.0, -10.0, 0.0], [10.0, -10.0, 0.0], [10.0, -10.0, 1.0]],
-    [[-10.0, -10.0, 0.0], [10.0, -10.0, 1.0], [-10.0, -10.0, 1.0]],
-    [[10, 10, 1], [-10, 10, 1], [-10, -10, 1], [10, -10, 1]],
-    [[10, -10, 0], [-10, -10, 0], [-10, 10, 0], [10, 10, 0]]
+    [[10, -10, 0], [10, 10, 0], [10, 10, 1]],
+    [[10, -10, 0], [10, 10, 1], [10, -10, 1]],
+    [[10, 10, 0], [-10, 10, 0], [-10, 10, 1]],
+    [[10, 10, 0], [-10, 10, 1], [10, 10, 1]],
+    [[-10, 10, 0], [-10, -10, 0], [-10, -10, 1]],
+    [[-10, 10, 0], [-10, -10, 1], [-10, 10, 1]],
+    [[-10, -10, 0], [10, -10, 0], [10, -10, 1]],
+    [[-10, -10, 0], [10, -10, 1], [-10, -10, 1]],
+    [[-10, -10, 1], [10, -10, 1], [10, 10, 1]],
+    [[10, 10, 1], [-10, 10, 1], [-10, -10, 1]],
+    [[10, 10, 0], [10, -10, 0], [-10, -10, 0]],
+    [[-10, -10, 0], [-10, 10, 0], [10, 10, 0]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   const poly2 = poly3.fromPoints([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
   pts = geom3.toPoints(geometry3)
 
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -84,7 +86,7 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 25)
+  t.is(pts.length, 26)
 })
 
 test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
@@ -101,7 +103,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 298)
+  t.is(pts.length, 304)
 })
 
 test('extrudeFromSlices (holes)', (t) => {
@@ -136,15 +138,23 @@ test('extrudeFromSlices (holes)', (t) => {
     [[5, 5, 0], [5, -5, 1], [5, 5, 1]],
     [[-5, 5, 0], [5, 5, 0], [5, 5, 1]],
     [[-5, 5, 0], [5, 5, 1], [-5, 5, 1]],
-    [[-10, -10, 1], [-5, -10, 1], [-5, 10, 1], [-10, 10, 1]],
-    [[10, -10, 1], [10, -5, 1], [-5, -5, 1], [-5, -10, 1]],
-    [[10, 10, 1], [5, 10, 1], [5, -5, 1], [10, -5, 1]],
-    [[5, 5, 1], [5, 10, 1], [-5, 10, 1], [-5, 5, 1]],
-    [[-10, 10, 0], [-5, 10, 0], [-5, -10, 0], [-10, -10, 0]],
-    [[10, -10, 0], [-5, -10, 0], [-5, -5, 0], [10, -5, 0]],
-    [[10, -5, 0], [5, -5, 0], [5, 10, 0], [10, 10, 0]],
-    [[5, 10, 0], [5, 5, 0], [-5, 5, 0], [-5, 10, 0]]
+    [[10, -10, 1], [10, 10, 1], [5, 5, 1]],
+    [[-5, 5, 1], [5, 5, 1], [10, 10, 1]],
+    [[10, -10, 1], [5, 5, 1], [5, -5, 1]],
+    [[-5, 5, 1], [10, 10, 1], [-10, 10, 1]],
+    [[-10, -10, 1], [10, -10, 1], [5, -5, 1]],
+    [[-5, -5, 1], [-5, 5, 1], [-10, 10, 1]],
+    [[-10, -10, 1], [5, -5, 1], [-5, -5, 1]],
+    [[-5, -5, 1], [-10, 10, 1], [-10, -10, 1]],
+    [[5, 5, 0], [10, 10, 0], [10, -10, 0]],
+    [[10, 10, 0], [5, 5, 0], [-5, 5, 0]],
+    [[5, -5, 0], [5, 5, 0], [10, -10, 0]],
+    [[-10, 10, 0], [10, 10, 0], [-5, 5, 0]],
+    [[5, -5, 0], [10, -10, 0], [-10, -10, 0]],
+    [[-10, 10, 0], [-5, 5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]],
+    [[-10, -10, 0], [-10, 10, 0], [-5, -5, 0]]
   ]
-  t.is(pts.length, 24)
+  t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

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
  *
@@ -21,17 +25,18 @@ const extrudeLinear = (options, ...objects) => {
   const defaults = {
     height: 1,
     twistAngle: 0,
-    twistSteps: 1
+    twistSteps: 1,
+    repair: true
   }
-  const { height, twistAngle, twistSteps } = Object.assign({ }, defaults, options)
+  const { height, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
   objects = flatten(objects)
   if (objects.length === 0) throw new Error('wrong number of arguments')
 
-  options = { offset: [0, 0, height], twistAngle: twistAngle, twistSteps: twistSteps }
+  options = { offset: [0, 0, height], twistAngle, twistSteps, repair }
 
   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')
 
@@ -20,10 +20,12 @@ test('extrudeLinear (defaults)', (t) => {
     [[-5, 5, 0], [-5, -5, 1], [-5, 5, 1]],
     [[-5, -5, 0], [5, -5, 0], [5, -5, 1]],
     [[-5, -5, 0], [5, -5, 1], [-5, -5, 1]],
-    [[5, 5, 1], [-5, 5, 1], [-5, -5, 1], [5, -5, 1]],
-    [[5, -5, 0], [-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[-5, -5, 1], [5, -5, 1], [5, 5, 1]],
+    [[5, 5, 1], [-5, 5, 1], [-5, -5, 1]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -41,10 +43,12 @@ test('extrudeLinear (no twist)', (t) => {
     [[-5, 5, 0], [-5, -5, 15], [-5, 5, 15]],
     [[-5, -5, 0], [5, -5, 0], [5, -5, 15]],
     [[-5, -5, 0], [5, -5, 15], [-5, -5, 15]],
-    [[5, 5, 15], [-5, 5, 15], [-5, -5, 15], [5, -5, 15]],
-    [[5, -5, 0], [-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[-5, -5, 15], [5, -5, 15], [5, 5, 15]],
+    [[5, 5, 15], [-5, 5, 15], [-5, -5, 15]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: -15 }, geometry2)
@@ -58,10 +62,12 @@ test('extrudeLinear (no twist)', (t) => {
     [[-5, -5, 0], [-5, 5, -15], [-5, -5, -15]],
     [[5, -5, 0], [-5, -5, 0], [-5, -5, -15]],
     [[5, -5, 0], [-5, -5, -15], [5, -5, -15]],
-    [[5, -5, -15], [-5, -5, -15], [-5, 5, -15], [5, 5, -15]],
-    [[5, 5, 0], [-5, 5, 0], [-5, -5, 0], [5, -5, 0]]
+    [[-5, 5, -15], [5, 5, -15], [5, -5, -15]],
+    [[5, -5, -15], [-5, -5, -15], [-5, 5, -15]],
+    [[5, -5, 0], [5, 5, 0], [-5, 5, 0]],
+    [[-5, 5, 0], [-5, -5, 0], [5, -5, 0]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -79,11 +85,20 @@ test('extrudeLinear (twist)', (t) => {
     [[-5, 5, 0], [-7.0710678118654755, -4.440892098500626e-16, 15], [-4.440892098500626e-16, 7.0710678118654755, 15]],
     [[-5, -5, 0], [5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15]],
     [[-5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15], [-7.0710678118654755, -4.440892098500626e-16, 15]],
-    [[7.071067811865477, 8.881784197001252e-16, 15], [1.7763568394002505e-15, 7.071067811865477, 15],
-      [-7.071067811865475, 0, 15], [0, -7.0710678118654755, 15]],
-    [[5, -5, 0], [-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [
+      [-7.0710678118654755, -4.440892098500626e-16, 15],
+      [4.440892098500626e-16, -7.0710678118654755, 15],
+      [7.0710678118654755, 4.440892098500626e-16, 15]
+    ],
+    [
+      [7.0710678118654755, 4.440892098500626e-16, 15],
+      [-4.440892098500626e-16, 7.0710678118654755, 15],
+      [-7.0710678118654755, -4.440892098500626e-16, 15]
+    ],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 3 }, geometry2)
@@ -113,15 +128,17 @@ test('extrudeLinear (twist)', (t) => {
     [[-6.830127018922193, -1.8301270189221923, 10], [5, -5, 15], [-5, -5, 15]],
     [[1.8301270189221923, -6.830127018922193, 10], [6.830127018922193, 1.8301270189221923, 10], [5, 5, 15]],
     [[1.8301270189221923, -6.830127018922193, 10], [5, 5, 15], [5, -5, 15]],
-    [[-5, 5, 15], [-5, -5, 15], [5, -5, 15], [5, 5, 15]],
-    [[5, -5, 0], [-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+    [[5, -5, 15], [5, 5, 15], [-5, 5, 15]],
+    [[-5, 5, 15], [-5, -5, 15], [5, -5, 15]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
-  t.is(pts.length, 26)
+  t.is(pts.length, 28)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 242)
+  t.is(pts.length, 244)
 })
 
 test('extrudeLinear (holes)', (t) => {
@@ -154,15 +171,48 @@ test('extrudeLinear (holes)', (t) => {
     [[2, 2, 0], [2, -2, 15], [2, 2, 15]],
     [[-2, 2, 0], [2, 2, 0], [2, 2, 15]],
     [[-2, 2, 0], [2, 2, 15], [-2, 2, 15]],
-    [[-5, -5, 15], [-2, -5, 15], [-2, 5, 15], [-5, 5, 15]],
-    [[5, -5, 15], [5, -2, 15], [-2, -2, 15], [-2, -5, 15]],
-    [[5, 5, 15], [2, 5, 15], [2, -2, 15], [5, -2, 15]],
-    [[2, 2, 15], [2, 5, 15], [-2, 5, 15], [-2, 2, 15]],
-    [[-5, 5, 0], [-2, 5, 0], [-2, -5, 0], [-5, -5, 0]],
-    [[5, -5, 0], [-2, -5, 0], [-2, -2, 0], [5, -2, 0]],
-    [[5, -2, 0], [2, -2, 0], [2, 5, 0], [5, 5, 0]],
-    [[2, 5, 0], [2, 2, 0], [-2, 2, 0], [-2, 5, 0]]
+    [[5, -5, 15], [5, 5, 15], [2, 2, 15]],
+    [[-2, 2, 15], [2, 2, 15], [5, 5, 15]],
+    [[5, -5, 15], [2, 2, 15], [2, -2, 15]],
+    [[-2, 2, 15], [5, 5, 15], [-5, 5, 15]],
+    [[-5, -5, 15], [5, -5, 15], [2, -2, 15]],
+    [[-2, -2, 15], [-2, 2, 15], [-5, 5, 15]],
+    [[-5, -5, 15], [2, -2, 15], [-2, -2, 15]],
+    [[-2, -2, 15], [-5, 5, 15], [-5, -5, 15]],
+    [[2, 2, 0], [5, 5, 0], [5, -5, 0]],
+    [[5, 5, 0], [2, 2, 0], [-2, 2, 0]],
+    [[2, -2, 0], [2, 2, 0], [5, -5, 0]],
+    [[-5, 5, 0], [5, 5, 0], [-2, 2, 0]],
+    [[2, -2, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, 5, 0], [-2, 2, 0], [-2, -2, 0]],
+    [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [-2, -2, 0]]
   ]
-  t.is(pts.length, 24)
+  t.is(pts.length, 32)
   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]],
+    [[12, 0, 15], [6, 10, 15], [0, 0, 15]],
+    [[0, 0, 0], [6, 10, 0], [12, 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/extrudeLinearGeom2.js

@@ -14,6 +14,7 @@ const extrudeFromSlices = require('./extrudeFromSlices')
  * @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 {Boolean} [options.repair] - repair gaps in the geometry
  * @param {geom2} geometry - the geometry to extrude
  * @returns {geom3} the extruded 3D geometry
 */
@@ -21,9 +22,10 @@ const extrudeGeom2 = (options, geometry) => {
   const defaults = {
     offset: [0, 0, 1],
     twistAngle: 0,
-    twistSteps: 12
+    twistSteps: 12,
+    repair: true
   }
-  let { offset, twistAngle, twistSteps } = Object.assign({ }, defaults, options)
+  let { offset, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
   if (twistSteps < 1) throw new Error('twistSteps must be 1 or more')
 
@@ -53,6 +55,7 @@ const extrudeGeom2 = (options, geometry) => {
     numberOfSlices: twistSteps + 1,
     capStart: true,
     capEnd: true,
+    repair,
     callback: createTwist
   }
   return extrudeFromSlices(options, baseSlice)

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,7 +12,7 @@ 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
  *

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, 44)
 
   obs = extrudeRectangular({ }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 40)
+  t.is(pts.length, 32)
 })
 
 test('extrudeRectangular (chamfer)', (t) => {
@@ -25,11 +25,11 @@ test('extrudeRectangular (chamfer)', (t) => {
 
   let obs = extrudeRectangular({ corners: 'chamfer' }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 42)
+  t.is(pts.length, 60)
 
   obs = extrudeRectangular({ corners: 'chamfer' }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 32)
+  t.is(pts.length, 48)
 })
 
 test('extrudeRectangular (segments = 8, round)', (t) => {
@@ -38,11 +38,11 @@ test('extrudeRectangular (segments = 8, round)', (t) => {
 
   let obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 56)
+  t.is(pts.length, 84)
 
   obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 40)
+  t.is(pts.length, 64)
 })
 
 test('extrudeRectangular (holes)', (t) => {
@@ -59,5 +59,5 @@ test('extrudeRectangular (holes)', (t) => {
 
   const obs = extrudeRectangular({ size: 2, height: 15, segments: 16, corners: 'round' }, geometry2)
   const pts = geom3.toPoints(obs)
-  t.is(pts.length, 122)
+  t.is(pts.length, 192)
 })

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

@@ -29,21 +29,21 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[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]],
-    [[18.38477631085024, 18.384776310850235, 7.999999999999998], [18.38477631085024, 18.384776310850235, -8],
-      [7.071067811865478, 7.071067811865474, -8], [7.071067811865476, 7.071067811865475, 8]],
-    [[10, 4.898587196589411e-16, 8], [10, -4.898587196589413e-16, -8],
-      [26, -4.898587196589412e-16, -8], [26, 4.898587196589414e-16, 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]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 26)
+  t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 26)
+  t.is(pts.length, 28)
 })
 
 test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom3', (t) => {
@@ -107,16 +107,12 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
-      [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]
-    ],
-    [
-      [7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
-      [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -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]]
   ]
-  t.is(pts.length, 6)
+  t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // overlap of Y axis; larger number of - points
@@ -137,18 +133,14 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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]],
-    [
-      [-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
-      [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
-      [4.898587196589414e-16, 0, -8]
-    ],
-    [
-      [0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
-      [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
-      [0, 4.898587196589411e-16, 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]]
   ]
-  t.is(pts.length, 14)
+  t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 

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/calculatePlane.js

@@ -23,10 +23,13 @@ const calculatePlane = (slice) => {
   let farthestEdge
   let distance = 0
   edges.forEach((edge) => {
-    const d = vec3.squaredDistance(midpoint, edge[0])
-    if (d > distance) {
-      farthestEdge = edge
-      distance = d
+    // Make sure that the farthest edge is not a self-edge
+    if (!vec3.equals(edge[0], edge[1])) {
+      const d = vec3.squaredDistance(midpoint, edge[0])
+      if (d > distance) {
+        farthestEdge = edge
+        distance = d
+      }
     }
   })
   // find the before edge

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/repairSlice.js

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