@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,54 @@
+
+// Simon Tatham's linked list merge sort algorithm
+// https://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+const sortLinked = (list, fn) => {
+  let i, p, q, e, numMerges
+  let inSize = 1
+
+  do {
+    p = list
+    list = null
+    let tail = null
+    numMerges = 0
+
+    while (p) {
+      numMerges++
+      q = p
+      let pSize = 0
+      for (i = 0; i < inSize; i++) {
+        pSize++
+        q = q.nextZ
+        if (!q) break
+      }
+
+      let qSize = inSize
+
+      while (pSize > 0 || (qSize > 0 && q)) {
+        if (pSize !== 0 && (qSize === 0 || !q || fn(p) <= fn(q))) {
+          e = p
+          p = p.nextZ
+          pSize--
+        } else {
+          e = q
+          q = q.nextZ
+          qSize--
+        }
+
+        if (tail) tail.nextZ = e
+        else list = e
+
+        e.prevZ = tail
+        tail = e
+      }
+
+      p = q
+    }
+
+    tail.nextZ = null
+    inSize *= 2
+  } while (numMerges > 1)
+
+  return list
+}
+
+module.exports = sortLinked

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.d.ts

@@ -0,0 +1,15 @@
+import Geom3 from '../../geometries/geom3/type'
+
+import Slice from './slice/type'
+
+export default extrudeFromSlices
+
+export interface ExtrudeFromSlicesOptions<Base> {
+  numberOfSlices?: number
+  capStart?: boolean
+  capEnd?: boolean
+  close?: boolean
+  callback?: (progress: number, index: number, base: Base) => Slice
+}
+
+declare function extrudeFromSlices<Base>(options: ExtrudeFromSlicesOptions<Base>, base: Base): Geom3

package/src/operations/extrusions/extrudeFromSlices.js

@@ -0,0 +1,124 @@
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const poly3 = require('../../geometries/poly3')
+
+const slice = require('./slice')
+const repairSlice = require('./slice/repair')
+
+const extrudeWalls = require('./extrudeWalls')
+
+const defaultCallback = (progress, index, base) => {
+  let baseSlice = null
+  if (geom2.isA(base)) baseSlice = slice.fromSides(geom2.toSides(base))
+  if (poly3.isA(base)) baseSlice = slice.fromPoints(poly3.toPoints(base))
+
+  return progress === 0 || progress === 1 ? slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, progress]), baseSlice) : null
+}
+
+/**
+ * Extrude a solid from the slices as returned by the callback function.
+ * @see slice
+ *
+ * @param {Object} options - options for extrude
+ * @param {Integer} [options.numberOfSlices=2] the number of slices to be generated by the callback
+ * @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
+ * @alias module:modeling/extrusions.extrudeFromSlices
+ *
+ * @example
+ * // Parameters:
+ * //   progress : the percent complete [0..1]
+ * //   index : the index of the current slice [0..numberOfSlices - 1]
+ * //   base : the base object as given
+ * // Return Value:
+ * //   slice or null (to skip)
+ * const callback = (progress, index, base) => {
+ *   ...
+ *   return slice
+ * }
+ */
+const extrudeFromSlices = (options, base) => {
+  const defaults = {
+    numberOfSlices: 2,
+    capStart: true,
+    capEnd: true,
+    close: false,
+    repair: true,
+    callback: defaultCallback
+  }
+  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) {
+    // note: base must be a slice, if base is geom2 this doesn't repair
+    base = repairSlice(base)
+  }
+
+  const sMax = numberOfSlices - 1
+
+  let startSlice = null
+  let endSlice = null
+  let prevSlice = null
+  let polygons = []
+  for (let s = 0; s < numberOfSlices; s++) {
+    // invoke the callback function to get the next slice
+    // NOTE: callback can return null to skip the slice
+    const currentSlice = generate(s / sMax, s, base)
+
+    if (currentSlice) {
+      if (!slice.isA(currentSlice)) throw new Error('the callback function must return slice objects')
+
+      const edges = slice.toEdges(currentSlice)
+      if (edges.length === 0) throw new Error('the callback function must return slices with one or more edges')
+
+      if (prevSlice) {
+        const walls = extrudeWalls(prevSlice, currentSlice)
+        for (let i = 0; i < walls.length; i++) {
+          polygons.push(walls[i])
+        }
+      }
+
+      // save start and end slices for caps if necessary
+      if (s === 0) startSlice = currentSlice
+      if (s === (numberOfSlices - 1)) endSlice = currentSlice
+
+      prevSlice = currentSlice
+    }
+  }
+
+  if (capEnd) {
+    // create a cap at the end
+    const endPolygons = slice.toPolygons(endSlice)
+    for (let i = 0; i < endPolygons.length; i++) {
+      polygons.push(endPolygons[i])
+    }
+  }
+  if (capStart) {
+    // create a cap at the start
+    const startPolygons = slice.toPolygons(startSlice).map(poly3.invert)
+    for (let i = 0; i < startPolygons.length; i++) {
+      polygons.push(startPolygons[i])
+    }
+  }
+  if (!capStart && !capEnd) {
+    // create walls between end and start slices
+    if (close && !slice.equals(endSlice, startSlice)) {
+      const walls = extrudeWalls(endSlice, startSlice)
+      for (let i = 0; i < walls.length; i++) {
+        polygons.push(walls[i])
+      }
+    }
+  }
+  return geom3.create(polygons)
+}
+
+module.exports = extrudeFromSlices

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

@@ -0,0 +1,167 @@
+const test = require('ava')
+
+const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
+
+const { TAU } = require('../../maths/constants')
+const mat4 = require('../../maths/mat4')
+
+const { geom2, geom3, poly3 } = require('../../geometries')
+
+const { circle } = require('../../primitives')
+
+const { extrudeFromSlices, slice } = require('./index')
+
+test('extrudeFromSlices (defaults)', (t) => {
+  const geometry2 = geom2.fromPoints([[10, 10], [-10, 10], [-10, -10], [10, -10]])
+
+  let geometry3 = extrudeFromSlices({ }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  const exp = [
+    [[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, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  const poly2 = poly3.create([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
+  geometry3 = extrudeFromSlices({ }, poly2)
+  pts = geom3.toPoints(geometry3)
+
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('extrudeFromSlices (torus)', (t) => {
+  const sqrt3 = Math.sqrt(3) / 2
+  const radius = 10
+
+  let hex = poly3.create([
+    [radius, 0, 0],
+    [radius / 2, radius * sqrt3, 0],
+    [-radius / 2, radius * sqrt3, 0],
+    [-radius, 0, 0],
+    [-radius / 2, -radius * sqrt3, 0],
+    [radius / 2, -radius * sqrt3, 0]
+  ])
+  hex = poly3.transform(mat4.fromTranslation(mat4.create(), [0, 20, 0]), hex)
+  hex = slice.fromPoints(poly3.toPoints(hex))
+
+  const angle = TAU / 8
+  const geometry3 = extrudeFromSlices(
+    {
+      numberOfSlices: TAU / angle,
+      capStart: false,
+      capEnd: false,
+      close: true,
+      callback: function (progress, index, base) {
+        return slice.transform(mat4.fromXRotation(mat4.create(), angle * index), base)
+      }
+    }, hex
+  )
+  const pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 96)
+})
+
+test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
+  const base = slice.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
+  const geometry3 = extrudeFromSlices(
+    {
+      numberOfSlices: 4,
+      capStart: true,
+      capEnd: false,
+      callback: function (progress, count, base) {
+        let newslice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 2]), base)
+        newslice = slice.transform(mat4.fromScaling(mat4.create(), [1 + count, 1 + (count / 2), 1]), newslice)
+        return newslice
+      }
+    }, base
+  )
+  const pts = geom3.toPoints(geometry3)
+  // 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) => {
+  const base = circle({ radius: 4, segments: 4 })
+  const geometry3 = extrudeFromSlices(
+    {
+      numberOfSlices: 5,
+      callback: (progress, count, base) => {
+        const newshape = circle({ radius: 5 + count, segments: 4 + count })
+        let newslice = slice.fromSides(geom2.toSides(newshape))
+        newslice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 10]), newslice)
+        return newslice
+      }
+    }, base
+  )
+  const pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.is(pts.length, 304)
+})
+
+test('extrudeFromSlices (holes)', (t) => {
+  const geometry2 = geom2.create(
+    [
+      [[-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)
+  const pts = geom3.toPoints(geometry3)
+  const exp = [
+    [[-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]],
+    [[-5, -5, 0], [-5, 5, 0], [-5, 5, 1]],
+    [[-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, 0], [5, -5, 0], [5, -5, 1]],
+    [[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], [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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 32)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})

package/src/operations/extrusions/extrudeHelical.d.ts

@@ -0,0 +1,14 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+
+export default extrudeHelical
+
+export interface ExtrudeHelicalOptions {
+  angle?: number
+  startAngle?: number
+  pitch?: number
+  height?: number
+  endOffset?: number
+  segmentsPerRotation?: number
+}
+
+declare function extrudeHelical(options: ExtrudeHelicalOptions, geometry: Geom2): Geom3