@jscad/modeling 2.7.2 → 2.9.1

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

@@ -16,25 +16,28 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -66,6 +69,7 @@ test('extrudeFromSlices (torus)', (t) => {
     }, hex
   )
   const pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -84,7 +88,9 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 25)
+  // expected to throw because capEnd is false (non-closed geometry)
+  t.throws(() => geom3.validate(geometry3))
+  t.is(pts.length, 26)
 })
 
 test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
@@ -101,20 +107,21 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 298)
+  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.is(pts.length, 304)
 })
 
 test('extrudeFromSlices (holes)', (t) => {
   const geometry2 = geom2.create(
     [
-      [[-10.0, 10.0], [-10.0, -10.0]],
-      [[-10.0, -10.0], [10.0, -10.0]],
-      [[10.0, -10.0], [10.0, 10.0]],
-      [[10.0, 10.0], [-10.0, 10.0]],
-      [[-5.0, -5.0], [-5.0, 5.0]],
-      [[5.0, -5.0], [-5.0, -5.0]],
-      [[5.0, 5.0], [5.0, -5.0]],
-      [[-5.0, 5.0], [5.0, 5.0]]
+      [[-10, 10], [-10, -10]],
+      [[-10, -10], [10, -10]],
+      [[10, -10], [10, 10]],
+      [[10, 10], [-10, 10]],
+      [[-5, -5], [-5, 5]],
+      [[5, -5], [-5, -5]],
+      [[5, 5], [5, -5]],
+      [[-5, 5], [5, 5]]
     ]
   )
   const geometry3 = extrudeFromSlices({ }, geometry2)
@@ -136,15 +143,24 @@ 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.notThrows(() => geom3.validate(geometry3))
+  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 {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,13 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -41,10 +44,13 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: -15 }, geometry2)
@@ -58,10 +64,13 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -79,11 +88,21 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 3 }, geometry2)
@@ -113,27 +132,30 @@ 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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 244)
 })
 
 test('extrudeLinear (holes)', (t) => {
   const geometry2 = geom2.create([
-    [[-5.00000, 5.00000], [-5.00000, -5.00000]],
-    [[-5.00000, -5.00000], [5.00000, -5.00000]],
-    [[5.00000, -5.00000], [5.00000, 5.00000]],
-    [[5.00000, 5.00000], [-5.00000, 5.00000]],
-    [[-2.00000, -2.00000], [-2.00000, 2.00000]],
-    [[2.00000, -2.00000], [-2.00000, -2.00000]],
-    [[2.00000, 2.00000], [2.00000, -2.00000]],
-    [[-2.00000, 2.00000], [2.00000, 2.00000]]
+    [[-5, 5], [-5, -5]],
+    [[-5, -5], [5, -5]],
+    [[5, -5], [5, 5]],
+    [[5, 5], [-5, 5]],
+    [[-2, -2], [-2, 2]],
+    [[2, -2], [-2, -2]],
+    [[2, 2], [2, -2]],
+    [[-2, 2], [2, 2]]
   ])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   const pts = geom3.toPoints(geometry3)
@@ -154,15 +176,49 @@ 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.notThrows(() => geom3.validate(geometry3))
+  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.notThrows(() => geom3.validate(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,13 @@ test('extrudeRectangular (defaults)', (t) => {
 
   let obs = extrudeRectangular({ }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 50)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 44)
 
   obs = extrudeRectangular({ }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 40)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 32)
 })
 
 test('extrudeRectangular (chamfer)', (t) => {
@@ -25,11 +27,13 @@ test('extrudeRectangular (chamfer)', (t) => {
 
   let obs = extrudeRectangular({ corners: 'chamfer' }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 42)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 60)
 
   obs = extrudeRectangular({ corners: 'chamfer' }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 32)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 48)
 })
 
 test('extrudeRectangular (segments = 8, round)', (t) => {
@@ -38,26 +42,29 @@ 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.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 84)
 
   obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 40)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 64)
 })
 
 test('extrudeRectangular (holes)', (t) => {
   const geometry2 = geom2.create([
-    [[15.00000, 15.00000], [-15.00000, 15.00000]],
-    [[-15.00000, 15.00000], [-15.00000, -15.00000]],
-    [[-15.00000, -15.00000], [15.00000, -15.00000]],
-    [[15.00000, -15.00000], [15.00000, 15.00000]],
-    [[-5.00000, 5.00000], [5.00000, 5.00000]],
-    [[5.00000, 5.00000], [5.00000, -5.00000]],
-    [[5.00000, -5.00000], [-5.00000, -5.00000]],
-    [[-5.00000, -5.00000], [-5.00000, 5.00000]]
+    [[15, 15], [-15, 15]],
+    [[-15, 15], [-15, -15]],
+    [[-15, -15], [15, -15]],
+    [[15, -15], [15, 15]],
+    [[-5, 5], [5, 5]],
+    [[5, 5], [5, -5]],
+    [[5, -5], [-5, -5]],
+    [[-5, -5], [-5, 5]]
   ])
 
   const obs = extrudeRectangular({ size: 2, height: 15, segments: 16, corners: 'round' }, geometry2)
   const pts = geom3.toPoints(obs)
-  t.is(pts.length, 122)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 192)
 })

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.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -29,21 +30,24 @@ 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.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.is(pts.length, 26)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 26)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 28)
 })
 
 test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom3', (t) => {
@@ -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.skip(() => 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.skip(() => 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.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => 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)
 })
 
@@ -107,16 +117,13 @@ 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.notThrows.skip(() => geom3.validate(obs))
+  t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // overlap of Y axis; larger number of - points
@@ -137,18 +144,15 @@ 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.notThrows.skip(() => geom3.validate(obs))
+  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
  *