@jbroll/jscad-modeling 2.12.7

package/src/operations/extrusions/extrudeHelical.js

@@ -0,0 +1,109 @@
+const { TAU } = require('../../maths/constants')
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+
+const extrudeFromSlices = require('./extrudeFromSlices')
+const slice = require('./slice')
+
+/**
+ * Perform a helical extrude of the geometry, using the given options.
+ *
+ * @param {Object} options - options for extrusion
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS); positive for right-hand rotation, negative for left-hand
+ * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
+ * @param {Number} [options.pitch=10] - elevation gain for each full rotation
+ * @param {Number} [options.height] - total height of the helix path. Ignored if pitch is set.
+ * @param {Number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
+ * @param {Number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
+ * @param {geom2} geometry - the geometry to extrude
+ * @returns {geom3} the extruded geometry
+ * @alias module:modeling/extrusions.extrudeHelical
+ *
+ * @example
+ * const myshape = circle({size: 3, center: [10, 0]}) // position for extrusion about Z
+ * const mycoil = extrudeHelical({angle: TAU * 2, pitch: 10, segmentsPerRotation: 64}, myshape))
+ */
+const extrudeHelical = (options, geometry) => {
+  const defaults = {
+    angle: TAU,
+    startAngle: 0,
+    pitch: 10,
+    height: 0,
+    endOffset: 0,
+    segmentsPerRotation: 32
+  }
+  let { angle, startAngle, pitch, height, endOffset, segmentsPerRotation } = Object.assign({}, defaults, options)
+
+  // calculate pitch from height if available
+  if (height != 0) {
+    // height / number of full rotations
+    pitch = height / (angle / TAU)
+  }
+
+  // needs at least 3 segments for each revolution
+  const minNumberOfSegments = 3
+
+  if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
+
+  const shapeSides = geom2.toSides(geometry)
+  if (shapeSides.length === 0) throw new Error('The given geometry cannot be empty')
+
+  // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
+  const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
+
+  let baseSlice = slice.fromSides(shapeSides)
+
+  if (pointsWithPositiveX.length === 0) {
+    // only points in negative x plane, reverse
+    baseSlice = slice.reverse(baseSlice)
+  }
+
+  const calculatedSegments = Math.round(segmentsPerRotation / TAU * Math.abs(angle))
+  const segments = calculatedSegments >= 2 ? calculatedSegments : 2
+
+  // define transform matrix variables for performance increase
+  const step1 = mat4.create()
+  const step2 = mat4.create()
+
+  const sliceCallback = (progress, index, base) => {
+    const zRotation = startAngle + angle / segments * index
+    const xOffset = endOffset / segments * index
+    const zOffset = (zRotation - startAngle) / TAU * pitch
+
+    // TODO: check for valid geometry after translations
+    // ie all the points have to be either x > -xOffset or x < -xOffset
+    // this would have to be checked for every transform, and handled
+    //
+    // not implementing, as this currently doesn't break anything,
+    // only creates inside-out polygons
+
+    // create transformation matrix
+    mat4.multiply(
+      step1,
+      // then apply offsets
+      mat4.fromTranslation(mat4.create(), [xOffset, 0, zOffset * Math.sign(angle)]),
+      // first rotate "flat" 2D shape from XY to XZ plane
+      mat4.fromXRotation(mat4.create(), -TAU / 4 * Math.sign(angle)) // rotate the slice correctly to not create inside-out polygon
+    )
+
+    mat4.multiply(
+      step2,
+      // finally rotate around Z axis
+      mat4.fromZRotation(mat4.create(), zRotation),
+      step1
+    )
+    return slice.transform(step2, base)
+  }
+
+  return extrudeFromSlices(
+    {
+      // "base" slice is counted as segment, so add one for complete final rotation
+      numberOfSlices: segments + 1,
+      callback: sliceCallback
+    },
+    baseSlice
+  )
+}
+
+module.exports = extrudeHelical

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

@@ -0,0 +1,70 @@
+const test = require('ava')
+const { TAU } = require('../../maths/constants')
+const { geom2, geom3 } = require('../../geometries')
+const { circle } = require('../../primitives')
+
+const { extrudeHelical } = require('./index')
+
+test('extrudeHelical: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
+})
+
+test('extrudeHelical: (defaults) extruding of a circle produces an expected geom3', (t) => {
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
+})
+
+test('extrudeHelical: (angle) extruding of a circle produces an expected geom3', (t) => {
+  const maxRevolutions = 10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(maxRevolutions).keys()]) {
+    // also test negative angles
+    const geometry3 = extrudeHelical({ angle: TAU * (index - maxRevolutions / 2) }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3', (t) => {
+  const startPitch = -10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(20).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ pitch: startPitch + index, startAngle: TAU * index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (height) extruding of a circle produces an expected geom3', (t) => {
+  const startHeight = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative heights
+    const geometry3 = extrudeHelical({ height: startHeight + index, angle: TAU * (index + 1) }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expected geom3', (t) => {
+  const startOffset = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ endRadiusOffset: startOffset + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})
+
+test('extrudeHelical: (segmentsPerRotation) extruding of a circle produces an expected geom3', (t) => {
+  const startSegments = 3
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(30).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ segmentsPerRotation: startSegments + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})

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

@@ -0,0 +1,15 @@
+import { Path2, Geom2, Geom3 } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default extrudeLinear
+
+export interface ExtrudeLinearOptions {
+  height?: number
+  twistAngle?: number
+  twistSteps?: number
+}
+
+type Geometry = Path2 | Geom2
+
+declare function extrudeLinear(options: ExtrudeLinearOptions, geometry: Geometry): Geom3
+declare function extrudeLinear(options: ExtrudeLinearOptions, ...geometries: RecursiveArray<Geometry>): Geom3

package/src/operations/extrusions/extrudeLinear.js

@@ -0,0 +1,47 @@
+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} objects - the geometries to extrude
+ * @return {Object|Array} the extruded geometry, or a list of extruded geometry
+ * @alias module:modeling/extrusions.extrudeLinear
+ *
+ * @example
+ * let myshape = extrudeLinear({height: 10}, rectangle({size: [20, 25]}))
+ */
+const extrudeLinear = (options, ...objects) => {
+  const defaults = {
+    height: 1,
+    twistAngle: 0,
+    twistSteps: 1,
+    repair: true
+  }
+  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, twistSteps, repair }
+
+  const results = objects.map((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
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = extrudeLinear

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

@@ -0,0 +1,226 @@
+const test = require('ava')
+
+const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
+
+const { TAU } = require('../../maths/constants')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { extrudeLinear } = require('./index')
+
+test('extrudeLinear (defaults)', (t) => {
+  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+
+  const geometry3 = extrudeLinear({ }, geometry2)
+  const pts = geom3.toPoints(geometry3)
+  const exp = [
+    [[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]],
+    [[-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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('extrudeLinear (no twist)', (t) => {
+  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+
+  let geometry3 = extrudeLinear({ height: 15 }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  let exp = [
+    [[5, -5, 0], [5, 5, 0], [5, 5, 15]],
+    [[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, 0], [-5, -5, 0], [-5, -5, 15]],
+    [[-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, 15], [-5, -5, 15]],
+    [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
+  ]
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  geometry3 = extrudeLinear({ height: -15 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  exp = [
+    [[5, 5, 0], [5, -5, 0], [5, -5, -15]],
+    [[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, 0], [-5, 5, 0], [-5, 5, -15]],
+    [[-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, -15], [-5, 5, -15]],
+    [[5, -5, 0], [5, 5, 0], [-5, 5, 0]],
+    [[-5, 5, 0], [-5, -5, 0], [5, -5, 0]]
+  ]
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+test('extrudeLinear (twist)', (t) => {
+  const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
+
+  let geometry3 = extrudeLinear({ height: 15, twistAngle: -TAU / 8 }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  let exp = [
+    [[5, -5, 0], [5, 5, 0], [7.0710678118654755, 4.440892098500626e-16, 15]],
+    [[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]],
+    [[-5, 5, 0], [-5, -5, 0], [-7.0710678118654755, -4.440892098500626e-16, 15]],
+    [[-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.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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 12)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 4, twistSteps: 3 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  exp = [
+    [[5, -5, 0], [5, 5, 0], [1.830127018922194, 6.830127018922193, 5]],
+    [[5, -5, 0], [1.830127018922194, 6.830127018922193, 5], [6.830127018922193, -1.830127018922194, 5]],
+    [[5, 5, 0], [-5, 5, 0], [-6.830127018922193, 1.830127018922194, 5]],
+    [[5, 5, 0], [-6.830127018922193, 1.830127018922194, 5], [1.830127018922194, 6.830127018922193, 5]],
+    [[-5, 5, 0], [-5, -5, 0], [-1.830127018922194, -6.830127018922193, 5]],
+    [[-5, 5, 0], [-1.830127018922194, -6.830127018922193, 5], [-6.830127018922193, 1.830127018922194, 5]],
+    [[-5, -5, 0], [5, -5, 0], [6.830127018922193, -1.830127018922194, 5]],
+    [[-5, -5, 0], [6.830127018922193, -1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5]],
+    [[6.830127018922193, -1.830127018922194, 5], [1.830127018922194, 6.830127018922193, 5], [-1.8301270189221923, 6.830127018922193, 10]],
+    [[6.830127018922193, -1.830127018922194, 5], [-1.8301270189221923, 6.830127018922193, 10], [6.830127018922193, 1.8301270189221923, 10]],
+    [[1.830127018922194, 6.830127018922193, 5], [-6.830127018922193, 1.830127018922194, 5], [-6.830127018922193, -1.8301270189221923, 10]],
+    [[1.830127018922194, 6.830127018922193, 5], [-6.830127018922193, -1.8301270189221923, 10], [-1.8301270189221923, 6.830127018922193, 10]],
+    [[-6.830127018922193, 1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5], [1.8301270189221923, -6.830127018922193, 10]],
+    [[-6.830127018922193, 1.830127018922194, 5], [1.8301270189221923, -6.830127018922193, 10], [-6.830127018922193, -1.8301270189221923, 10]],
+    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, -1.830127018922194, 5], [6.830127018922193, 1.8301270189221923, 10]],
+    [[-1.830127018922194, -6.830127018922193, 5], [6.830127018922193, 1.8301270189221923, 10], [1.8301270189221923, -6.830127018922193, 10]],
+    [[6.830127018922193, 1.8301270189221923, 10], [-1.8301270189221923, 6.830127018922193, 10], [-5, 5, 15]],
+    [[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]],
+    [[-6.830127018922193, -1.8301270189221923, 10], [1.8301270189221923, -6.830127018922193, 10], [5, -5, 15]],
+    [[-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, 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, 28)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 244)
+})
+
+test('extrudeLinear (holes)', (t) => {
+  const geometry2 = geom2.create([
+    [[-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)
+  const exp = [
+    [[-5, 5, 0], [-5, -5, 0], [-5, -5, 15]],
+    [[-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, 0], [5, 5, 0], [5, 5, 15]],
+    [[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]],
+    [[-2, -2, 0], [-2, 2, 0], [-2, 2, 15]],
+    [[-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]],
+    [[2, 2, 0], [2, -2, 0], [2, -2, 15]],
+    [[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], [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.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

@@ -0,0 +1,64 @@
+const mat4 = require('../../maths/mat4')
+const vec3 = require('../../maths/vec3')
+
+const geom2 = require('../../geometries/geom2')
+
+const slice = require('./slice')
+
+const extrudeFromSlices = require('./extrudeFromSlices')
+
+/*
+ * 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 {Boolean} [options.repair] - repair gaps in the geometry
+ * @param {geom2} geometry - the geometry to extrude
+ * @returns {geom3} the extruded 3D geometry
+*/
+const extrudeGeom2 = (options, geometry) => {
+  const defaults = {
+    offset: [0, 0, 1],
+    twistAngle: 0,
+    twistSteps: 12,
+    repair: true
+  }
+  let { offset, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
+
+  if (twistSteps < 1) throw new Error('twistSteps must be 1 or more')
+
+  if (twistAngle === 0) {
+    twistSteps = 1
+  }
+
+  // convert to vector in order to perform transforms
+  const offsetv = vec3.clone(offset)
+
+  const baseSides = geom2.toSides(geometry)
+  if (baseSides.length === 0) throw new Error('the given geometry cannot be empty')
+
+  const baseSlice = slice.fromSides(baseSides)
+  if (offsetv[2] < 0) slice.reverse(baseSlice, baseSlice)
+
+  const matrix = mat4.create()
+  const createTwist = (progress, index, base) => {
+    const Zrotation = index / twistSteps * twistAngle
+    const Zoffset = vec3.scale(vec3.create(), offsetv, index / twistSteps)
+    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromTranslation(mat4.create(), Zoffset))
+
+    return slice.transform(matrix, base)
+  }
+
+  options = {
+    numberOfSlices: twistSteps + 1,
+    capStart: true,
+    capEnd: true,
+    repair,
+    callback: createTwist
+  }
+  return extrudeFromSlices(options, baseSlice)
+}
+
+module.exports = extrudeGeom2

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

@@ -0,0 +1,17 @@
+import { Path2, Geom2, Geom3 } from '../../geometries/types'
+import { Corners } from '../../utils/corners'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default extrudeRectangular
+
+export interface ExtrudeRectangularOptions {
+  size?: number
+  height?: number
+  corners?: Corners
+  segments?: number
+}
+
+type Geometry = Path2 | Geom2
+
+declare function extrudeRectangular(options: ExtrudeRectangularOptions, geometry: Geometry): Geom3
+declare function extrudeRectangular(options: ExtrudeRectangularOptions, ...geometries: RecursiveArray<Geometry>): Geom3

package/src/operations/extrusions/extrudeRectangular.js

@@ -0,0 +1,45 @@
+const flatten = require('../../utils/flatten')
+
+const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
+
+const extrudeRectangularPath2 = require('./extrudeRectangularPath2')
+const extrudeRectangularGeom2 = require('./extrudeRectangularGeom2')
+
+/**
+ * Extrude the given geometry by following the outline(s) with a rectangle.
+ * @See expand for addition options
+ * @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} objects - the geometries to extrude
+ * @return {Object|Array} the extruded object, or a list of extruded objects
+ * @alias module:modeling/extrusions.extrudeRectangular
+ *
+ * @example
+ * let mywalls = extrudeRectangular({size: 1, height: 3}, square({size: 20}))
+ * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: TAU / 2}, square({size: 20}))
+ */
+const extrudeRectangular = (options, ...objects) => {
+  const defaults = {
+    size: 1,
+    height: 1
+  }
+  const { size, height } = Object.assign({}, defaults, options)
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  if (size <= 0) throw new Error('size must be positive')
+  if (height <= 0) throw new Error('height must be positive')
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return extrudeRectangularPath2(options, object)
+    if (geom2.isA(object)) return extrudeRectangularGeom2(options, object)
+    // if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = extrudeRectangular