@jscad/modeling 3.0.3-alpha.0 → 3.0.5-alpha.0

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/index.js

@@ -1,8 +1,10 @@
 /**
  * All shapes (primitives or the results of operations) can be passed to boolean functions
  * to perform logical operations, e.g. remove a hole from a board.
+ *
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/booleans
+ *
  * @example
  * import { intersect, scission, subtract, union } from '@jscad/modeling'
  */

package/src/operations/booleans/intersect.js

@@ -6,7 +6,6 @@ import * as geom3 from '../../geometries/geom3/index.js'
 
 import { intersectGeom2 } from './intersectGeom2.js'
 import { intersectGeom3 } from './intersectGeom3.js'
-
 /**
  * Return a new geometry representing space in both the first geometry and
  * all subsequent geometries.

package/src/operations/booleans/scission.js

@@ -1,7 +1,6 @@
 import * as geom3 from '../../geometries/geom3/index.js'
 
 import { scissionGeom3 } from './scissionGeom3.js'
-
 /**
  * Scission (divide) the given geometry into the component pieces.
  *

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

@@ -4,10 +4,7 @@ export const splitLineSegmentByPlane = (plane, p1, p2) => {
   const direction = vec3.subtract(vec3.create(), p2, p1)
   let lambda = (plane[3] - vec3.dot(plane, p1)) / vec3.dot(plane, direction)
 
-  Number.isNaN(lambda) ? lambda = 0
-    : lambda > 1 ? lambda = 1
-      : lambda < 0 ? lambda = 0
-        : lambda
+  Number.isNaN(lambda) ? lambda = 0 : lambda > 1 ? lambda = 1 : lambda < 0 ? lambda = 0 : lambda
 
   vec3.scale(direction, direction, lambda)
   vec3.add(direction, p1, direction)

package/src/operations/booleans/trees/splitPolygonByPlane.d.ts

@@ -28,6 +28,4 @@ interface SplitRes
 // In case the polygon is spanning, returns:
 // .front: a Polygon3 of the front part
 // .back: a Polygon3 of the back part
-declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;
-
-export default splitPolygonByPlane;
+export declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;

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

@@ -0,0 +1,138 @@
+import test from 'ava'
+
+import { poly3 } from '../../../geometries/index.js'
+import { plane } from '../../../maths/index.js'
+
+import { splitPolygonByPlane } from './splitPolygonByPlane.js'
+
+test('splitPolygonByPlane: test coplanar-front polygon returns type 0.', (t) => {
+  // Polygon in XY plane at z=0
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
+  // Plane is also XY plane at z=0, normal pointing up
+  const splane = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 0) // coplanar-front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in front returns type 2.', (t) => {
+  // Polygon at z=5
+  const polygon = poly3.create([[0, 0, 5], [1, 0, 5], [1, 1, 5], [0, 1, 5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 2) // front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in back returns type 3.', (t) => {
+  // Polygon at z=-5
+  const polygon = poly3.create([[0, 0, -5], [1, 0, -5], [1, 1, -5], [0, 1, -5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 3) // back
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test spanning polygon returns type 4 with front and back.', (t) => {
+  // Polygon spanning z=0 plane (from z=-1 to z=1)
+  const polygon = poly3.create([[0, 0, -1], [1, 0, -1], [1, 0, 1], [0, 0, 1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Front polygon should have z >= 0
+  const frontPoints = poly3.toVertices(result.front)
+  t.true(frontPoints.length >= 3)
+  frontPoints.forEach((p) => {
+    t.true(p[2] >= -1e-5, `front point z=${p[2]} should be >= 0`)
+  })
+
+  // Back polygon should have z <= 0
+  const backPoints = poly3.toVertices(result.back)
+  t.true(backPoints.length >= 3)
+  backPoints.forEach((p) => {
+    t.true(p[2] <= 1e-5, `back point z=${p[2]} should be <= 0`)
+  })
+})
+
+test('splitPolygonByPlane: test duplicate vertices are removed from split result.', (t) => {
+  // Create a polygon that when split would produce duplicate vertices
+  // Triangle with one vertex on the plane
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 1], [1, 0, -1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+
+  // Verify no consecutive duplicate vertices in front
+  if (result.front) {
+    const frontPoints = poly3.toVertices(result.front)
+    for (let i = 0; i < frontPoints.length; i++) {
+      const curr = frontPoints[i]
+      const next = frontPoints[(i + 1) % frontPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'front polygon should not have duplicate consecutive vertices')
+    }
+  }
+
+  // Verify no consecutive duplicate vertices in back
+  if (result.back) {
+    const backPoints = poly3.toVertices(result.back)
+    for (let i = 0; i < backPoints.length; i++) {
+      const curr = backPoints[i]
+      const next = backPoints[(i + 1) % backPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'back polygon should not have duplicate consecutive vertices')
+    }
+  }
+})
+
+test('splitPolygonByPlane: test complex spanning polygon splits correctly.', (t) => {
+  // Hexagon spanning the XY plane
+  const polygon = poly3.create([
+    [1, 0, -1],
+    [0.5, 0.866, -1],
+    [-0.5, 0.866, 1],
+    [-1, 0, 1],
+    [-0.5, -0.866, 1],
+    [0.5, -0.866, -1]
+  ])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Both resulting polygons should be valid (at least 3 vertices)
+  const frontPoints = poly3.toVertices(result.front)
+  const backPoints = poly3.toVertices(result.back)
+  t.true(frontPoints.length >= 3, 'front polygon should have at least 3 vertices')
+  t.true(backPoints.length >= 3, 'back polygon should have at least 3 vertices')
+})

package/src/operations/booleans/union.js

@@ -37,7 +37,7 @@ export const union = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return unionPath(matrix, geometries)
+  // TODO if (path2.isA(geometry)) return unionPath(geometries)
   if (geom2.isA(geometry)) return unionGeom2(geometries)
   if (geom3.isA(geometry)) return unionGeom3(geometries)
   throw new Error('union unsupported geometry type')