@jscad/modeling 3.0.0-alpha.0 → 3.0.1-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.1-alpha.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -64,5 +64,5 @@
     "rollup": "^2.79.1",
     "rollup-plugin-banner": "^0.2.1"
   },
-  "gitHead": "3656d36ed9cd738ab884e86aae5a2ce08d52adf7"
+  "gitHead": "0660b5c1f1a5faf54d4cfae1cb85bb94182a8d32"
 }

package/rollup.config.js

@@ -16,6 +16,6 @@ export default {
   ],
   plugins: [
     banner('<%= pkg.description %>\n@module <%= pkg.name %>\n@version <%= pkg.version %>\n@license <%= pkg.license %>'),
-    terser({ compress: { module: true }, mangle: false, format: { comments: 'some'} })
+    terser({ compress: { module: true }, mangle: false, format: { comments: 'some' } })
   ]
 }

package/src/colors/colorize.js

@@ -1,5 +1,3 @@
-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'
@@ -47,14 +45,12 @@ export const colorize = (color, ...objects) => {
   if (color.length < 3) throw new Error('color must contain R, G and B values')
   if (color.length === 3) color = [color[0], color[1], color[2], 1.0] // add alpha
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     if (geom2.isA(object)) return colorGeom2(color, object)
     if (geom3.isA(object)) return colorGeom3(color, object)
     if (path2.isA(object)) return colorPath2(color, object)
     if (poly3.isA(object)) return colorPoly3(color, object)
+    if (Array.isArray(object)) return colorize(color, ...object)
 
     object.color = color
     return object

package/src/colors/colorize.test.js

@@ -11,14 +11,12 @@ test('color (rgb on objects)', (t) => {
   const obs = colorize([1, 0, 0], obj1, obj2)
   const exp1 = { color: [1, 0, 0, 1] }
   const exp2 = { id: 'a', color: [1, 0, 0, 1] }
+  const exp3 = { id: 'b', color: [1, 0, 0, 1] }
 
-  t.is(obs.length, 3)
+  t.is(obs.length, 2)
   t.deepEqual(obs[0], exp1)
-  t.deepEqual(obs[1], exp2)
-
-  const obs3 = colorize([1, 0, 0], obj1)
-  const exp3 = { color: [1, 0, 0, 1] }
-  t.deepEqual(obs3, exp3)
+  t.deepEqual(obs[1][0], exp2)
+  t.deepEqual(obs[1][1], exp3)
 })
 
 test('color (rgba on objects)', (t) => {
@@ -28,10 +26,12 @@ test('color (rgba on objects)', (t) => {
   const obs = colorize([1, 1, 0.5, 0.8], obj1, obj2)
   const exp1 = { color: [1, 1, 0.5, 0.8] }
   const exp2 = { id: 'a', color: [1, 1, 0.5, 0.8] }
+  const exp3 = { id: 'b', color: [1, 1, 0.5, 0.8] }
 
-  t.is(obs.length, 3)
+  t.is(obs.length, 2)
   t.deepEqual(obs[0], exp1)
-  t.deepEqual(obs[1], exp2)
+  t.deepEqual(obs[1][0], exp2)
+  t.deepEqual(obs[1][1], exp3)
 })
 
 test('color (rgba on geometry)', (t) => {

package/src/geometries/geom2/transform.js

@@ -1,5 +1,7 @@
 import * as mat4 from '../../maths/mat4/index.js'
 
+import { reverse } from './reverse.js'
+
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the outlines, as this function only adjusts the transforms.
@@ -14,5 +16,11 @@ import * as mat4 from '../../maths/mat4/index.js'
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
-  return Object.assign({}, geometry, { transforms })
+  const transformed = Object.assign({}, geometry, { transforms })
+  // determine if the transform is mirroring in 2D
+  if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {
+    // reverse the order to preserve the orientation
+    return reverse(transformed)
+  }
+  return transformed
 }

package/src/geometries/geom2/transform.test.js

@@ -2,6 +2,12 @@ import test from 'ava'
 
 import { mat4 } from '../../maths/index.js'
 
+import { measureArea } from '../../measurements/index.js'
+
+import { mirrorX, mirrorY, mirrorZ } from '../../operations/transforms/index.js'
+
+import { square } from '../../primitives/index.js'
+
 import { create, transform, toOutlines, toSides } from './index.js'
 
 import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
@@ -50,3 +56,54 @@ test('transform: adjusts the transforms of geom2', (t) => {
   t.true(comparePoints(another.outlines[0], expected.outlines[0]))
   t.true(compareVectors(another.transforms, expected.transforms))
 })
+
+test('transform: geom2 mirrorX', (t) => {
+  const geometry = square()
+  const transformed = mirrorX(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[1, 1], [-1, 1], [-1, -1], [1, -1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]]
+  ])
+})
+
+test('transform: geom2 mirrorY', (t) => {
+  const geometry = square()
+  const transformed = mirrorY(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})
+
+test('transform: geom2 mirrorZ', (t) => {
+  const geometry = square()
+  const transformed = mirrorZ(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we DIDN'T reverse the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})

package/src/geometries/geom3/fromPointsConvex.d.ts

@@ -0,0 +1,4 @@
+import type { Geom3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export function fromPointsConvex(points: Array<Array<Vec3>>): Geom3

package/src/geometries/geom3/fromPointsConvex.js

@@ -0,0 +1,25 @@
+import { runner } from '../../operations/hulls/quickhull/index.js'
+import { create } from './create.js'
+import * as poly3 from '../poly3/index.js'
+
+/**
+ * Construct a new convex 3D geometry from a list of unique points.
+ *
+ * @param {Array} uniquePoints - list of points to construct convex 3D geometry
+ * @returns {geom3} a new geometry
+ * @alias module:modeling/geometries/geom3.fromPointsConvex
+ */
+export const fromPointsConvex = (uniquePoints) => {
+  if (!Array.isArray(uniquePoints)) {
+    throw new Error('the given points must be an array')
+  }
+
+  const faces = runner(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return create(polygons)
+}

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

@@ -0,0 +1,32 @@
+import test from 'ava'
+
+import { fromPointsConvex, validate } from './index.js'
+
+test('fromPointsConvex (uniquePoints)', (t) => {
+  const out = []
+  for (let x = -9; x <= 9; ++x) {
+    for (let y = -9; y <= 9; ++y) {
+      for (let z = -9; z <= 9; ++z) {
+        if (x * x + y * y + z * z <= 96) {
+          out.push([x, y, z])
+        }
+      }
+    }
+  }
+
+  const obs = fromPointsConvex(out)
+  validate(obs)
+  t.is(obs.polygons.length, 170)
+  t.true(obs.polygons.every((f) => ([3, 4, 8, 9].indexOf(f.vertices.length) !== -1)))
+
+  const c = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  obs.polygons.forEach((f) => c[f.vertices.length]++)
+  t.is(c[3], 120)
+  t.is(c[4], 24)
+  t.is(c[8], 18)
+  t.is(c[9], 8)
+
+  let edges2 = 336 * 2
+  obs.polygons.forEach((f) => { edges2 -= f.vertices.length })
+  t.is(edges2, 0)
+})

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

@@ -1,6 +1,7 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { fromPoints } from './fromPoints.js'
+export { fromPointsConvex } from './fromPointsConvex.js'
 export { fromCompactBinary } from './fromCompactBinary.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'

package/src/geometries/geom3/index.js

@@ -17,6 +17,7 @@
 export { clone } from './clone.js'
 export { create } from './create.js'
 export { fromPoints } from './fromPoints.js'
+export { fromPointsConvex } from './fromPointsConvex.js'
 export { fromCompactBinary } from './fromCompactBinary.js'
 export { invert } from './invert.js'
 export { isA } from './isA.js'

package/src/geometries/index.js

@@ -5,14 +5,13 @@
  * @see {@link geom2} - 2D geometry consisting of 2D outlines
  * @see {@link geom3} - 3D geometry consisting of polygons
  * @see {@link path2} - 2D geometry consisting of ordered points
- * @see {@link poly2} - 2D polygon consisting of ordered vertices
+ * @see {@link poly2} - 2D polygon consisting of ordered points
  * @see {@link poly3} - 3D polygon consisting of ordered vertices
- * @see {@link slice} - 3D geometry consisting of 3D outlines
+ * @see {@link slice} - 3D geometry consisting of 3D contours
  *
  * @module modeling/geometries
  * @example
- * import { geometries } from '@jscad/modeling'
- * const { geom2, geom3, path2, poly2, poly3 } = geometries
+ * import { geom2, geom3, path2, poly2, poly3, slice } from '@jscad/modeling'
  */
 export * as geom2 from './geom2/index.js'
 export * as geom3 from './geom3/index.js'

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

@@ -6,6 +6,6 @@ export interface Poly3 {
   vertices: Array<Vec3>
   color?: Color
 
-  // used internally for caching:
+  // used internally for calculations
   plane?: Plane
 }

package/src/geometries/slice/validate.js

@@ -28,10 +28,9 @@ export const validate = (object) => {
     // contours must be coplanar
     const contourPlane = poly3.plane(poly3.create(contour))
     if (!plane.equals(slicePlane, contourPlane)) {
-      throw new Error(`slice contours must be coplanar`)
+      throw new Error('slice contours must be coplanar')
     }
 
-
     for (let i = 0; i < contour.length; i++) {
       const vertex = contour[i]
       // check for infinity, nan

package/src/maths/index.js

@@ -15,3 +15,4 @@ export * as vec2 from './vec2/index.js'
 export * as vec3 from './vec3/index.js'
 export * as vec4 from './vec4/index.js'
 export { cos, sin } from './utils/trigonometry.js'
+export { area } from './utils/area.js'

package/src/maths/mat4/isOnlyTransformScale.js

@@ -18,7 +18,7 @@ export const isOnlyTransformScale = (matrix) => (
 )
 
 /**
- * @param {number} num 
+ * @param {number} num
  * @returns {boolean}
  */
 const isZero = (num) => Math.abs(num) < Number.EPSILON

package/src/measurements/measureAggregateArea.js

@@ -14,7 +14,6 @@ import { measureArea } from './measureArea.js'
  */
 export const measureAggregateArea = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateArea: no geometries supplied')
   const areas = measureArea(geometries)
   if (geometries.length === 1) {
     return areas

package/src/measurements/measureAggregateBoundingBox.js

@@ -15,7 +15,6 @@ import { measureBoundingBox } from './measureBoundingBox.js'
  */
 export const measureAggregateBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateBoundingBox: no geometries supplied')
   const bounds = measureBoundingBox(geometries)
   if (geometries.length === 1) {
     return bounds

package/src/measurements/measureAggregateEpsilon.js

@@ -18,7 +18,6 @@ import { calculateEpsilonFromBounds } from './calculateEpsilonFromBounds.js'
  */
 export const measureAggregateEpsilon = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateEpsilon: no geometries supplied')
   const bounds = measureAggregateBoundingBox(geometries)
 
   let dimensions = 0

package/src/measurements/measureAggregateVolume.js

@@ -14,7 +14,6 @@ import { measureVolume } from './measureVolume.js'
  */
 export const measureAggregateVolume = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('measureAggregateVolume: no geometries supplied')
   const volumes = measureVolume(geometries)
   if (geometries.length === 1) {
     return volumes

package/src/measurements/measureArea.js

@@ -85,7 +85,6 @@ const measureAreaOfSlice = (geometry) => {
  */
 export const measureArea = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return measureAreaOfPath2(geometry)

package/src/measurements/measureBoundingBox.js

@@ -121,7 +121,6 @@ const measureBoundingBoxOfSlice = (geometry) => {
  */
 export const measureBoundingBox = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return measureCached(geometry, measureBoundingBoxOfPath2)

package/src/measurements/measureEpsilon.js

@@ -20,7 +20,6 @@ import { measureBoundingBox } from './measureBoundingBox.js'
  */
 export const measureEpsilon = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)

package/src/measurements/measureVolume.js

@@ -34,7 +34,6 @@ const measureVolumeOfGeom3 = (geometry) => {
  */
 export const measureVolume = (...geometries) => {
   geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
 
   const results = geometries.map((geometry) => {
     if (geom3.isA(geometry)) return measureVolumeOfGeom3(geometry)

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

@@ -1,3 +1,4 @@
 export { intersect } from './intersect.js'
 export { subtract } from './subtract.js'
 export { union } from './union.js'
+export { scission } from './scission.js'

package/src/operations/booleans/intersect.js

@@ -1,5 +1,5 @@
 import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
-import { flatten } from '../../utils/flatten.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -13,11 +13,11 @@ import { intersectGeom3 } from './intersectGeom3.js'
  * 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.intersect
  *
  * @example
- * let myshape = intersect(cube({size: [5,5,5]}), cube({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = intersect(cube({size: 5}), cube({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+
@@ -30,9 +30,9 @@ import { intersectGeom3 } from './intersectGeom3.js'
  *      +-------+
  */
 export const intersect = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('intersect wrong number of arguments')
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('intersect arguments must be the same geometry type')
   }

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

@@ -4,11 +4,11 @@ import { geom2, geom3 } from '../../geometries/index.js'
 
 import { intersect } from './index.js'
 
-test('intersect error wrong number of arguments', (t) => {
-  const message = 'intersect wrong number of arguments'
-  t.throws(() => intersect(), { message })
-  t.throws(() => intersect([]), { message })
-  t.throws(() => intersect([[], []]), { message })
+test('intersect empty arguments', (t) => {
+  t.is(intersect(), undefined)
+  t.is(intersect([]), undefined)
+  t.is(intersect([[], []]), undefined)
+  t.is(intersect(null, null), undefined)
 })
 
 test('intersect error different geometry types', (t) => {
@@ -20,6 +20,5 @@ test('intersect error non-geometries', (t) => {
   const message = 'intersect unsupported geometry type'
   t.throws(() => intersect([1, 2, 3], [4, 5, 6]), { message })
   t.throws(() => intersect([], [123]), { message })
-  t.throws(() => intersect("one", "two"), { message })
-  t.throws(() => intersect(null, null), { message })
+  t.throws(() => intersect('one', 'two'), { message })
 })

package/src/operations/booleans/intersectGeom2.js

@@ -1,17 +1,13 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { INTERSECTION } from './martinez/operation.js'
 import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing space in both the first geometry and
  * in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom2} geometries - list of 2D geometries
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new 2D geometry
  */
-export const intersectGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const intersectGeom2 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = boolean(newGeometry, geometry, INTERSECTION)

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

@@ -6,7 +6,7 @@ import { geom2 } from '../../geometries/index.js'
 
 import { measureArea } from '../../measurements/index.js'
 
-import { circle, rectangle } from '../../primitives/index.js'
+import { circle, rectangle, square } from '../../primitives/index.js'
 
 import { intersect } from './index.js'
 
@@ -73,3 +73,27 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })
+
+test('intersect with undefined/null values', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = intersect(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})
+
+test('intersect of nested arrays', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = intersect(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})

package/src/operations/booleans/intersectGeom3.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { retessellate } from '../modifiers/retessellate.js'
 
 import { intersectGeom3Sub } from './intersectGeom3Sub.js'
@@ -7,12 +5,10 @@ import { intersectGeom3Sub } from './intersectGeom3Sub.js'
 /*
  * Return a new 3D geometry representing space in both the first geometry and
  * in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom3} geometries - list of 3D geometries
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new 3D geometry
  */
-export const intersectGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const intersectGeom3 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = intersectGeom3Sub(newGeometry, geometry)

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

@@ -4,7 +4,7 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { sphere, cuboid } from '../../primitives/index.js'
 
@@ -69,6 +69,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureArea(result1), 44.053756306589825)
   t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -79,6 +80,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const result2 = intersect(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows(() => geom3.validate(result2))
+  t.is(measureArea(result2), 0)
   t.is(measureVolume(result2), 0)
   t.is(obs.length, 0)
 
@@ -99,6 +101,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   ]
 
   t.notThrows(() => geom3.validate(result3))
+  t.is(measureArea(result3), 6)
   t.is(measureVolume(result3), 1.0000000000000009)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -107,6 +110,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const result4 = intersect(geometry1, geometry3)
   obs = geom3.toPoints(result4)
   t.notThrows.skip(() => geom3.validate(result4))
+  t.is(measureArea(result4), 44.053756306589825)
   t.is(measureVolume(result4), 25.751611331979678)
   t.is(obs.length, 32)
 })

package/src/operations/booleans/mayOverlap.js

@@ -2,7 +2,6 @@ import { EPS } from '../../maths/constants.js'
 
 import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
 
-
 /*
  * Determine if the given geometries overlap by comparing min and max bounds.
  * NOTE: This is used in union for performance gains.

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

@@ -0,0 +1,5 @@
+import type { Geom3 } from '../../geometries/geom3/type.d.ts'
+import type { RecursiveArray } from '../../utils/recursiveArray.d.ts'
+
+export function scission(...geometries: RecursiveArray<Geom3>): Geom3
+export function scission(...geometries: RecursiveArray<Geom3>): Array<Geom3>

package/src/operations/booleans/scission.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom3 from '../../geometries/geom3/index.js'
 
 import { scissionGeom3 } from './scissionGeom3.js'
@@ -7,6 +5,8 @@ import { scissionGeom3 } from './scissionGeom3.js'
 /**
  * Scission (divide) the given geometry into the component pieces.
  *
+ * NOTE: Currently only 3D geometries are supported.
+ *
  * @param {...Object} objects - list of geometries
  * @returns {Array} list of pieces from each geometry
  * @alias module:modeling/booleans.scission
@@ -26,13 +26,11 @@ import { scissionGeom3 } from './scissionGeom3.js'
  *      +-------+            +-------+
  */
 export const scission = (...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   const results = objects.map((object) => {
     // if (path2.isA(object)) return path2.transform(matrix, object)
     // if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return scissionGeom3(object)
+    if (Array.isArray(object)) return scission(...object)
     return object
   })
   return results.length === 1 ? results[0] : results

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

@@ -2,6 +2,8 @@ import test from 'ava'
 
 import { geom3 } from '../../geometries/index.js'
 
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { cube, torus } from '../../primitives/index.js'
 
 import { scission, union } from './index.js'
@@ -42,6 +44,10 @@ test('scission: scission of complex geom3 produces expected geometry', (t) => {
   t.is(result1.length, 2)
   t.notThrows.skip(() => geom3.validate(result1[0]))
   t.notThrows.skip(() => geom3.validate(result1[1]))
+  t.is(measureArea(result1[0]), 7720.0306508548)
+  t.is(measureArea(result1[1]), 3860.0153254273987)
+  t.is(measureVolume(result1[0]), 18745.166004060953)
+  t.is(measureVolume(result1[1]), 9372.583002030477)
 
   const rc1 = geom3.toPolygons(result1[0]).length
   const rc2 = geom3.toPolygons(result1[1]).length