@jscad/modeling 2.8.0 → 2.9.0

package/src/operations/extrusions/earcut/linkedPolygon.js

@@ -0,0 +1,197 @@
+const { Node, insertNode, removeNode } = require('./linkedList')
+const { area } = require('./triangle')
+
+/*
+ * create a circular doubly linked list from polygon points in the specified winding order
+ */
+const linkedPolygon = (data, start, end, dim, clockwise) => {
+  let last
+
+  if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+    for (let i = start; i < end; i += dim) {
+      last = insertNode(i, data[i], data[i + 1], last)
+    }
+  } else {
+    for (let i = end - dim; i >= start; i -= dim) {
+      last = insertNode(i, data[i], data[i + 1], last)
+    }
+  }
+
+  if (last && equals(last, last.next)) {
+    removeNode(last)
+    last = last.next
+  }
+
+  return last
+}
+
+/*
+ * eliminate colinear or duplicate points
+ */
+const filterPoints = (start, end) => {
+  if (!start) return start
+  if (!end) end = start
+
+  let p = start
+  let again
+  do {
+    again = false
+
+    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      removeNode(p)
+      p = end = p.prev
+      if (p === p.next) break
+      again = true
+    } else {
+      p = p.next
+    }
+  } while (again || p !== end)
+
+  return end
+}
+
+/*
+ * go through all polygon nodes and cure small local self-intersections
+ */
+const cureLocalIntersections = (start, triangles, dim) => {
+  let p = start
+  do {
+    const a = p.prev
+    const b = p.next.next
+
+    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i / dim)
+      triangles.push(p.i / dim)
+      triangles.push(b.i / dim)
+
+      // remove two nodes involved
+      removeNode(p)
+      removeNode(p.next)
+
+      p = start = b
+    }
+
+    p = p.next
+  } while (p !== start)
+
+  return filterPoints(p)
+}
+
+/*
+ * check if a polygon diagonal intersects any polygon segments
+ */
+const intersectsPolygon = (a, b) => {
+  let p = a
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+        intersects(p, p.next, a, b)) return true
+    p = p.next
+  } while (p !== a)
+
+  return false
+}
+
+/*
+ * check if a polygon diagonal is locally inside the polygon
+ */
+const locallyInside = (a, b) => area(a.prev, a, a.next) < 0
+  ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0
+  : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0
+
+/*
+ * check if the middle point of a polygon diagonal is inside the polygon
+ */
+const middleInside = (a, b) => {
+  let p = a
+  let inside = false
+  const px = (a.x + b.x) / 2
+  const py = (a.y + b.y) / 2
+  do {
+    if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+        (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)) { inside = !inside }
+    p = p.next
+  } while (p !== a)
+
+  return inside
+}
+
+/*
+ * link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two
+ * if one belongs to the outer ring and another to a hole, it merges it into a single ring
+ */
+const splitPolygon = (a, b) => {
+  const a2 = new Node(a.i, a.x, a.y)
+  const b2 = new Node(b.i, b.x, b.y)
+  const an = a.next
+  const bp = b.prev
+
+  a.next = b
+  b.prev = a
+
+  a2.next = an
+  an.prev = a2
+
+  b2.next = a2
+  a2.prev = b2
+
+  bp.next = b2
+  b2.prev = bp
+
+  return b2
+}
+
+/*
+ * check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+ */
+const isValidDiagonal = (a, b) => a.next.i !== b.i &&
+    a.prev.i !== b.i &&
+    !intersectsPolygon(a, b) && // doesn't intersect other edges
+    (
+      locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+        (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+        equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0
+    )
+
+/*
+ * check if two segments intersect
+ */
+const intersects = (p1, q1, p2, q2) => {
+  const o1 = Math.sign(area(p1, q1, p2))
+  const o2 = Math.sign(area(p1, q1, q2))
+  const o3 = Math.sign(area(p2, q2, p1))
+  const o4 = Math.sign(area(p2, q2, q1))
+
+  if (o1 !== o2 && o3 !== o4) return true // general case
+
+  if (o1 === 0 && onSegment(p1, p2, q1)) return true // p1, q1 and p2 are colinear and p2 lies on p1q1
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true // p1, q1 and q2 are colinear and q2 lies on p1q1
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true // p2, q2 and p1 are colinear and p1 lies on p2q2
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true // p2, q2 and q1 are colinear and q1 lies on p2q2
+
+  return false
+}
+
+/*
+ * for colinear points p, q, r, check if point q lies on segment pr
+ */
+const onSegment = (p, q, r) => q.x <= Math.max(p.x, r.x) &&
+    q.x >= Math.min(p.x, r.x) &&
+    q.y <= Math.max(p.y, r.y) &&
+    q.y >= Math.min(p.y, r.y)
+
+const signedArea = (data, start, end, dim) => {
+  let sum = 0
+  for (let i = start, j = end - dim; i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1])
+    j = i
+  }
+
+  return sum
+}
+
+/*
+ * check if two points are equal
+ */
+const equals = (p1, p2) => p1.x === p2.x && p1.y === p2.y
+
+module.exports = { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, locallyInside, splitPolygon }

package/src/operations/extrusions/earcut/polygonHierarchy.js

@@ -0,0 +1,64 @@
+const geom2 = require('../../../geometries/geom2')
+const plane = require('../../../maths/plane')
+const vec2 = require('../../../maths/vec2')
+const vec3 = require('../../../maths/vec3')
+const calculatePlane = require('../slice/calculatePlane')
+const assignHoles = require('./assignHoles')
+
+/*
+ * Constructs a polygon hierarchy which associates holes with their outer solids.
+ * This class maps a 3D polygon onto a 2D space using an orthonormal basis.
+ * It tracks the mapping so that points can be reversed back to 3D losslessly.
+ */
+class PolygonHierarchy {
+  constructor (slice) {
+    this.plane = calculatePlane(slice)
+
+    // create an orthonormal basis
+    // choose an arbitrary right hand vector, making sure it is somewhat orthogonal to the plane normal
+    const rightvector = vec3.orthogonal(vec3.create(), this.plane)
+    const perp = vec3.cross(vec3.create(), this.plane, rightvector)
+    this.v = vec3.normalize(perp, perp)
+    this.u = vec3.cross(vec3.create(), this.v, this.plane)
+
+    // map from 2D to original 3D points
+    this.basisMap = new Map()
+
+    // project slice onto 2D plane
+    const projected = slice.edges.map((e) => e.map((v) => this.to2D(v)))
+
+    // compute polygon hierarchies, assign holes to solids
+    const geometry = geom2.create(projected)
+    this.roots = assignHoles(geometry)
+  }
+
+  /*
+   * project a 3D point onto the 2D plane
+   */
+  to2D (vector3) {
+    const vector2 = vec2.fromValues(vec3.dot(vector3, this.u), vec3.dot(vector3, this.v))
+    this.basisMap.set(vector2, vector3)
+    return vector2
+  }
+
+  /*
+   * un-project a 2D point back into 3D
+   */
+  to3D (vector2) {
+    // use a map to get the original 3D, no floating point error
+    const original = this.basisMap.get(vector2)
+    if (original) {
+      return original
+    } else {
+      console.log('Warning: point not in original slice')
+      const v1 = vec3.scale(vec3.create(), this.u, vector2[0])
+      const v2 = vec3.scale(vec3.create(), this.v, vector2[1])
+
+      const planeOrigin = vec3.scale(vec3.create(), plane, plane[3])
+      const v3 = vec3.add(v1, v1, planeOrigin)
+      return vec3.add(v2, v2, v3)
+    }
+  }
+}
+
+module.exports = PolygonHierarchy

package/src/operations/extrusions/earcut/triangle.js

@@ -0,0 +1,16 @@
+
+/*
+ * check if a point lies within a convex triangle
+ */
+const pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (
+  (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
+      (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
+      (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
+)
+
+/*
+ * signed area of a triangle
+ */
+const area = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
+
+module.exports = { area, pointInTriangle }

package/src/operations/extrusions/extrudeFromSlices.js

@@ -5,6 +5,7 @@ const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
 const slice = require('./slice')
+const repairSlice = require('./slice/repairSlice')
 
 const extrudeWalls = require('./extrudeWalls')
 
@@ -25,6 +26,7 @@ const defaultCallback = (progress, index, base) => {
  * @param {Boolean} [options.capStart=true] the solid should have a cap at the start
  * @param {Boolean} [options.capEnd=true] the solid should have a cap at the end
  * @param {Boolean} [options.close=false] the solid should have a closing section between start and end
+ * @param {Boolean} [options.repair=true] - repair gaps in the geometry
  * @param {Function} [options.callback] the callback function that generates each slice
  * @param {Object} base - the base object which is used to create slices (see the example for callback information)
  * @return {geom3} the extruded shape
@@ -48,12 +50,18 @@ const extrudeFromSlices = (options, base) => {
     capStart: true,
     capEnd: true,
     close: false,
+    repair: true,
     callback: defaultCallback
   }
-  const { numberOfSlices, capStart, capEnd, close, callback: generate } = Object.assign({ }, defaults, options)
+  const { numberOfSlices, capStart, capEnd, close, repair, callback: generate } = Object.assign({ }, defaults, options)
 
   if (numberOfSlices < 2) throw new Error('numberOfSlices must be 2 or more')
 
+  // Repair gaps in the base slice
+  if (repair) {
+    repairSlice(base)
+  }
+
   const sMax = numberOfSlices - 1
 
   let startSlice = null
@@ -90,8 +98,7 @@ const extrudeFromSlices = (options, base) => {
   }
   if (capStart) {
     // create a cap at the start
-    slice.reverse(startSlice, startSlice)
-    const startPolygons = slice.toPolygons(startSlice)
+    const startPolygons = slice.toPolygons(startSlice).map(poly3.invert)
     polygons = polygons.concat(startPolygons)
   }
   if (!capStart && !capEnd) {

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

@@ -25,14 +25,15 @@ 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 (path2.isA(object)) return extrudeLinearPath2(options, object)

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

@@ -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,16 +171,24 @@ 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))
 })
 
@@ -179,9 +204,10 @@ test('extrudeLinear (path2)', (t) => {
     [[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]]
+    [[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))
 })

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/extrudeRectangular.test.js

@@ -12,11 +12,11 @@ test('extrudeRectangular (defaults)', (t) => {
 
   let obs = extrudeRectangular({ }, geometry1)
   let pts = geom3.toPoints(obs)
-  t.is(pts.length, 34)
+  t.is(pts.length, 44)
 
   obs = extrudeRectangular({ }, geometry2)
   pts = geom3.toPoints(obs)
-  t.is(pts.length, 24)
+  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)
 })