@jscad/modeling 3.0.4-alpha.0 → 3.0.6-alpha.0

package/src/geometries/poly2/type.d.ts

@@ -1,7 +1,3 @@
 import type { Vec2 } from '../../maths/vec2/type.d.ts'
 
-export declare interface Poly2 {
-  points: Array<Vec2>
-}
-
-export default Poly2
+export declare interface Poly2 { points: Array<Vec2> }

package/src/geometries/slice/earcut/index.js

@@ -28,8 +28,10 @@ export const triangulate = (data, holeIndices, dim = 2) => {
 
   // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
   if (data.length > 80 * dim) {
-    minX = maxX = data[0]
-    minY = maxY = data[1]
+    minX = data[0]
+    maxX = data[0]
+    minY = data[1]
+    maxY = data[1]
 
     for (let i = dim; i < outerLen; i += dim) {
       const x = data[i]

package/src/geometries/slice/earcut/linkedPolygon.js

@@ -39,7 +39,8 @@ export const filterPoints = (start, end) => {
 
     if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
       removeNode(p)
-      p = end = p.prev
+      p = p.prev
+      end = p.prev
       if (p === p.next) break
       again = true
     } else {
@@ -68,7 +69,8 @@ export const cureLocalIntersections = (start, triangles, dim) => {
       removeNode(p)
       removeNode(p.next)
 
-      p = start = b
+      p = b
+      start = b
     }
 
     p = p.next

package/src/geometries/slice/fromOutlines.d.ts

@@ -0,0 +1,5 @@
+import type { Vec2 } from '../../maths/types.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+export function fromOutlines(outlines: Array<Array<Vec2>>): Slice

package/src/geometries/slice/fromOutlines.js

@@ -0,0 +1,16 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a slice from the given outlines.
+ *
+ * @param {Array} outlines - where each outline is an array of ordered points
+ * @returns {Slice} a new slice
+ * @alias module:modeling/slice.fromOutlines
+ */
+export const fromOutlines = (outlines) => {
+  // Convert from 2D points to 3D vertices
+  const contours = outlines.map((outline) => outline.map((point) => vec3.fromVec2(vec3.create(), point)))
+  return create(contours)
+}

package/src/geometries/slice/fromOutlines.test.js

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { fromOutlines } from './index.js'
+
+test('slice: fromOutlines() should return a new slice with correct values', (t) => {
+  const exp1 = {
+    contours: [
+      [[0, 0, 0], [1, 0, 0], [1, 1, 0]],
+      [[2, 2, 0], [3, 1, 0], [3, 3, 0]]
+    ]
+  }
+  const obs1 = fromOutlines([
+    [[0, 0], [1, 0], [1, 1]],
+    [[2, 2], [3, 1], [3, 3]]
+  ])
+  t.deepEqual(obs1, exp1)
+})

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

@@ -2,7 +2,7 @@ export { calculatePlane } from './calculatePlane.js'
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { equals } from './equals.js'
-export { fromGeom2 } from './fromGeom2.js'
+export { fromOutlines } from './fromOutlines.js'
 export { fromVertices } from './fromVertices.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/slice/index.js

@@ -26,7 +26,7 @@ export { calculatePlane } from './calculatePlane.js'
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { equals } from './equals.js'
-export { fromGeom2 } from './fromGeom2.js'
+export { fromOutlines } from './fromOutlines.js'
 export { fromVertices } from './fromVertices.js'
 export { isA } from './isA.js'
 export { reverse } from './reverse.js'

package/src/geometries/slice/transform.js

@@ -16,5 +16,6 @@ import { create } from './create.js'
  */
 export const transform = (matrix, slice) => {
   const contours = slice.contours.map((contour) => contour.map((vertex) => vec3.transform(vec3.create(), vertex, matrix)))
-  return create(contours)
+  // use Object.assign in order to assign EXTRA attributes like color, name, etc
+  return Object.assign({}, slice, { contours })
 }

package/src/maths/line2/intersectPointOfLines.js

@@ -14,7 +14,4 @@ import { solve2Linear } from '../utils/solve2Linear.js'
  * @return {Vec2} the point of intersection
  * @alias module:modeling/maths/line2.intersectPointOfLines
  */
-export const intersectPointOfLines = (line1, line2) => {
-  const point = solve2Linear(line1[0], line1[1], line2[0], line2[1], line1[2], line2[2])
-  return vec2.clone(point)
-}
+export const intersectPointOfLines = (line1, line2) => solve2Linear(line1[0], line1[1], line2[0], line2[1], line1[2], line2[2])

package/src/maths/plane/fromNormalAndPoint.js

@@ -18,12 +18,10 @@ import * as vec3 from '../vec3/index.js'
  * @alias module:modeling/maths/plane.fromNormalAndPoint
  */
 export const fromNormalAndPoint = (out, normal, point) => {
-  const u = vec3.normalize(vec3.create(), normal)
-  const w = vec3.dot(point, u)
+  // normalize to out
+  vec3.normalize(out, normal)
+  // calculate distance
+  out[3] = vec3.dot(point, out)
 
-  out[0] = u[0]
-  out[1] = u[1]
-  out[2] = u[2]
-  out[3] = w
   return out
 }

package/src/maths/plane/fromPoints.js

@@ -1,10 +1,13 @@
 import * as vec3 from '../vec3/index.js'
 
+const ba = vec3.create()
+const ca = vec3.create()
+
 /**
  * Create a plane from the given points.
  *
  * @param {Plane} out - receiving plane
- * @param {Array} vertices - points on the plane
+ * @param {Array} vertices - list of points on the plane
  * @returns {Plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */
@@ -13,8 +16,6 @@ export const fromPoints = (out, ...vertices) => {
 
   // Calculate normal vector for a single vertex
   // Inline to avoid allocations
-  const ba = vec3.create()
-  const ca = vec3.create()
   const vertexNormal = (index) => {
     const a = vertices[index]
     const b = vertices[(index + 1) % len]
@@ -26,18 +27,18 @@ export const fromPoints = (out, ...vertices) => {
     return ba
   }
 
-  out[0] = 0
-  out[1] = 0
-  out[2] = 0
   if (len === 3) {
     // optimization for triangles, which are always coplanar
     vec3.copy(out, vertexNormal(0))
   } else {
     // sum of vertex normals
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
     vertices.forEach((v, i) => {
       vec3.add(out, out, vertexNormal(i))
     })
-    // renormalize normal vector
+    // normalize sum
     vec3.normalize(out, out)
   }
   out[3] = vec3.dot(out, vertices[0])

package/src/maths/plane/fromPointsRandom.js

@@ -15,26 +15,26 @@ import * as vec3 from '../vec3/index.js'
  * @alias module:modeling/maths/plane.fromPointsRandom
  */
 export const fromPointsRandom = (out, a, b, c) => {
-  let ba = vec3.subtract(vec3.create(), b, a)
-  let ca = vec3.subtract(vec3.create(), c, a)
+  const ba = vec3.subtract(vec3.create(), b, a)
+  const ca = vec3.subtract(vec3.create(), c, a)
   if (vec3.length(ba) < EPS) {
-    ba = vec3.orthogonal(ba, ca)
+    vec3.orthogonal(ba, ca)
   }
   if (vec3.length(ca) < EPS) {
-    ca = vec3.orthogonal(ca, ba)
+    vec3.orthogonal(ca, ba)
   }
-  let normal = vec3.cross(vec3.create(), ba, ca)
+
+  // calculate plane normal
+  const normal = vec3.cross(out, ba, ca)
   if (vec3.length(normal) < EPS) {
     // this would mean that ba == ca.negated()
-    ca = vec3.orthogonal(ca, ba)
-    normal = vec3.cross(normal, ba, ca)
+    vec3.orthogonal(ca, ba)
+    vec3.cross(normal, ba, ca)
   }
-  normal = vec3.normalize(normal, normal)
-  const w = vec3.dot(normal, a)
+  vec3.normalize(normal, normal)
+
+  // and distance
+  out[3] = vec3.dot(normal, a)
 
-  out[0] = normal[0]
-  out[1] = normal[1]
-  out[2] = normal[2]
-  out[3] = w
   return out
 }

package/src/measurements/measureAggregateEpsilon.js

@@ -3,6 +3,8 @@ import { flatten } from '../utils/flatten.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
+import * as slice from '../geometries/slice/index.js'
 
 import { measureAggregateBoundingBox } from './measureAggregateBoundingBox.js'
 import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
@@ -23,7 +25,7 @@ export const measureAggregateEpsilon = (...geometries) => {
   let dimensions = 0
   dimensions = geometries.reduce((dimensions, geometry) => {
     if (path2.isA(geometry) || geom2.isA(geometry)) return Math.max(dimensions, 2)
-    if (geom3.isA(geometry)) return Math.max(dimensions, 3)
+    if (geom3.isA(geometry || path3.isA(geometry) || slice.isA(geometry))) return Math.max(dimensions, 3)
     return 0
   }, dimensions)
   return calculateEpsilonFromBounds(bounds, dimensions)

package/src/measurements/measureAggregateEpsilon.test.js

@@ -13,7 +13,7 @@ test('measureAggregateEpsilon (single objects)', (t) => {
   t.is(calculatedEpsilon, expectedEpsilon)
 })
 
-test('measureAggregateEpsilon (multiple objects)', (t) => {
+test('measureAggregateEpsilon (multiple 3D objects)', (t) => {
   const highCube = cube({ size: 4, center: [-40, 100, 20] })
   const lowCube = cube({ size: 60, center: [20, -10, 20] })
   const calculatedEpsilon = measureAggregateEpsilon(highCube, lowCube)

package/src/measurements/measureArea.js

@@ -3,6 +3,7 @@ import { flatten } from '../utils/flatten.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -12,10 +13,10 @@ const cache = new WeakMap()
  * Measure the area of the given geometry.
  * NOTE: paths are infinitely narrow and do not have an area
  *
- * @param {Path2} geometry - geometry to measure
+ * @param {Path2|Path3} geometry - geometry to measure
  * @returns {number} area of the geometry
  */
-const measureAreaOfPath2 = () => 0
+const measureAreaOfPath = () => 0
 
 /*
  * Measure the area of the given geometry.
@@ -87,9 +88,10 @@ export const measureArea = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureAreaOfPath2(geometry)
-    if (geom2.isA(geometry)) return measureAreaOfGeom2(geometry)
     if (geom3.isA(geometry)) return measureAreaOfGeom3(geometry)
+    if (geom2.isA(geometry)) return measureAreaOfGeom2(geometry)
+    if (path2.isA(geometry)) return measureAreaOfPath(geometry)
+    if (path3.isA(geometry)) return measureAreaOfPath(geometry)
     if (slice.isA(geometry)) return measureAreaOfSlice(geometry)
     return 0
   })

package/src/measurements/measureArea.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, cuboid } from '../primitives/index.js'
 
@@ -12,6 +12,7 @@ test('measureArea: single objects', (t) => {
   const acube = cuboid()
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -25,6 +26,7 @@ test('measureArea: single objects', (t) => {
   const carea = measureArea(acube)
 
   const p2area = measureArea(apath2)
+  const p3area = measureArea(apath3)
   const g2area = measureArea(ageom2)
   const g3area = measureArea(ageom3)
   const slarea = measureArea(aslice)
@@ -38,6 +40,7 @@ test('measureArea: single objects', (t) => {
   t.is(carea, 24) // 2x2x6
 
   t.is(p2area, 0)
+  t.is(p3area, 0)
   t.is(g2area, 0)
   t.is(g3area, 0)
   t.is(slarea, 0)

package/src/measurements/measureBoundingBox.js

@@ -6,6 +6,7 @@ import * as vec3 from '../maths/vec3/index.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -70,6 +71,18 @@ const measureBoundingBoxOfPath2 = (geometry) => {
   return boundingBox
 }
 
+/*
+ * Measure the min and max bounds of the given (path3) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
+ */
+const measureBoundingBoxOfPath3 = (geometry) => {
+  const boundingBox = []
+  path3.toVertices(geometry).forEach((vertice) => {
+    expand3(boundingBox, vertice)
+  })
+  return boundingBox
+}
+
 /*
  * Measure the min and max bounds of the given (geom2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
@@ -123,9 +136,10 @@ export const measureBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)
-    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom2)
     if (geom3.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom3)
+    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfGeom2)
+    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)
+    if (path3.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath3)
     if (slice.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfSlice)
     return [[0, 0, 0], [0, 0, 0]]
   })

package/src/measurements/measureBoundingBox.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, cuboid } from '../primitives/index.js'
 
@@ -14,6 +14,7 @@ test('measureBoundingBox (single objects)', (t) => {
   const acube = cuboid()
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -27,6 +28,7 @@ test('measureBoundingBox (single objects)', (t) => {
   const cbounds = measureBoundingBox(acube)
 
   const p2bounds = measureBoundingBox(apath2)
+  const p3bounds = measureBoundingBox(apath3)
   const g2bounds = measureBoundingBox(ageom2)
   const g3bounds = measureBoundingBox(ageom3)
   const slbounds = measureBoundingBox(aslice)
@@ -40,6 +42,7 @@ test('measureBoundingBox (single objects)', (t) => {
   t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
 
   t.deepEqual(p2bounds, [[0, 0, 0], [0, 0, 0]])
+  t.deepEqual(p3bounds, [[0, 0, 0], [0, 0, 0]])
   t.deepEqual(g2bounds, [[0, 0, 0], [0, 0, 0]])
   t.deepEqual(g3bounds, [[0, 0, 0], [0, 0, 0]])
   t.deepEqual(slbounds, [[0, 0, 0], [0, 0, 0]])

package/src/measurements/measureBoundingSphere.js

@@ -6,6 +6,7 @@ import * as vec3 from '../maths/vec3/index.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as poly3 from '../geometries/poly3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
@@ -60,6 +61,33 @@ const measureBoundingSphereOfPoints = (points) => {
   return [centroid, radius]
 }
 
+/*
+ * Measure the bounding sphere of the given 2D points.
+ * @return {[[x, y, z], radius]} the bounding sphere for the points
+ */
+const measureBoundingSphereOfVertices = (vertices) => {
+  const centroid = vec3.create()
+  let radius = 0
+
+  if (vertices.length > 0) {
+    // calculate the centroid of the vertices
+    let numVertices = 0
+    vertices.forEach((vertex) => {
+      vec3.add(centroid, centroid, vertex)
+      numVertices++
+    })
+    vec3.scale(centroid, centroid, 1 / numVertices)
+
+    // find the farthest vertex from the centroid
+    vertices.forEach((vertex) => {
+      radius = Math.max(radius, vec3.squaredDistance(centroid, vertex))
+    })
+    radius = Math.sqrt(radius)
+  }
+
+  return [centroid, radius]
+}
+
 /*
  * Measure the bounding sphere of the given (path2) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
@@ -106,36 +134,16 @@ const measureBoundingSphereOfGeom3 = (geometry) => {
 }
 
 /*
- * Measure the bounding sphere of the given (geom3) geometry.
+ * Measure the bounding sphere of the given (slice) geometry.
  * @return {[[x, y, z], radius]} the bounding sphere for the geometry
  */
-const measureBoundingSphereOfSlice = (geometry) => {
-  const centroid = vec3.create()
-  let radius = 0
-  let numVertices = 0
+const measureBoundingSphereOfPath3 = (geometry) => measureBoundingSphereOfVertices(path3.toVertices(geometry))
 
-  // calculate the centroid of the geometry
-  geometry.contours.forEach((contour) => {
-    contour.forEach((vertex) => {
-      vec3.add(centroid, centroid, vertex)
-      numVertices++
-    })
-  })
-
-  if (numVertices > 0) {
-    vec3.scale(centroid, centroid, 1 / numVertices)
-
-    // find the farthest vertex from the centroid
-    geometry.contours.forEach((contour) => {
-      contour.forEach((vertex) => {
-        radius = Math.max(radius, vec3.squaredDistance(centroid, vertex))
-      })
-    })
-    radius = Math.sqrt(radius)
-  }
-
-  return [centroid, radius]
-}
+/*
+ * Measure the bounding sphere of the given (slice) geometry.
+ * @return {[[x, y, z], radius]} the bounding sphere for the geometry
+ */
+const measureBoundingSphereOfSlice = (geometry) => measureBoundingSphereOfVertices(slice.toVertices(geometry))
 
 /**
  * Measure the (approximate) bounding sphere of the given geometries.
@@ -151,9 +159,10 @@ export const measureBoundingSphere = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath2)
-    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom2)
     if (geom3.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom3)
+    if (geom2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfGeom2)
+    if (path2.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath2)
+    if (path3.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfPath3)
     if (slice.isA(geometry)) return measureCached(geometry, measureBoundingSphereOfSlice)
     return [[0, 0, 0], 0]
   })

package/src/measurements/measureBoundingSphere.test.js

@@ -1,6 +1,6 @@
 import test from 'ava'
 
-import { geom2, geom3, path2, slice } from '../geometries/index.js'
+import { geom2, geom3, path2, path3, slice } from '../geometries/index.js'
 
 import { line, rectangle, ellipsoid } from '../primitives/index.js'
 
@@ -12,6 +12,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   const aellipsoid = ellipsoid({ radius: [5, 10, 15], center: [5, 5, 5] })
 
   const apath2 = path2.create()
+  const apath3 = path3.create()
   const ageom2 = geom2.create()
   const ageom3 = geom3.create()
   const aslice = slice.create()
@@ -25,6 +26,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   const cbounds = measureBoundingSphere(aellipsoid)
 
   const p2bounds = measureBoundingSphere(apath2)
+  const p3bounds = measureBoundingSphere(apath3)
   const g2bounds = measureBoundingSphere(ageom2)
   const g3bounds = measureBoundingSphere(ageom3)
   const slbounds = measureBoundingSphere(aslice)
@@ -38,6 +40,7 @@ test('measureBoundingSphere (single objects)', (t) => {
   t.deepEqual(cbounds, [[5.000000000000018, 4.999999999999983, 5.000000000000001], 15])
 
   t.deepEqual(p2bounds, [[0, 0, 0], 0])
+  t.deepEqual(p3bounds, [[0, 0, 0], 0])
   t.deepEqual(g2bounds, [[0, 0, 0], 0])
   t.deepEqual(g3bounds, [[0, 0, 0], 0])
   t.deepEqual(slbounds, [[0, 0, 0], 0])

package/src/measurements/measureCenterOfMass.js

@@ -95,9 +95,10 @@ export const measureCenterOfMass = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    // NOTE: center of mass for geometry path2 is not possible
-    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
     if (geom3.isA(geometry)) return measureCenterOfMassGeom3(geometry)
+    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
+    // TODO if (slice.isA(geometry)) return measureCenterOfMassSlice(geometry)
+    // NOTE: center of mass for geometry path2 and path3 is not possible
     return [0, 0, 0]
   })
   return results.length === 1 ? results[0] : results

package/src/measurements/measureEpsilon.js

@@ -3,6 +3,7 @@ import { flatten } from '../utils/flatten.js'
 import * as geom2 from '../geometries/geom2/index.js'
 import * as geom3 from '../geometries/geom3/index.js'
 import * as path2 from '../geometries/path2/index.js'
+import * as path3 from '../geometries/path3/index.js'
 import * as slice from '../geometries/slice/index.js'
 
 import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
@@ -22,9 +23,10 @@ export const measureEpsilon = (...geometries) => {
   geometries = flatten(geometries)
 
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-    if (geom2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
     if (geom3.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
+    if (geom2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+    if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
+    if (path3.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
     if (slice.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
     return 0
   })

package/src/operations/booleans/martinez/computeFields.js

@@ -70,6 +70,8 @@ const inResult = (event, operation) => {
                   (!event.isSubject && !event.otherInOut)
         case XOR:
           return true
+        default:
+          throw new Error('computeFields01')
       }
       break
     case SAME_TRANSITION:
@@ -78,6 +80,8 @@ const inResult = (event, operation) => {
       return operation === DIFFERENCE
     case NON_CONTRIBUTING:
       return false
+    default:
+      throw new Error('computeFields02')
   }
   return false
 }
@@ -104,6 +108,8 @@ const determineResultTransition = (event, operation) => {
         isIn = thatIn && !thisIn
       }
       break
+    default:
+      throw new Error('computeFields03')
   }
   return isIn ? +1 : -1
 }

package/src/operations/booleans/martinez/divideSegment.js

@@ -12,7 +12,8 @@ export const divideSegment = (segment, point, queue) => {
   const r = new SweepEvent(point, false, segment, segment.isSubject)
   const l = new SweepEvent(point, true, segment.otherEvent, segment.isSubject)
 
-  r.contourId = l.contourId = segment.contourId
+  r.contourId = segment.contourId
+  l.contourId = segment.contourId
 
   // avoid a rounding error. The left event would be processed after the right event
   if (compareEvents(l, segment.otherEvent) > 0) {

package/src/operations/booleans/martinez/fillQueue.js

@@ -25,7 +25,9 @@ const processPolygon = (contourOrHole, isSubject, ringId, queue, bbox, isExterio
       continue // skip collapsed edges, or it breaks
     }
 
-    e1.contourId = e2.contourId = ringId
+    e1.contourId = ringId
+    e2.contourId = ringId
+
     if (!isExteriorRing) {
       e1.isExteriorRing = false
       e2.isExteriorRing = false

package/src/operations/booleans/martinez/subdivideSegments.js

@@ -32,14 +32,14 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
     }
 
     if (event.left) {
-      next = prev = sweepLine.insert(event)
+      prev = sweepLine.insert(event)
       begin = sweepLine.minNode()
 
+      next = sweepLine.next(prev)
+
       if (prev !== begin) prev = sweepLine.prev(prev)
       else prev = null
 
-      next = sweepLine.next(next)
-
       const prevEvent = prev ? prev.key : null
       let prevprevEvent
       computeFields(event, prevEvent, operation)
@@ -62,7 +62,8 @@ export const subdivideSegments = (eventQueue, subject, clipping, sbbox, cbbox, o
         }
       }
     } else {
-      next = prev = sweepLine.find(event.otherEvent)
+      prev = sweepLine.find(event.otherEvent)
+      next = prev
 
       if (prev && next) {
         // FIXME is this correct? begin is assigned if event.left, not every iterration

package/src/operations/booleans/subtractGeom3Sub.js

@@ -13,7 +13,7 @@ import { mayOverlap } from './mayOverlap.js'
  */
 export const subtractGeom3Sub = (geometry1, geometry2) => {
   if (!mayOverlap(geometry1, geometry2)) {
-    return geom3.clone(geometry1)
+    return geometry1
   }
 
   const a = new Tree(geom3.toPolygons(geometry1))

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

@@ -215,6 +215,9 @@ export class PolygonTreeNode {
           backNodes.push(backNode)
         }
         break
+
+      default:
+        throw new Error('PolygonTreeNode05')
     }
   }