@jscad/modeling 2.9.2 → 2.9.3

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.2",
+  "version": "2.9.3",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
+  "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
   "types": "src/index.d.ts",
@@ -60,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "0cebde0166c104e3c08cc05d2c03d9defc7eca26"
+  "gitHead": "85fa1fcdfb2d516a201ecf31da242e64b5b3274e"
 }

package/src/colors/colorize.test.js

@@ -38,7 +38,7 @@ test('color (rgba on geometry)', (t) => {
   const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
   const obj1 = geom3.fromPoints([[[0, 0, 0], [1, 0, 0], [1, 0, 1]]])
   const obj2 = path2.fromPoints({ closed: true }, [[0, 0], [1, 0], [1, 1]])
-  const obj3 = poly3.fromPoints([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
+  const obj3 = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0]])
 
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)

package/src/geometries/geom2/toOutlines.js

@@ -6,22 +6,42 @@ const toSides = require('./toSides')
  * Create a list of edges which SHARE vertices.
  * This allows the edges to be traversed in order.
  */
-const toEdges = (sides) => {
-  const vertices = {}
+const toSharedVertices = (sides) => {
+  const unique = new Map() // {key: vertex}
   const getUniqueVertex = (vertex) => {
     const key = vertex.toString()
-    if (!vertices[key]) {
-      vertices[key] = vertex
+    if (unique.has(key)) {
+      return unique.get(key)
+    } else {
+      unique.set(key, vertex)
+      return vertex
     }
-    return vertices[key]
   }
 
   return sides.map((side) => side.map(getUniqueVertex))
 }
 
+/*
+ * Convert a list of sides into a map from vertex to edges.
+ */
+const toVertexMap = (sides) => {
+  const vertexMap = new Map()
+  // first map to edges with shared vertices
+  const edges = toSharedVertices(sides)
+  // construct adjacent edges map
+  edges.forEach((edge) => {
+    if (vertexMap.has(edge[0])) {
+      vertexMap.get(edge[0]).push(edge)
+    } else {
+      vertexMap.set(edge[0], [edge])
+    }
+  })
+  return vertexMap
+}
+
 /**
  * Create the outline(s) of the given geometry.
- * @param  {geom2} geometry
+ * @param {geom2} geometry - geometry to create outlines from
  * @returns {Array} an array of outlines, where each outline is an array of ordered points
  * @alias module:modeling/geometries/geom2.toOutlines
  *
@@ -30,65 +50,35 @@ const toEdges = (sides) => {
  * let outlines = toOutlines(geometry) // returns two outlines
  */
 const toOutlines = (geometry) => {
-  const vertexMap = new Map()
-  const edges = toEdges(toSides(geometry))
-  edges.forEach((edge) => {
-    if (!(vertexMap.has(edge[0]))) {
-      vertexMap.set(edge[0], [])
-    }
-    const sideslist = vertexMap.get(edge[0])
-    sideslist.push(edge)
-  })
-
+  const vertexMap = toVertexMap(toSides(geometry)) // {vertex: [edges]}
   const outlines = []
   while (true) {
-    let startside
+    let startSide
     for (const [vertex, edges] of vertexMap) {
-      startside = edges.shift()
-      if (!startside) {
+      startSide = edges.shift()
+      if (!startSide) {
         vertexMap.delete(vertex)
         continue
       }
       break
     }
-    if (startside === undefined) break // all starting sides have been visited
+    if (startSide === undefined) break // all starting sides have been visited
 
     const connectedVertexPoints = []
-    const startvertex = startside[0]
-    const v0 = vec2.create()
+    const startVertex = startSide[0]
     while (true) {
-      connectedVertexPoints.push(startside[0])
-      const nextvertex = startside[1]
-      if (nextvertex === startvertex) break // the outline has been closed
-      const nextpossiblesides = vertexMap.get(nextvertex)
-      if (!nextpossiblesides) {
-        throw new Error('the given geometry is not closed. verify proper construction')
+      connectedVertexPoints.push(startSide[0])
+      const nextVertex = startSide[1]
+      if (nextVertex === startVertex) break // the outline has been closed
+      const nextPossibleSides = vertexMap.get(nextVertex)
+      if (!nextPossibleSides) {
+        throw new Error(`geometry is not closed at vertex ${nextVertex}`)
       }
-      let nextsideindex = -1
-      if (nextpossiblesides.length === 1) {
-        nextsideindex = 0
-      } else {
-        // more than one side starting at the same vertex
-        let bestangle
-        const startangle = vec2.angleDegrees(vec2.subtract(v0, startside[1], startside[0]))
-        for (let sideindex = 0; sideindex < nextpossiblesides.length; sideindex++) {
-          const nextpossibleside = nextpossiblesides[sideindex]
-          const nextangle = vec2.angleDegrees(vec2.subtract(v0, nextpossibleside[1], nextpossibleside[0]))
-          let angledif = nextangle - startangle
-          if (angledif < -180) angledif += 360
-          if (angledif >= 180) angledif -= 360
-          if ((nextsideindex < 0) || (angledif > bestangle)) {
-            nextsideindex = sideindex
-            bestangle = angledif
-          }
-        }
+      const nextSide = popNextSide(startSide, nextPossibleSides)
+      if (nextPossibleSides.length === 0) {
+        vertexMap.delete(nextVertex)
       }
-      const nextside = nextpossiblesides[nextsideindex]
-      nextpossiblesides.splice(nextsideindex, 1) // remove side from list
-      if (nextpossiblesides.length === 0) {
-        vertexMap.delete(nextvertex)
-      }
-      startside = nextside
+      startSide = nextSide
     } // inner loop
 
     // due to the logic of fromPoints()
@@ -102,4 +92,28 @@ const toOutlines = (geometry) => {
   return outlines
 }
 
+// find the first counter-clockwise edge from startSide and pop from nextSides
+const popNextSide = (startSide, nextSides) => {
+  if (nextSides.length === 1) {
+    return nextSides.pop()
+  }
+  const v0 = vec2.create()
+  const startAngle = vec2.angleDegrees(vec2.subtract(v0, startSide[1], startSide[0]))
+  let bestAngle
+  let bestIndex
+  nextSides.forEach((nextSide, index) => {
+    const nextAngle = vec2.angleDegrees(vec2.subtract(v0, nextSide[1], nextSide[0]))
+    let angle = nextAngle - startAngle
+    if (angle < -180) angle += 360
+    if (angle >= 180) angle -= 360
+    if (bestIndex === undefined || angle > bestAngle) {
+      bestIndex = index
+      bestAngle = angle
+    }
+  })
+  const nextSide = nextSides[bestIndex]
+  nextSides.splice(bestIndex, 1) // remove side from list
+  return nextSide
+}
+
 module.exports = toOutlines

package/src/geometries/geom3/create.js

@@ -18,7 +18,7 @@ const create = (polygons) => {
     polygons = [] // empty contents
   }
   return {
-    polygons: polygons,
+    polygons,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -14,7 +14,7 @@ test('create: Creates an empty geom3', (t) => {
 
 test('create: Creates a populated geom3', (t) => {
   const points = [[0, 0, 0], [0, 10, 0], [0, 10, 10]]
-  const polygon = poly3.fromPoints(points)
+  const polygon = poly3.create(points)
 
   const polygons = [polygon]
   const expected = {

package/src/geometries/geom3/fromPoints.js

@@ -18,7 +18,7 @@ const fromPoints = (listofpoints) => {
 
   const polygons = listofpoints.map((points, index) => {
     // TODO catch the error, and rethrow with index
-    const polygon = poly3.fromPoints(points)
+    const polygon = poly3.create(points)
     return polygon
   })
   const result = create(polygons)

package/src/geometries/path2/index.d.ts

@@ -5,7 +5,6 @@ export { default as clone } from './clone'
 export { default as close } from './close'
 export { default as concat } from './concat'
 export { default as create } from './create'
-export { default as eachPoint, EachPointOptions } from './eachPoint'
 export { default as equals } from './equals'
 export { default as fromPoints, FromPointsOptions } from './fromPoints'
 export { default as fromCompactBinary } from './fromCompactBinary'

package/src/geometries/path2/index.js

@@ -22,7 +22,6 @@ module.exports = {
   close: require('./close'),
   concat: require('./concat'),
   create: require('./create'),
-  eachPoint: require('./eachPoint'),
   equals: require('./equals'),
   fromPoints: require('./fromPoints'),
   fromCompactBinary: require('./fromCompactBinary'),

package/src/geometries/poly3/create.js

@@ -18,7 +18,7 @@ const create = (vertices) => {
   if (vertices === undefined || vertices.length < 3) {
     vertices = [] // empty contents
   }
-  return { vertices: vertices }
+  return { vertices }
 }
 
 module.exports = create

package/src/geometries/poly3/validate.js

@@ -1,7 +1,10 @@
+const signedDistanceToPoint = require('../../maths/plane/signedDistanceToPoint')
+const { NEPS } = require('../../maths/constants')
 const vec3 = require('../../maths/vec3')
 const isA = require('./isA')
 const isConvex = require('./isConvex')
 const measureArea = require('./measureArea')
+const plane = require('./plane')
 
 /**
  * Determine if the given object is a valid polygon.
@@ -45,6 +48,17 @@ const validate = (object) => {
       throw new Error(`poly3 invalid vertex ${vertex}`)
     }
   })
+
+  // check that points are co-planar
+  if (object.vertices.length > 3) {
+    const normal = plane(object)
+    object.vertices.forEach((vertex) => {
+      const dist = Math.abs(signedDistanceToPoint(normal, vertex))
+      if (dist > NEPS) {
+        throw new Error(`poly3 must be coplanar: vertex ${vertex} distance ${dist}`)
+      }
+    })
+  }
 }
 
 module.exports = validate

package/src/maths/constants.d.ts

@@ -1,2 +1,3 @@
 export const EPS: number
+export const NEPS: number
 export const spatialResolution: number

package/src/maths/constants.js

@@ -14,7 +14,18 @@ const spatialResolution = 1e5
  */
 const EPS = 1e-5
 
+/**
+ * Smaller epsilon used for measuring near zero distances.
+ * @default
+ * @alias module:modeling/maths.NEPS
+ */
+const NEPS = 1e-13
+// NEPS is derived from a series of tests to determine the optimal precision
+// for comparing coplanar polygons, as provided by the sphere primitive at high
+// segmentation. NEPS is for 64 bit Number values.
+
 module.exports = {
   EPS,
+  NEPS,
   spatialResolution
 }

package/src/maths/utils/aboutEqualNormals.js

@@ -1,8 +1,4 @@
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
-// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
+const { NEPS } = require('../constants')
 
 /**
  * Compare two normals (unit vectors) for near equality.

package/src/operations/booleans/intersectGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const intersectSub = require('./intersectGeom3Sub')
 
 /*

package/src/operations/booleans/subtractGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const subtractSub = require('./subtractGeom3Sub')
 
 /*

package/src/operations/booleans/to3DWalls.js

@@ -14,7 +14,7 @@ const to3DWall = (z0, z1, side) => {
     vec3.fromVec2(vec3.create(), side[1], z1),
     vec3.fromVec2(vec3.create(), side[0], z1)
   ]
-  return poly3.fromPoints(points)
+  return poly3.create(points)
 }
 
 /*

package/src/operations/booleans/unionGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const unionSub = require('./unionGeom3Sub')
 
 /*

package/src/operations/expansions/expandGeom3.test.js

@@ -6,20 +6,20 @@ const expandGeom3 = require('./expandGeom3')
 test('expandGeom3: expand completes properly, issue 876', async (t) => {
   setTimeout(() => t.fail(), 1000)
   const polies = [
-    poly3.fromPoints([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
-    poly3.fromPoints([[-16.863040644206997, -0.8000000000000015, -10.28], [-16.863040644206997, -2.7500000000000018, -10.28], [-14.292644267871385, -2.7500000000000018, -11.855000000000016], [-14.292644267871383, -0.8000000000000015, -11.855000000000018]]),
-    poly3.fromPoints([[-17.319999999999993, -0.8000000000000015, -9.999999999999996], [-17.319999999999993, -2.7500000000000018, -9.999999999999996], [-16.87560702649131, -2.7500000000000018, -10.272299999999998], [-16.866696319053347, -0.8000000000000015, -10.277759999999997]]),
-    poly3.fromPoints([[-16.863040644207004, -2.7500000000000013, -10.280000000000001], [-16.863040644207004, -0.8000000000000014, -10.280000000000001], [-16.86669631905335, -0.8000000000000012, -10.27776], [-16.875607026491313, -2.75, -10.272300000000001]]),
-    poly3.fromPoints([[-14.107140000000015, -0.7999999999999987, 11.85500000000003], [-14.107140000000015, -2.7499999999999982, 11.85500000000003], [-17.319999999999975, -2.7499999999999982, 9.999999999999956], [-17.319999999999975, -0.7999999999999987, 9.999999999999956]]),
-    poly3.fromPoints([[-17.32, -0.7999999999999988, 9.999999999999993], [-17.32, -0.7999999999999986, 11.855], [-14.107139999999994, -0.7999999999999986, 11.855]]),
-    poly3.fromPoints([[-17.32, -0.800000000000001, -11.855], [-17.32, -0.8000000000000008, -10.000000000000078], [-14.292644267871482, -0.800000000000001, -11.855]]),
-    poly3.fromPoints([[-17.32, -0.800000000000001, -11.855], [-19.61, -0.800000000000001, -11.855], [-19.61, -0.7999999999999986, 11.855], [-17.32, -0.7999999999999986, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.7500000000000013, -10.000000000000076], [-17.32, -2.7500000000000018, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855]]),
-    poly3.fromPoints([[-17.32, -2.7499999999999982, 11.855], [-17.32, -2.7499999999999987, 9.999999999999996], [-14.107139999999996, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.7499999999999982, 11.855], [-19.61, -2.7499999999999982, 11.855], [-19.61, -2.7500000000000018, -11.855], [-17.32, -2.7500000000000018, -11.855]]),
-    poly3.fromPoints([[-14.107139999999996, -0.7999999999999986, 11.855], [-19.61, -0.7999999999999986, 11.855], [-19.61, -2.7499999999999982, 11.855], [-14.107139999999994, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-19.61, -0.8000000000000015, -11.855], [-14.292644267871486, -0.8000000000000015, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855], [-19.61, -2.7500000000000018, -11.855]])
+    poly3.create([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
+    poly3.create([[-16.863040644206997, -0.8000000000000015, -10.28], [-16.863040644206997, -2.7500000000000018, -10.28], [-14.292644267871385, -2.7500000000000018, -11.855000000000016], [-14.292644267871383, -0.8000000000000015, -11.855000000000018]]),
+    poly3.create([[-17.319999999999993, -0.8000000000000015, -9.999999999999996], [-17.319999999999993, -2.7500000000000018, -9.999999999999996], [-16.87560702649131, -2.7500000000000018, -10.272299999999998], [-16.866696319053347, -0.8000000000000015, -10.277759999999997]]),
+    poly3.create([[-16.863040644207004, -2.7500000000000013, -10.280000000000001], [-16.863040644207004, -0.8000000000000014, -10.280000000000001], [-16.86669631905335, -0.8000000000000012, -10.27776], [-16.875607026491313, -2.75, -10.272300000000001]]),
+    poly3.create([[-14.107140000000015, -0.7999999999999987, 11.85500000000003], [-14.107140000000015, -2.7499999999999982, 11.85500000000003], [-17.319999999999975, -2.7499999999999982, 9.999999999999956], [-17.319999999999975, -0.7999999999999987, 9.999999999999956]]),
+    poly3.create([[-17.32, -0.7999999999999988, 9.999999999999993], [-17.32, -0.7999999999999986, 11.855], [-14.107139999999994, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-17.32, -0.8000000000000008, -10.000000000000078], [-14.292644267871482, -0.800000000000001, -11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-19.61, -0.800000000000001, -11.855], [-19.61, -0.7999999999999986, 11.855], [-17.32, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -2.7500000000000013, -10.000000000000076], [-17.32, -2.7500000000000018, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-17.32, -2.7499999999999987, 9.999999999999996], [-14.107139999999996, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-19.61, -2.7499999999999982, 11.855], [-19.61, -2.7500000000000018, -11.855], [-17.32, -2.7500000000000018, -11.855]]),
+    poly3.create([[-14.107139999999996, -0.7999999999999986, 11.855], [-19.61, -0.7999999999999986, 11.855], [-19.61, -2.7499999999999982, 11.855], [-14.107139999999994, -2.7499999999999982, 11.855]]),
+    poly3.create([[-19.61, -0.8000000000000015, -11.855], [-14.292644267871486, -0.8000000000000015, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855], [-19.61, -2.7500000000000018, -11.855]])
   ]
 
   const sub = geom3.create(polies)

package/src/operations/expansions/expandShell.js

@@ -10,7 +10,8 @@ const poly3 = require('../../geometries/poly3')
 
 const sphere = require('../../primitives/sphere')
 
-const retessellate = require('../booleans/retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const unionGeom3Sub = require('../booleans/unionGeom3Sub')
 
 const extrudePolygon = require('./extrudePolygon')
@@ -166,7 +167,7 @@ const expandShell = (options, geometry) => {
           startfacevertices.push(p1)
           endfacevertices.push(p2)
           const points = [prevp2, p2, p1, prevp1]
-          const polygon = poly3.fromPoints(points)
+          const polygon = poly3.create(points)
           polygons.push(polygon)
         }
         prevp1 = p1
@@ -174,8 +175,8 @@ const expandShell = (options, geometry) => {
       }
     }
     endfacevertices.reverse()
-    polygons.push(poly3.fromPoints(startfacevertices))
-    polygons.push(poly3.fromPoints(endfacevertices))
+    polygons.push(poly3.create(startfacevertices))
+    polygons.push(poly3.create(endfacevertices))
 
     const cylinder = geom3.create(polygons)
     result = unionGeom3Sub(result, cylinder)

package/src/operations/expansions/extrudePolygon.js

@@ -17,14 +17,14 @@ const extrudePolygon = (offsetvector, polygon1) => {
   const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1)
   const numvertices = polygon1.vertices.length
   for (let i = 0; i < numvertices; i++) {
-    const sidefacepoints = []
     const nexti = (i < (numvertices - 1)) ? i + 1 : 0
-    sidefacepoints.push(polygon1.vertices[i])
-    sidefacepoints.push(polygon2.vertices[i])
-    sidefacepoints.push(polygon2.vertices[nexti])
-    sidefacepoints.push(polygon1.vertices[nexti])
-    const sidefacepolygon = poly3.fromPoints(sidefacepoints)
-    newpolygons.push(sidefacepolygon)
+    const sideFacePolygon = poly3.create([
+      polygon1.vertices[i],
+      polygon2.vertices[i],
+      polygon2.vertices[nexti],
+      polygon1.vertices[nexti]
+    ])
+    newpolygons.push(sideFacePolygon)
   }
   newpolygons.push(poly3.invert(polygon2))
 

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

@@ -32,7 +32,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   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]])
+  const poly2 = poly3.create([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
   pts = geom3.toPoints(geometry3)
 
@@ -45,7 +45,7 @@ test('extrudeFromSlices (torus)', (t) => {
   const sqrt3 = Math.sqrt(3) / 2
   const radius = 10
 
-  let hex = poly3.fromPoints([
+  let hex = poly3.create([
     [radius, 0, 0],
     [radius / 2, radius * sqrt3, 0],
     [-radius / 2, radius * sqrt3, 0],

package/src/operations/extrusions/extrudeRotate.js

@@ -114,7 +114,11 @@ const extrudeRotate = (options, geometry) => {
 
   const matrix = mat4.create()
   const createSlice = (progress, index, base) => {
-    const Zrotation = rotationPerSlice * index + startAngle
+    let Zrotation = rotationPerSlice * index + startAngle
+    // fix rounding error when rotating 2 * PI radians
+    if (totalRotation === Math.PI * 2 && index === segments) {
+      Zrotation = startAngle
+    }
     mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), Math.PI / 2))
 
     return slice.transform(matrix, base)

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

@@ -11,7 +11,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
 
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -61,7 +61,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, 18.384776310850235, 8],
     [-11.803752993228215, 23.166169628897567, 8]
   ]
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 
@@ -72,7 +72,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, -18.384776310850235, 8],
     [23.166169628897567, 11.803752993228215, 8]
   ]
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 })
@@ -83,12 +83,12 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 512)
 
   // test overlapping edges

package/src/operations/extrusions/extrudeWalls.js

@@ -64,11 +64,11 @@ const extrudeWalls = (slice0, slice1) => {
   edges0.forEach((edge0, i) => {
     const edge1 = edges1[i]
 
-    const poly0 = poly3.fromPoints([edge0[0], edge0[1], edge1[1]])
+    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.fromPoints([edge0[0], edge1[1], edge1[0]])
+    const poly1 = poly3.create([edge0[0], edge1[1], edge1[0]])
     const poly1area = poly3.measureArea(poly1)
     if (Number.isFinite(poly1area) && poly1area > EPSAREA) walls.push(poly1)
   })

package/src/operations/extrusions/project.js

@@ -11,7 +11,6 @@ const poly3 = require('../../geometries/poly3')
 const measureEpsilon = require('../../measurements/measureEpsilon')
 
 const unionGeom2 = require('../booleans/unionGeom2')
-const unionGeom3 = require('../booleans/unionGeom3')
 
 const projectGeom3 = (options, geometry) => {
   // create a plane from the options, and verify
@@ -27,32 +26,30 @@ const projectGeom3 = (options, geometry) => {
 
   // project the polygons to the plane
   const polygons = geom3.toPolygons(geometry)
-  const projpolys = []
+  let projpolys = []
   for (let i = 0; i < polygons.length; i++) {
     const newpoints = polygons[i].vertices.map((v) => plane.projectionOfPoint(projplane, v))
     const newpoly = poly3.create(newpoints)
-    // only keep projections that have a measurable area
-    if (poly3.measureArea(newpoly) < epsilonArea) continue
     // only keep projections that face the same direction as the plane
     const newplane = poly3.plane(newpoly)
     if (!aboutEqualNormals(projplane, newplane)) continue
+    // only keep projections that have a measurable area
+    if (poly3.measureArea(newpoly) < epsilonArea) continue
     projpolys.push(newpoly)
   }
-  // union the projected polygons to eliminate overlaying polygons
-  let projection = geom3.create(projpolys)
-  projection = unionGeom3(projection, projection)
-  // rotate the projection to lay on X/Y axes if necessary
+
+  // rotate the polygons to lay on X/Y axes if necessary
   if (!aboutEqualNormals(projplane, [0, 0, 1])) {
     const rotation = mat4.fromVectorRotation(mat4.create(), projplane, [0, 0, 1])
-    projection = geom3.transform(rotation, projection)
+    projpolys = projpolys.map((p) => poly3.transform(rotation, p))
   }
 
-  // convert the projection (polygons) into a series of 2D geometry
-  const projections2D = geom3.toPolygons(projection).map((p) => geom2.fromPoints(poly3.toPoints(p)))
-  // union the 2D geometries to obtain the outline of the projection
-  projection = unionGeom2(projections2D)
+  // sort the polygons to allow the union to ignore small pieces efficiently
+  projpolys = projpolys.sort((a, b) => poly3.measureArea(b) - poly3.measureArea(a))
 
-  return projection
+  // convert polygons to geometry, and union all pieces into a single geometry
+  const projgeoms = projpolys.map((p) => geom2.fromPoints(p.vertices))
+  return unionGeom2(projgeoms)
 }
 
 /**