@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { TAU } = require('../../maths/constants')
+
+const { geom2, geom3 } = require('../../geometries')
+
+const { arc, rectangle } = require('../../primitives')
+
+const { extrudeRectangular } = require('./index')
+
+test('extrudeRectangular (defaults)', (t) => {
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
+  const geometry2 = rectangle({ size: [5, 5] })
+
+  let obs = extrudeRectangular({ }, geometry1)
+  let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 44)
+
+  obs = extrudeRectangular({ }, geometry2)
+  pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 32)
+})
+
+test('extrudeRectangular (chamfer)', (t) => {
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
+  const geometry2 = rectangle({ size: [5, 5] })
+
+  let obs = extrudeRectangular({ corners: 'chamfer' }, geometry1)
+  let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 60)
+
+  obs = extrudeRectangular({ corners: 'chamfer' }, geometry2)
+  pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 48)
+})
+
+test('extrudeRectangular (segments = 8, round)', (t) => {
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
+  const geometry2 = rectangle({ size: [5, 5] })
+
+  let obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry1)
+  let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 84)
+
+  obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry2)
+  pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 64)
+})
+
+test('extrudeRectangular (holes)', (t) => {
+  const geometry2 = geom2.create([
+    [[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.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 192)
+})

package/src/operations/extrusions/extrudeRectangularGeom2.js

@@ -0,0 +1,46 @@
+const { area } = require('../../maths/utils')
+
+const geom2 = require('../../geometries/geom2')
+const path2 = require('../../geometries/path2')
+
+const expand = require('../expansions/expand')
+
+const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
+
+/*
+ * Expand and extrude the given geometry (geom2).
+ * @see expand for additional 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 {geom2} geometry - the geometry to extrude
+ * @return {geom3} the extruded geometry
+ */
+const extrudeRectangularGeom2 = (options, geometry) => {
+  const defaults = {
+    size: 1,
+    height: 1
+  }
+  const { size, height } = Object.assign({ }, defaults, options)
+
+  options.delta = size
+  options.offset = [0, 0, height]
+
+  // convert the geometry to outlines
+  const outlines = geom2.toOutlines(geometry)
+  if (outlines.length === 0) throw new Error('the given geometry cannot be empty')
+
+  // expand the outlines
+  const newparts = outlines.map((outline) => {
+    if (area(outline) < 0) outline.reverse() // all outlines must wind counter clockwise
+    return expand(options, path2.fromPoints({ closed: true }, outline))
+  })
+
+  // create a composite geometry
+  const allsides = newparts.reduce((sides, part) => sides.concat(geom2.toSides(part)), [])
+  const newgeometry = geom2.create(allsides)
+
+  return extrudeLinearGeom2(options, newgeometry)
+}
+
+module.exports = extrudeRectangularGeom2

package/src/operations/extrusions/extrudeRectangularPath2.js

@@ -0,0 +1,33 @@
+const path2 = require('../../geometries/path2')
+
+const expand = require('../expansions/expand')
+
+const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
+
+/*
+ * Expand and extrude the given geometry (path2).
+ * @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 {path2} geometry - the geometry to extrude
+ * @return {geom3} the extruded geometry
+ */
+const extrudeRectangularPath2 = (options, geometry) => {
+  const defaults = {
+    size: 1,
+    height: 1
+  }
+  const { size, height } = Object.assign({ }, defaults, options)
+
+  options.delta = size
+  options.offset = [0, 0, height]
+
+  const points = path2.toPoints(geometry)
+  if (points.length === 0) throw new Error('the given geometry cannot be empty')
+
+  const newgeometry = expand(options, geometry)
+  return extrudeLinearGeom2(options, newgeometry)
+}
+
+module.exports = extrudeRectangularPath2

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

@@ -0,0 +1,12 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+
+export default extrudeRotate
+
+export interface ExtrudeRotateOptions {
+  angle?: number
+  startAngle?: number
+  overflow?: 'cap'
+  segments?: number;
+}
+
+declare function extrudeRotate(options: ExtrudeRotateOptions, geometry: Geom2): Geom3

package/src/operations/extrusions/extrudeRotate.js

@@ -0,0 +1,138 @@
+const { TAU } = require('../../maths/constants')
+const mat4 = require('../../maths/mat4')
+
+const { mirrorX } = require('../transforms/mirror')
+
+const geom2 = require('../../geometries/geom2')
+
+const slice = require('./slice')
+
+const extrudeFromSlices = require('./extrudeFromSlices')
+
+/**
+ * Rotate extrude the given geometry using the given options.
+ *
+ * @param {Object} options - options for extrusion
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS)
+ * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
+ * @param {String} [options.overflow='cap'] - what to do with points outside of bounds (+ / - x) :
+ * defaults to capping those points to 0 (only supported behaviour for now)
+ * @param {Number} [options.segments=12] - number of segments of the extrusion
+ * @param {geom2} geometry - the geometry to extrude
+ * @returns {geom3} the extruded geometry
+ * @alias module:modeling/extrusions.extrudeRotate
+ *
+ * @example
+ * const myshape = extrudeRotate({segments: 8, angle: TAU / 2}, circle({size: 3, center: [4, 0]}))
+ */
+const extrudeRotate = (options, geometry) => {
+  const defaults = {
+    segments: 12,
+    startAngle: 0,
+    angle: TAU,
+    overflow: 'cap'
+  }
+  let { segments, startAngle, angle, overflow } = Object.assign({}, defaults, options)
+
+  if (segments < 3) throw new Error('segments must be greater then 3')
+
+  startAngle = Math.abs(startAngle) > TAU ? startAngle % TAU : startAngle
+  angle = Math.abs(angle) > TAU ? angle % TAU : angle
+
+  let endAngle = startAngle + angle
+  endAngle = Math.abs(endAngle) > TAU ? endAngle % TAU : endAngle
+
+  if (endAngle < startAngle) {
+    const x = startAngle
+    startAngle = endAngle
+    endAngle = x
+  }
+  let totalRotation = endAngle - startAngle
+  if (totalRotation <= 0.0) totalRotation = TAU
+
+  if (Math.abs(totalRotation) < TAU) {
+    // adjust the segments to achieve the total rotation requested
+    const anglePerSegment = TAU / segments
+    segments = Math.floor(Math.abs(totalRotation) / anglePerSegment)
+    if (Math.abs(totalRotation) > (segments * anglePerSegment)) segments++
+  }
+
+  // console.log('startAngle: '+startAngle)
+  // console.log('endAngle: '+endAngle)
+  // console.log(totalRotation)
+  // console.log(segments)
+
+  // convert geometry to an array of sides, easier to deal with
+  let shapeSides = geom2.toSides(geometry)
+  if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
+
+  // determine if the rotate extrude can be computed in the first place
+  // ie all the points have to be either x > 0 or x < 0
+
+  // generic solution to always have a valid solid, even if points go beyond x/ -x
+  // 1. split points up between all those on the 'left' side of the axis (x<0) & those on the 'righ' (x>0)
+  // 2. for each set of points do the extrusion operation IN OPOSITE DIRECTIONS
+  // 3. union the two resulting solids
+
+  // 1. alt : OR : just cap of points at the axis ?
+
+  const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
+  const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
+  const arePointsWithNegAndPosX = pointsWithNegativeX.length > 0 && pointsWithPositiveX.length > 0
+
+  // FIXME actually there are cases where setting X=0 will change the basic shape
+  // - Alternative #1 : don't allow shapes with both negative and positive X values
+  // - Alternative #2 : remove one half of the shape (costly)
+  if (arePointsWithNegAndPosX && overflow === 'cap') {
+    if (pointsWithNegativeX.length > pointsWithPositiveX.length) {
+      shapeSides = shapeSides.map((side) => {
+        let point0 = side[0]
+        let point1 = side[1]
+        point0 = [Math.min(point0[0], 0), point0[1]]
+        point1 = [Math.min(point1[0], 0), point1[1]]
+        return [point0, point1]
+      })
+      // recreate the geometry from the (-) capped points
+      geometry = geom2.create(shapeSides)
+      geometry = mirrorX(geometry)
+    } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
+      shapeSides = shapeSides.map((side) => {
+        let point0 = side[0]
+        let point1 = side[1]
+        point0 = [Math.max(point0[0], 0), point0[1]]
+        point1 = [Math.max(point1[0], 0), point1[1]]
+        return [point0, point1]
+      })
+      // recreate the geometry from the (+) capped points
+      geometry = geom2.create(shapeSides)
+    }
+  }
+
+  const rotationPerSlice = totalRotation / segments
+  const isCapped = Math.abs(totalRotation) < TAU
+  const baseSlice = slice.fromSides(geom2.toSides(geometry))
+  slice.reverse(baseSlice, baseSlice)
+
+  const matrix = mat4.create()
+  const createSlice = (progress, index, base) => {
+    let Zrotation = rotationPerSlice * index + startAngle
+    // fix rounding error when rotating TAU radians
+    if (totalRotation === TAU && index === segments) {
+      Zrotation = startAngle
+    }
+    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), TAU / 4))
+
+    return slice.transform(matrix, base)
+  }
+
+  options = {
+    numberOfSlices: segments + 1,
+    capStart: isCapped,
+    capEnd: isCapped,
+    close: !isCapped,
+    callback: createSlice
+  }
+  return extrudeFromSlices(options, baseSlice)
+}
+
+module.exports = extrudeRotate

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

@@ -0,0 +1,161 @@
+const test = require('ava')
+
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const { TAU } = require('../../maths/constants')
+
+const { geom2, geom3 } = require('../../geometries')
+
+const { extrudeRotate } = require('./index')
+
+test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+  const geometry3 = extrudeRotate({ }, geometry2)
+  const pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 96)
+})
+
+test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (t) => {
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+  // test angle
+  let geometry3 = extrudeRotate({ segments: 4, angle: TAU / 8 }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  const exp = [
+    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
+    [[7.0710678118654755, 7.071067811865475, -8], [7.0710678118654755, 7.071067811865475, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[18.38477631085024, 18.384776310850235, 8], [18.38477631085024, 18.384776310850235, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, 8], [10, 0, 8], [10, 0, -8]],
+    [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
+  ]
+  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.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 28)
+
+  geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 28)
+})
+
+test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom3', (t) => {
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+  // test startAngle
+  let geometry3 = extrudeRotate({ segments: 5, startAngle: TAU / 8 }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  let exp = [
+    [7.0710678118654755, 7.071067811865475, 8],
+    [18.38477631085024, 18.384776310850235, 8],
+    [-11.803752993228215, 23.166169628897567, 8]
+  ]
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 40)
+  t.true(comparePoints(pts[0], exp))
+
+  geometry3 = extrudeRotate({ segments: 5, startAngle: -TAU / 8 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  exp = [
+    [7.0710678118654755, -7.071067811865475, 8],
+    [18.38477631085024, -18.384776310850235, 8],
+    [23.166169628897567, 11.803752993228215, 8]
+  ]
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 40)
+  t.true(comparePoints(pts[0], exp))
+})
+
+test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3', (t) => {
+  let geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+  // test segments
+  let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
+  let pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
+  t.is(pts.length, 32)
+
+  geometry3 = extrudeRotate({ segments: 64 }, geometry2)
+  pts = geom3.toPoints(geometry3)
+  t.notThrows(() => 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(() => 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(() => geom3.validate(geometry3))
+  t.is(pts.length, 80)
+})
+
+test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geom3', (t) => {
+  // overlap of Y axis; even number of + and - points
+  let geometry = geom2.fromPoints([[-1, 8], [-1, -8], [7, -8], [7, 8]])
+
+  let obs = extrudeRotate({ segments: 4, angle: TAU / 4 }, geometry)
+  let pts = geom3.toPoints(obs)
+  let exp = [
+    [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
+    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [0, 7, -8], [0, 7, 8]],
+    [[0, 0, -8], [0, 0, 8], [0, 7, 8]],
+    [[0, 7, 8], [0, 7, -8], [0, 0, -8]],
+    [[7, 0, 8], [0, 0, 8], [0, 0, -8]],
+    [[0, 0, -8], [7, 0, -8], [7, 0, 8]]
+  ]
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 8)
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  // overlap of Y axis; larger number of - points
+  geometry = geom2.fromPoints([[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]])
+
+  obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry)
+  pts = geom3.toPoints(obs)
+  exp = [
+    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [2, 0, 4], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0, 1, -8], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [1.4142135623730951, 1.414213562373095, 4], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [0, 2, 4], [0, 1, 8]],
+    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
+    [[0, 1, -8], [0, 0, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 1, 8], [0, 2, 4]],
+    [[0, 2, 4], [0, 1, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 0, -8], [1, 0, -8]],
+    [[2, 0, 4], [1, 0, 8], [0, 0, 8]],
+    [[0, 0, 8], [1, 0, -8], [2, 0, 4]]
+  ]
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 18)
+  t.true(comparePolygonsAsPoints(pts, exp))
+})
+
+// TEST HOLES

package/src/operations/extrusions/extrudeWalls.js

@@ -0,0 +1,78 @@
+const { EPS } = require('../../maths/constants')
+const vec3 = require('../../maths/vec3')
+
+const poly3 = require('../../geometries/poly3')
+
+const slice = require('./slice')
+
+// https://en.wikipedia.org/wiki/Greatest_common_divisor#Using_Euclid's_algorithm
+const gcd = (a, b) => {
+  if (a === b) { return a }
+  if (a < b) { return gcd(b, a) }
+  if (b === 1) { return 1 }
+  if (b === 0) { return a }
+  return gcd(b, a % b)
+}
+
+const lcm = (a, b) => (a * b) / gcd(a, b)
+
+// Return a set of edges that encloses the same area by splitting
+// the given edges to have newlength total edges.
+const repartitionEdges = (newlength, edges) => {
+  // NOTE: This implementation splits each edge evenly.
+  const multiple = newlength / edges.length
+  if (multiple === 1) {
+    return edges
+  }
+
+  const divisor = vec3.fromValues(multiple, multiple, multiple)
+
+  const newEdges = []
+  edges.forEach((edge) => {
+    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.divide(increment, increment, divisor)
+
+    // repartition the edge
+    let prev = edge[0]
+    for (let i = 1; i <= multiple; ++i) {
+      const next = vec3.add(vec3.create(), prev, increment)
+      newEdges.push([prev, next])
+      prev = next
+    }
+  })
+  return newEdges
+}
+
+const EPSAREA = (EPS * EPS / 2) * Math.sin(Math.PI / 3)
+
+/*
+ * Extrude (build) walls between the given slices.
+ * Each wall consists of two triangles, which may be invalid if slices are overlapping.
+ */
+const extrudeWalls = (slice0, slice1) => {
+  let edges0 = slice.toEdges(slice0)
+  let edges1 = slice.toEdges(slice1)
+
+  if (edges0.length !== edges1.length) {
+    // different shapes, so adjust one or both to the same number of edges
+    const newlength = lcm(edges0.length, edges1.length)
+    if (newlength !== edges0.length) edges0 = repartitionEdges(newlength, edges0)
+    if (newlength !== edges1.length) edges1 = repartitionEdges(newlength, edges1)
+  }
+
+  const walls = []
+  edges0.forEach((edge0, i) => {
+    const edge1 = edges1[i]
+
+    const poly0 = poly3.create([edge0[0], edge0[1], edge1[1]])
+    const poly0area = poly3.measureArea(poly0)
+    if (Number.isFinite(poly0area) && poly0area > EPSAREA) walls.push(poly0)
+
+    const poly1 = poly3.create([edge0[0], edge1[1], edge1[0]])
+    const poly1area = poly3.measureArea(poly1)
+    if (Number.isFinite(poly1area) && poly1area > EPSAREA) walls.push(poly1)
+  })
+  return walls
+}
+
+module.exports = extrudeWalls

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

@@ -0,0 +1,82 @@
+const test = require('ava')
+
+const { mat4 } = require('../../maths')
+
+const slice = require('./slice')
+
+const extrudeWalls = require('./extrudeWalls')
+
+test('extrudeWalls (same shapes)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  const shape0 = []
+  const shape1 = [
+    [[-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]]
+  ]
+  const shape2 = [ // hole
+    [[-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]]
+  ]
+
+  const slice0 = slice.fromSides(shape0)
+  const slice1 = slice.fromSides(shape1)
+  const slice2 = slice.fromSides(shape2)
+
+  // empty slices
+  let walls = extrudeWalls(slice0, slice0)
+  t.is(walls.length, 0)
+
+  // outline slices
+  walls = extrudeWalls(slice1, slice.transform(matrix, slice1))
+  t.is(walls.length, 8)
+
+  // slices with holes
+  walls = extrudeWalls(slice2, slice.transform(matrix, slice2))
+  t.is(walls.length, 16)
+})
+
+test('extrudeWalls (different shapes)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  const shape1 = [
+    [[-10.0, 10.0], [-10.0, -10.0]],
+    [[-10.0, -10.0], [10.0, -10.0]],
+    [[10.0, -10.0], [10.0, 10.0]]
+  ]
+  const shape2 = [
+    [[-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]]
+  ]
+  const shape3 = [
+    [[2.50000, -4.33013], [5.00000, 0.00000]],
+    [[5.00000, 0.00000], [2.50000, 4.33013]],
+    [[2.50000, 4.33013], [-2.50000, 4.33013]],
+    [[-2.50000, 4.33013], [-5.00000, 0.00000]],
+    [[-5.00000, 0.00000], [-2.50000, -4.33013]],
+    [[-2.50000, -4.33013], [2.50000, -4.33013]]
+  ]
+
+  const slice1 = slice.fromSides(shape1)
+  const slice2 = slice.fromSides(shape2)
+  const slice3 = slice.fromSides(shape3)
+
+  let walls = extrudeWalls(slice1, slice.transform(matrix, slice2))
+  t.is(walls.length, 24)
+
+  walls = extrudeWalls(slice1, slice.transform(matrix, slice3))
+  t.is(walls.length, 12)
+
+  walls = extrudeWalls(slice3, slice.transform(matrix, slice2))
+  t.is(walls.length, 24)
+})

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

@@ -0,0 +1,9 @@
+export { default as extrudeFromSlices, ExtrudeFromSlicesOptions } from './extrudeFromSlices'
+export { default as extrudeLinear, ExtrudeLinearOptions } from './extrudeLinear'
+export { default as extrudeRectangular, ExtrudeRectangularOptions } from './extrudeRectangular'
+export { default as extrudeRotate, ExtrudeRotateOptions } from './extrudeRotate'
+export { default as extrudeHelical, ExtrudeHelicalOptions } from './extrudeHelical'
+export { default as project, ProjectOptions } from './project'
+export * as slice from './slice'
+
+export as namespace extrusions

package/src/operations/extrusions/index.js

@@ -0,0 +1,16 @@
+/**
+ * All 2D shapes (primitives or the results of operations) can be extruded in various ways.
+ * In all cases, the function returns the results, and never changes the original shapes.
+ * @module modeling/extrusions
+ * @example
+ * const { extrudeHelical, extrudeLinear, extrudeRectangular, extrudeRotate, project, slice } = require('@jscad/modeling').extrusions
+ */
+module.exports = {
+  extrudeFromSlices: require('./extrudeFromSlices'),
+  extrudeLinear: require('./extrudeLinear'),
+  extrudeRectangular: require('./extrudeRectangular'),
+  extrudeRotate: require('./extrudeRotate'),
+  extrudeHelical: require('./extrudeHelical'),
+  project: require('./project'),
+  slice: require('./slice')
+}

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

@@ -0,0 +1,14 @@
+import { Geom2, Geom3 } from '../../geometries/types'
+import { Vec3 } from '../../maths/vec3'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default project
+
+export interface ProjectOptions {
+  axis?: Vec3
+  origin?: Vec3
+}
+
+declare function project(options: ProjectOptions, geometry: Geom3): Geom2
+declare function project(options: ProjectOptions, ...geometries: RecursiveArray<Geom3>): Array<Geom2>
+declare function project(options: ProjectOptions, ...geometries: RecursiveArray<any>): Array<any>