@jscad/modeling 2.12.0 → 3.0.0-alpha.0

package/src/operations/booleans/trees/splitPolygonByPlane.js

@@ -1,11 +1,11 @@
-const { EPS } = require('../../../maths/constants')
+import { EPS } from '../../../maths/constants.js'
 
-const plane = require('../../../maths/plane')
-const vec3 = require('../../../maths/vec3')
+import * as plane from '../../../maths/plane/index.js'
+import * as vec3 from '../../../maths/vec3/index.js'
 
-const poly3 = require('../../../geometries/poly3')
+import * as poly3 from '../../../geometries/poly3/index.js'
 
-const splitLineSegmentByPlane = require('./splitLineSegmentByPlane')
+import { splitLineSegmentByPlane } from './splitLineSegmentByPlane.js'
 
 // Returns object:
 // .type:
@@ -17,7 +17,7 @@ const splitLineSegmentByPlane = require('./splitLineSegmentByPlane')
 // In case the polygon is spanning, returns:
 // .front: a Polygon3 of the front part
 // .back: a Polygon3 of the back part
-const splitPolygonByPlane = (splane, polygon) => {
+export const splitPolygonByPlane = (splane, polygon) => {
   const result = {
     type: null,
     front: null,
@@ -25,97 +25,95 @@ const splitPolygonByPlane = (splane, polygon) => {
   }
   // cache in local lets (speedup):
   const vertices = polygon.vertices
-  const numvertices = vertices.length
+  const numVertices = vertices.length
   const pplane = poly3.plane(polygon)
   if (plane.equals(pplane, splane)) {
     result.type = 0
   } else {
-    let hasfront = false
-    let hasback = false
+    let hasFront = false
+    let hasBack = false
     const vertexIsBack = []
     const MINEPS = -EPS
-    for (let i = 0; i < numvertices; i++) {
+    for (let i = 0; i < numVertices; i++) {
       const t = vec3.dot(splane, vertices[i]) - splane[3]
       const isback = (t < MINEPS)
       vertexIsBack.push(isback)
-      if (t > EPS) hasfront = true
-      if (t < MINEPS) hasback = true
+      if (t > EPS) hasFront = true
+      if (t < MINEPS) hasBack = true
     }
-    if ((!hasfront) && (!hasback)) {
+    if ((!hasFront) && (!hasBack)) {
       // all points coplanar
       const t = vec3.dot(splane, pplane)
       result.type = (t >= 0) ? 0 : 1
-    } else if (!hasback) {
+    } else if (!hasBack) {
       result.type = 2
-    } else if (!hasfront) {
+    } else if (!hasFront) {
       result.type = 3
     } else {
       // spanning
       result.type = 4
-      const frontvertices = []
-      const backvertices = []
+      const frontVertices = []
+      const backVertices = []
       let isback = vertexIsBack[0]
-      for (let vertexindex = 0; vertexindex < numvertices; vertexindex++) {
-        const vertex = vertices[vertexindex]
-        let nextvertexindex = vertexindex + 1
-        if (nextvertexindex >= numvertices) nextvertexindex = 0
-        const nextisback = vertexIsBack[nextvertexindex]
-        if (isback === nextisback) {
+      for (let vertexIndex = 0; vertexIndex < numVertices; vertexIndex++) {
+        const vertex = vertices[vertexIndex]
+        let nextVertexIndex = vertexIndex + 1
+        if (nextVertexIndex >= numVertices) nextVertexIndex = 0
+        const nextIsBack = vertexIsBack[nextVertexIndex]
+        if (isback === nextIsBack) {
           // line segment is on one side of the plane:
           if (isback) {
-            backvertices.push(vertex)
+            backVertices.push(vertex)
           } else {
-            frontvertices.push(vertex)
+            frontVertices.push(vertex)
           }
         } else {
           // line segment intersects plane:
-          const nextpoint = vertices[nextvertexindex]
-          const intersectionpoint = splitLineSegmentByPlane(splane, vertex, nextpoint)
+          const nextPoint = vertices[nextVertexIndex]
+          const intersectionPoint = splitLineSegmentByPlane(splane, vertex, nextPoint)
           if (isback) {
-            backvertices.push(vertex)
-            backvertices.push(intersectionpoint)
-            frontvertices.push(intersectionpoint)
+            backVertices.push(vertex)
+            backVertices.push(intersectionPoint)
+            frontVertices.push(intersectionPoint)
           } else {
-            frontvertices.push(vertex)
-            frontvertices.push(intersectionpoint)
-            backvertices.push(intersectionpoint)
+            frontVertices.push(vertex)
+            frontVertices.push(intersectionPoint)
+            backVertices.push(intersectionPoint)
           }
         }
-        isback = nextisback
-      } // for vertexindex
+        isback = nextIsBack
+      } // for vertexIndex
       // remove duplicate vertices:
       const EPS_SQUARED = EPS * EPS
-      if (backvertices.length >= 3) {
-        let prevvertex = backvertices[backvertices.length - 1]
-        for (let vertexindex = 0; vertexindex < backvertices.length; vertexindex++) {
-          const vertex = backvertices[vertexindex]
-          if (vec3.squaredDistance(vertex, prevvertex) < EPS_SQUARED) {
-            backvertices.splice(vertexindex, 1)
-            vertexindex--
+      if (backVertices.length >= 3) {
+        let prevVertex = backVertices[backVertices.length - 1]
+        for (let vertexIndex = 0; vertexIndex < backVertices.length; vertexIndex++) {
+          const vertex = backVertices[vertexIndex]
+          if (vec3.squaredDistance(vertex, prevVertex) < EPS_SQUARED) {
+            backVertices.splice(vertexIndex, 1)
+            vertexIndex--
           }
-          prevvertex = vertex
+          prevVertex = vertex
         }
       }
-      if (frontvertices.length >= 3) {
-        let prevvertex = frontvertices[frontvertices.length - 1]
-        for (let vertexindex = 0; vertexindex < frontvertices.length; vertexindex++) {
-          const vertex = frontvertices[vertexindex]
-          if (vec3.squaredDistance(vertex, prevvertex) < EPS_SQUARED) {
-            frontvertices.splice(vertexindex, 1)
-            vertexindex--
+      if (frontVertices.length >= 3) {
+        let prevVertex = frontVertices[frontVertices.length - 1]
+        for (let vertexIndex = 0; vertexIndex < frontVertices.length; vertexIndex++) {
+          const vertex = frontVertices[vertexIndex]
+          if (vec3.squaredDistance(vertex, prevVertex) < EPS_SQUARED) {
+            frontVertices.splice(vertexIndex, 1)
+            vertexIndex--
           }
-          prevvertex = vertex
+          prevVertex = vertex
         }
       }
-      if (frontvertices.length >= 3) {
-        result.front = poly3.fromPointsAndPlane(frontvertices, pplane)
+      if (frontVertices.length >= 3) {
+        result.front = poly3.fromVerticesAndPlane(frontVertices, pplane)
       }
-      if (backvertices.length >= 3) {
-        result.back = poly3.fromPointsAndPlane(backvertices, pplane)
+      if (backVertices.length >= 3) {
+        result.back = poly3.fromVerticesAndPlane(backVertices, pplane)
       }
     }
   }
   return result
 }
-
-module.exports = splitPolygonByPlane

package/src/operations/booleans/union.d.ts

@@ -1,7 +1,6 @@
-import { Geom2, Geom3 } from '../../geometries/types'
-import RecursiveArray from '../../utils/recursiveArray'
+import type { Geom2 } from '../../geometries/geom2/type.d.ts'
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
 
-export default union
-
-declare function union(...geometries: RecursiveArray<Geom2>): Geom2
-declare function union(...geometries: RecursiveArray<Geom3>): Geom3
+export function union(...geometries: RecursiveArray<Geom2>): Geom2
+export function union(...geometries: RecursiveArray<Geom3>): Geom3

package/src/operations/booleans/union.js

@@ -1,18 +1,18 @@
-const flatten = require('../../utils/flatten')
-const areAllShapesTheSameType = require('../../utils/areAllShapesTheSameType')
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { flatten } from '../../utils/flatten.js'
 
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
+import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
 
-const unionGeom2 = require('./unionGeom2')
-const unionGeom3 = require('./unionGeom3')
+import { unionGeom2 } from './unionGeom2.js'
+import { unionGeom3 } from './unionGeom3.js'
 
 /**
  * Return a new geometry representing the total space in the given geometries.
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {geom2|geom3} a new geometry
+ * @returns {Geom2|geom3} a new geometry
  * @alias module:modeling/booleans.union
  *
  * @example
@@ -28,19 +28,17 @@ const unionGeom3 = require('./unionGeom3')
  *      |       |            |       |
  *      +-------+            +-------+
  */
-const union = (...geometries) => {
+export const union = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  if (geometries.length === 0) throw new Error('union wrong number of arguments')
 
   if (!areAllShapesTheSameType(geometries)) {
-    throw new Error('only unions of the same type are supported')
+    throw new Error('union arguments must be the same geometry type')
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return pathunion(matrix, geometries)
+  // if (path.isA(geometry)) return unionPath(matrix, geometries)
   if (geom2.isA(geometry)) return unionGeom2(geometries)
   if (geom3.isA(geometry)) return unionGeom3(geometries)
-  return geometry
+  throw new Error('union unsupported geometry type')
 }
-
-module.exports = union

package/src/operations/booleans/union.test.js

@@ -0,0 +1,25 @@
+import test from 'ava'
+
+import { geom2, geom3 } from '../../geometries/index.js'
+
+import { union } from './index.js'
+
+test('union error wrong number of arguments', (t) => {
+  const message = 'union wrong number of arguments'
+  t.throws(() => union(), { message })
+  t.throws(() => union([]), { message })
+  t.throws(() => union([[], []]), { message })
+})
+
+test('union error different geometry types', (t) => {
+  const message = 'union arguments must be the same geometry type'
+  t.throws(() => union(geom2.create(), geom3.create()), { message })
+})
+
+test('union error non-geometries', (t) => {
+  const message = 'union unsupported geometry type'
+  t.throws(() => union([1, 2, 3], [4, 5, 6]), { message })
+  t.throws(() => union([], [123]), { message })
+  t.throws(() => union("one", "two"), { message })
+  t.throws(() => union(null, null), { message })
+})

package/src/operations/booleans/unionGeom2.js

@@ -1,26 +1,20 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const geom3 = require('../../geometries/geom3')
-
-const measureEpsilon = require('../../measurements/measureEpsilon')
-
-const fromFakePolygons = require('./fromFakePolygons')
-const to3DWalls = require('./to3DWalls')
-const unionGeom3 = require('./unionGeom3')
+import { UNION } from './martinez/operation.js'
+import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing the total space in the given 2D geometries.
  * @param {...geom2} geometries - list of 2D geometries to union
- * @returns {geom2} new 2D geometry
+ * @returns {Geom2} new 2D geometry
  */
-const union = (...geometries) => {
+export const unionGeom2 = (...geometries) => {
   geometries = flatten(geometries)
-  const newgeometries = geometries.map((geometry) => to3DWalls({ z0: -1, z1: 1 }, geometry))
 
-  const newgeom3 = unionGeom3(newgeometries)
-  const epsilon = measureEpsilon(newgeom3)
+  let newGeometry = geometries.shift()
+  geometries.forEach((geometry) => {
+    newGeometry = boolean(newGeometry, geometry, UNION)
+  })
 
-  return fromFakePolygons(epsilon, geom3.toPolygons(newgeom3))
+  return newGeometry
 }
-
-module.exports = union

package/src/operations/booleans/unionGeom2.test.js

@@ -1,15 +1,16 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePoints } = require('../../../test/helpers')
+import { comparePoints } from '../../../test/helpers/index.js'
 
-const { geom2 } = require('../../geometries')
+import { geom2 } from '../../geometries/index.js'
 
-const { circle, rectangle } = require('../../primitives')
+import { measureArea } from '../../measurements/index.js'
 
-const { union } = require('./index')
+import { circle, rectangle } from '../../primitives/index.js'
 
-const { center } = require('../transforms/center')
-const { translate } = require('../transforms/translate')
+import { center, translate } from '../transforms/index.js'
+
+import { union } from './index.js'
 
 test('union of one or more geom2 objects produces expected geometry', (t) => {
   const geometry1 = circle({ radius: 2, segments: 8 })
@@ -19,15 +20,17 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
   let obs = geom2.toPoints(result1)
   let exp = [
     [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
+    [1.4142135623730951, 1.414213562373095],
     [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
+    [-1.414213562373095, 1.4142135623730951],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
+    [1.4142135623730947, -1.4142135623730954]
   ]
   t.notThrows(() => geom2.validate(result1))
+  t.is(measureArea(result1), 11.31370849898476)
+  t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
   // union of two non-overlapping objects
@@ -37,19 +40,21 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
   obs = geom2.toPoints(result2)
   exp = [
     [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
+    [1.4142135623730951, 1.414213562373095],
     [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
+    [-1.414213562373095, 1.4142135623730951],
     [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
+    [-1.4142135623730954, -1.414213562373095],
     [0, -2],
-    [8, 12],
+    [1.4142135623730947, -1.4142135623730954],
     [8, 8],
     [12, 8],
     [12, 12],
-    [1.4142000000000001, -1.4142000000000001]
+    [8, 12]
   ]
   t.notThrows(() => geom2.validate(result2))
+  t.is(measureArea(result2), 27.31370849898476)
+  t.is(obs.length, 12)
   t.true(comparePoints(obs, exp))
 
   // union of two partially overlapping objects
@@ -58,28 +63,32 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
   const result3 = union(geometry2, geometry3)
   obs = geom2.toPoints(result3)
   exp = [
-    [11.999973333333333, 11.999973333333333],
-    [7.999933333333333, 11.999973333333333],
-    [9.000053333333334, 7.999933333333333],
-    [-9.000053333333334, 9.000053333333334],
-    [-9.000053333333334, -9.000053333333334],
-    [9.000053333333334, -9.000053333333334],
-    [7.999933333333333, 9.000053333333334],
-    [11.999973333333333, 7.999933333333333]
+    [-9, -9],
+    [9, -9],
+    [9, 8],
+    [12, 8],
+    [12, 12],
+    [8, 12],
+    [8, 9],
+    [-9, 9]
   ]
   t.notThrows(() => geom2.validate(result3))
+  t.is(measureArea(result3), 339)
+  t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
   // union of two completely overlapping objects
   const result4 = union(geometry1, geometry3)
   obs = geom2.toPoints(result4)
   exp = [
-    [-9.000046666666666, -9.000046666666666],
-    [9.000046666666666, -9.000046666666666],
-    [9.000046666666666, 9.000046666666666],
-    [-9.000046666666666, 9.000046666666666]
+    [-9, -9],
+    [9, -9],
+    [9, 9],
+    [-9, 9]
   ]
   t.notThrows(() => geom2.validate(result4))
+  t.is(measureArea(result4), 324)
+  t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 
   // union of unions of non-overlapping objects (BSP gap from #907)
@@ -95,72 +104,108 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
     )
   )
   obs = geom2.toPoints(result5)
-  t.notThrows.skip(() => geom2.validate(result5))
-  t.is(obs.length, 112)
+  t.notThrows(() => geom2.validate(result5))
+  t.is(measureArea(result5), 9.36433545677411)
+  t.is(obs.length, 96)
 })
 
 test('union of geom2 with closing issues #15', (t) => {
   const c = geom2.create([
-    [[-45.82118740347841168159, -16.85726810555620147625], [-49.30331715865012398581, -14.68093629710870118288]],
-    [[-49.10586702080816223770, -15.27604177352110781385], [-48.16645938811709015681, -15.86317173589183227023]],
-    [[-49.60419521731581937729, -14.89550781504266296906], [-49.42407001323204696064, -15.67605088949303393520]],
-    [[-49.05727291218684626983, -15.48661638542171203881], [-49.10586702080816223770, -15.27604177352110781385]],
-    [[-49.30706235399220815907, -15.81529674600091794900], [-46.00505780290426827150, -17.21108547999804727624]],
-    [[-46.00505780290426827150, -17.21108547999804727624], [-45.85939703723252591772, -17.21502856394236857795]],
-    [[-45.85939703723252591772, -17.21502856394236857795], [-45.74972032664388166268, -17.11909303495791334626]],
-    [[-45.74972032664388166268, -17.11909303495791334626], [-45.73424573227583067592, -16.97420292661295349035]],
-    [[-45.73424573227583067592, -16.97420292661295349035], [-45.82118740347841168159, -16.85726810555620147625]],
-    [[-49.30331715865012398581, -14.68093629710870118288], [-49.45428884427643367871, -14.65565769658912387285]],
-    [[-49.45428884427643367871, -14.65565769658912387285], [-49.57891661679624917269, -14.74453612941635327616]],
-    [[-49.57891661679624917269, -14.74453612941635327616], [-49.60419521731581937729, -14.89550781504266296906]],
-    [[-49.42407001323204696064, -15.67605088949303393520], [-49.30706235399220815907, -15.81529674600091794900]],
-    [[-48.16645938811709015681, -15.86317173589183227023], [-49.05727291218684626983, -15.48661638542171203881]]
+    [
+      [-49.303317158650124, -14.680936297108701],
+      [-49.454288844276434, -14.655657696589124],
+      [-49.57891661679625, -14.744536129416353],
+      [-49.60419521731582, -14.895507815042663],
+      [-49.42407001323205, -15.676050889493034],
+      [-49.30706235399221, -15.815296746000918],
+      [-46.00505780290427, -17.211085479998047],
+      [-45.859397037232526, -17.21502856394237],
+      [-45.74972032664388, -17.119093034957913],
+      [-45.73424573227583, -16.974202926612953],
+      [-45.82118740347841, -16.8572681055562]
+    ],
+    [
+      [-48.16645938811709, -15.863171735891832],
+      [-49.057272912186846, -15.486616385421712],
+      [-49.10586702080816, -15.276041773521108]
+    ]
   ])
   const d = geom2.create([
-    [[-49.03431352173912216585, -15.58610714407888764299], [-49.21443872582289458251, -14.80556406962851667686]],
-    [[-68.31614651314507113966, -3.10790373951434872879], [-49.34036769611472550423, -15.79733157434056778357]],
-    [[-49.58572929483430868913, -14.97552686612213790340], [-49.53755741140093959984, -15.18427183431472826669]],
-    [[-49.53755741140093959984, -15.18427183431472826669], [-54.61235529924312714911, -11.79066769321313756791]],
-    [[-49.30227466841120076424, -14.68159232649114187552], [-68.09792828135776687759, -2.77270756611528668145]],
-    [[-49.21443872582289458251, -14.80556406962851667686], [-49.30227466841120076424, -14.68159232649114187552]],
-    [[-49.34036769611472550423, -15.79733157434056778357], [-49.18823337756091262918, -15.82684012194931710837]],
-    [[-49.18823337756091262918, -15.82684012194931710837], [-49.06069007212390431505, -15.73881563386780157998]],
-    [[-49.06069007212390431505, -15.73881563386780157998], [-49.03431352173912216585, -15.58610714407888764299]],
-    [[-68.09792828135776687759, -2.77270756611528668145], [-68.24753735887460948106, -2.74623350179570024920]],
-    [[-68.24753735887460948106, -2.74623350179570024920], [-68.37258141465594007968, -2.83253376987636329432]],
-    [[-68.37258141465594007968, -2.83253376987636329432], [-68.40089829889257089235, -2.98180502037078554167]],
-    [[-68.40089829889257089235, -2.98180502037078554167], [-68.31614651314507113966, -3.10790373951434872879]],
-    [[-54.61235529924312714911, -11.79066769321313756791], [-49.58572929483430868913, -14.97552686612213790340]]
+    [
+      [-49.214438725822895, -14.805564069628517],
+      [-49.3022746684112, -14.681592326491142],
+      [-68.09792828135777, -2.7727075661152867],
+      [-68.24753735887461, -2.7462335017957002],
+      [-68.37258141465594, -2.8325337698763633],
+      [-68.40089829889257, -2.9818050203707855],
+      [-68.31614651314507, -3.1079037395143487],
+      [-49.340367696114726, -15.797331574340568],
+      [-49.18823337756091, -15.826840121949317],
+      [-49.060690072123904, -15.738815633867802],
+      [-49.03431352173912, -15.586107144078888]
+    ],
+    [
+      [-49.53755741140094, -15.184271834314728],
+      [-54.61235529924313, -11.790667693213138],
+      [-49.58572929483431, -14.975526866122138]
+    ]
   ])
-  // geom2.toOutlines(c)
-  // geom2.toOutlines(d)
 
-  const obs = union(c, d)
-  // const outlines = geom2.toOutlines(obs)
-  const pts = geom2.toPoints(obs)
+  const result = union(c, d)
+  const pts = geom2.toPoints(result)
   const exp = [
-    [-49.10585516965137, -15.276000175919414],
-    [-49.0573272145917, -15.486679335654257],
-    [-49.307011370463215, -15.815286644243773],
-    [-46.00502320253235, -17.211117609669667],
-    [-45.85943933735334, -17.215031154432545],
-    [-45.74972963250071, -17.119149307742074],
-    [-45.734205904941305, -16.974217700023555],
-    [-48.166473975068946, -15.86316234184296],
-    [-49.318621553259746, -15.801589237573706],
-    [-49.585786209072104, -14.975570389622606],
-    [-68.31614189569036, -3.1078763476921982],
-    [-49.53751915699663, -15.184292776976012],
-    [-68.09789654941396, -2.7727464644978874],
-    [-68.24752441084793, -2.7462648116024244],
-    [-68.37262739176788, -2.8324932478777995],
-    [-68.40093536555268, -2.98186020632758],
-    [-54.61234310251047, -11.79072766159384],
-    [-49.30335872868453, -14.680880468978017],
-    [-49.34040695243976, -15.797284338334542],
-    [-45.82121705016925, -16.857333163105647]
+    [-68.40089829889257, -2.9818050203707855],
+    [-68.31614651314507, -3.1079037395143487],
+    [-49.340367696114726, -15.797331574340568],
+    [-49.318612612739564, -15.801551272562577],
+    [-49.30706235399221, -15.815296746000918],
+    [-46.00505780290427, -17.211085479998047],
+    [-45.859397037232526, -17.21502856394237],
+    [-45.74972032664388, -17.119093034957913],
+    [-45.73424573227583, -16.974202926612953],
+    [-45.82118740347841, -16.8572681055562],
+    [-49.302794903461326, -14.68126270670841],
+    [-68.09792828135777, -2.7727075661152867],
+    [-68.24753735887461, -2.7462335017957002],
+    [-68.37258141465594, -2.8325337698763633],
+    [-49.58572929483431, -14.975526866122138],
+    [-49.53755741140094, -15.184271834314728],
+    [-54.61235529924313, -11.790667693213138],
+    [-48.16645938811709, -15.863171735891832],
+    [-49.057272912186846, -15.486616385421712],
+    [-49.10586702080816, -15.276041773521108]
   ]
-  t.notThrows(() => geom2.validate(obs))
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 17.56120670215806)
   t.is(pts.length, 20) // number of sides in union
   t.true(comparePoints(pts, exp))
 })
+
+test('union of geom2 with colinear edge (martinez issue #155)', (t) => {
+  // This test is a minimal example extracted from:
+  // project({ axis: [0, 1, 0], origin: [0, -1, 0] }, torus({ innerSegments: 8, outerSegments: 4 }))
+  const g1 = geom2.create([[
+    [-5, 0],
+    [4.707106781186547, 0.7071067811865477],
+    [3.477592250072517, 0.7836116248912244],
+    [4, 1]
+  ]])
+  const g2 = geom2.create([[
+    [4.707106781186547, 0.7071067811865477],
+    [4, 1],
+    [0, 1]
+  ]])
+  const exp = [
+    [-5, 0],
+    [4.707106781186547, 0.7071067811865477],
+    [4, 1],
+    [0, 1],
+    [2.564081902288895, 0.8404535446987661]
+  ]
+  const result = union(g1, g2)
+  const pts = geom2.toPoints(result)
+  t.notThrows(() => geom2.validate(result))
+  t.is(measureArea(result), 1.9906657858562764)
+  t.is(pts.length, 5)
+  t.true(comparePoints(pts, exp))
+})

package/src/operations/booleans/unionGeom3.js

@@ -1,25 +1,23 @@
-const flatten = require('../../utils/flatten')
+import { flatten } from '../../utils/flatten.js'
 
-const retessellate = require('../modifiers/retessellate')
+import { retessellate } from '../modifiers/retessellate.js'
 
-const unionSub = require('./unionGeom3Sub')
+import { unionGeom3Sub } from './unionGeom3Sub.js'
 
 /*
  * Return a new 3D geometry representing the space in the given 3D geometries.
  * @param {...objects} geometries - list of geometries to union
- * @returns {geom3} new 3D geometry
+ * @returns {Geom3} new 3D geometry
  */
-const union = (...geometries) => {
+export const unionGeom3 = (...geometries) => {
   geometries = flatten(geometries)
 
   // combine geometries in a way that forms a balanced binary tree pattern
   let i
   for (i = 1; i < geometries.length; i += 2) {
-    geometries.push(unionSub(geometries[i - 1], geometries[i]))
+    geometries.push(unionGeom3Sub(geometries[i - 1], geometries[i]))
   }
-  let newgeometry = geometries[i - 1]
-  newgeometry = retessellate(newgeometry)
-  return newgeometry
+  let newGeometry = geometries[i - 1]
+  newGeometry = retessellate(newGeometry)
+  return newGeometry
 }
-
-module.exports = union