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

package/src/operations/hulls/hullChain.test.js

@@ -1,13 +1,15 @@
 import test from 'ava'
 
 import { geom2, geom3 } from '../../geometries/index.js'
-import { measureArea } from '../../measurements/measureArea.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { square } from '../../primitives/square.js'
 
 import { hullChain } from './index.js'
 
 test('hullChain: hullChain single geometry', (t) => {
-  const result = hullChain([ square({ size: 1 }) ])
+  const result = hullChain([square({ size: 1 })])
   t.notThrows(() => geom2.validate(result))
   t.is(measureArea(result), 1)
   t.is(geom2.toPoints(result).length, 4)
@@ -22,6 +24,7 @@ test('hullChain (two, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 9)
   t.is(pts.length, 4)
 
   // different
@@ -29,6 +32,7 @@ test('hullChain (two, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 81)
   t.is(pts.length, 6)
 })
 
@@ -43,6 +47,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 126)
   t.is(pts.length, 10)
 
   // closed
@@ -51,6 +56,7 @@ test('hullChain (three, geom2)', (t) => {
 
   // the sides change based on the bestplane chosen in trees/Node.js
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 148.21875)
   t.is(pts.length, 10)
 })
 
@@ -85,6 +91,8 @@ test('hullChain (three, geom3)', (t) => {
   let pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 266.1454764345133)
+  t.is(measureVolume(obs), 239.2012987012987)
   t.is(pts.length, 23)
 
   // closed
@@ -92,5 +100,7 @@ test('hullChain (three, geom3)', (t) => {
   pts = geom3.toPoints(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 272.2887171436021)
+  t.is(measureVolume(obs), 261.96982218883045)
   t.is(pts.length, 28)
 })

package/src/operations/hulls/hullGeom2.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 
 import { hullPoints2 } from './hullPoints2.js'
@@ -7,12 +5,13 @@ import { toUniquePoints } from './toUniquePoints.js'
 
 /*
  * Create a convex hull of the given geom2 geometries.
- * @param {...geometries} geometries - list of geom2 geometries
+ *
+ * NOTE: The given geometries must be valid geom2 geometries.
+ *
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new geometry
  */
-export const hullGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullGeom2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 

package/src/operations/hulls/hullGeom3.js

@@ -1,30 +1,21 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom3 from '../../geometries/geom3/index.js'
-import * as poly3 from '../../geometries/poly3/index.js'
 
-import { runner } from './quickhull/index.js'
+import { hullPoints3 } from './hullPoints3.js'
 import { toUniquePoints } from './toUniquePoints.js'
 
 /*
- * Create a convex hull of the given geometries (geom3).
- * @param {...geometries} geometries - list of geom3 geometries
+ * Create a convex hull of the given geom3 geometries.
+ *
+ * NOTE: The given geometries must be valid geom3 geometries.
+ *
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new geometry
  */
-export const hullGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
-  if (geometries.length === 1) return geometries[0]
-
+export const hullGeom3 = (geometries) => {
   // extract the unique vertices from the geometries
   const unique = toUniquePoints(geometries)
 
-  const faces = runner(unique, { skipTriangulation: true })
-
-  const polygons = faces.map((face) => {
-    const vertices = face.map((index) => unique[index])
-    return poly3.create(vertices)
-  })
+  if (unique.length === 0) return geom3.create()
 
-  return geom3.create(polygons)
+  return geom3.create(hullPoints3(unique))
 }

package/src/operations/hulls/hullPath2.js

@@ -1,18 +1,17 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as path2 from '../../geometries/path2/index.js'
 
 import { hullPoints2 } from './hullPoints2.js'
 import { toUniquePoints } from './toUniquePoints.js'
 
 /*
- * Create a convex hull of the given geometries (path2).
- * @param {...geometries} geometries - list of path2 geometries
+ * Create a convex hull of the given path2 geometries.
+ *
+ * NOTE: The given geometries must be valid path2 geometry.
+ *
+ * @param {Path2[]} geometries - a flat list of path2 geometries
  * @returns {Path2} new geometry
  */
-export const hullPath2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const hullPath2 = (geometries) => {
   // extract the unique points from the geometries
   const unique = toUniquePoints(geometries)
 

package/src/operations/hulls/hullPath2.test.js

@@ -9,7 +9,7 @@ test('hullPath2', (t) => {
   const geometry1 = path2.fromPoints({ closed }, [[0, 0], [-4, 4], [-4, -4]])
   const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
 
-  const obs = hullPath2(geometry1, geometry2)
+  const obs = hullPath2([geometry1, geometry2])
   t.notThrows(() => path2.validate(obs))
   const pts = path2.toPoints(obs)
   t.is(pts.length, 4)

package/src/operations/hulls/hullPoints2.d.ts

@@ -0,0 +1,3 @@
+import type { Vec2 } from '../../maths/vec2/type.d.ts'
+
+export function hullPoints2(uniquePoints: Array<Vec2>): Array<Vec2>

package/src/operations/hulls/hullPoints2.js

@@ -1,10 +1,12 @@
 import * as vec2 from '../../maths/vec2/index.js'
 
-/*
+/**
  * Create a convex hull of the given set of points, where each point is an array of [x,y].
- * Uses https://en.wikipedia.org/wiki/Graham_scan
+ *
+ * @see https://en.wikipedia.org/wiki/Graham_scan
  * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
  * @returns {Array} a list of points that form the hull
+ * @alias module:modeling/hulls.hullPoints2
  */
 export const hullPoints2 = (uniquePoints) => {
   // find min point
@@ -15,28 +17,32 @@ export const hullPoints2 = (uniquePoints) => {
     }
   })
 
-  // gather information for sorting by polar coordinates (point, angle, distSq)
-  const points = []
-  uniquePoints.forEach((point) => {
-    // use faster fakeAtan2 instead of Math.atan2
-    const angle = fakeAtan2(point[1] - min[1], point[0] - min[0])
-    const distSq = vec2.squaredDistance(point, min)
-    points.push({ point, angle, distSq })
-  })
+  // calculations relative to min point
+  const squaredDistance = (point) => vec2.squaredDistance(point, min)
+  const polarAngle = (point) => (point[0] === min[0] && point[1] === min[1]) ? -Infinity : -(point[0] - min[0]) / (point[1] - min[1])
 
-  // sort by polar coordinates
-  points.sort((pt1, pt2) => pt1.angle !== pt2.angle
-    ? pt1.angle - pt2.angle
-    : pt1.distSq - pt2.distSq)
+  // points are sorted by polar angle in clockwise order
+  const sorted = uniquePoints
+  sorted.sort((pt1, pt2) => {
+    const pa1 = polarAngle(pt1)
+    const pa2 = polarAngle(pt2)
+    if (pa1 === pa2) {
+      // sort by the relative distances to min point
+      return squaredDistance(pt1) - squaredDistance(pt2)
+    }
+    // sort by polar angles to min point
+    return pa1 - pa2
+  })
 
   const stack = [] // start with empty stack
-  points.forEach((point) => {
+  sorted.forEach((point) => {
     let cnt = stack.length
-    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point.point) <= Number.EPSILON) {
-      stack.pop() // get rid of colinear and interior (clockwise) points
+    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point) <= Number.EPSILON) {
+      // get rid of colinear and interior (clockwise) points
+      stack.pop()
       cnt = stack.length
     }
-    stack.push(point.point)
+    stack.push(point)
   })
 
   return stack
@@ -44,15 +50,3 @@ export const hullPoints2 = (uniquePoints) => {
 
 // returns: < 0 clockwise, 0 colinear, > 0 counter-clockwise
 const ccw = (v1, v2, v3) => (v2[0] - v1[0]) * (v3[1] - v1[1]) - (v2[1] - v1[1]) * (v3[0] - v1[0])
-
-// Returned "angle" is really 1/tan (inverse of slope) made negative to increase with angle.
-// This function is strictly for sorting in this algorithm.
-const fakeAtan2 = (y, x) => {
-  // The "if" is a special case for when the minimum vector found in loop above is present.
-  // We need to ensure that it sorts as the minimum point. Otherwise, this becomes NaN.
-  if (y === 0 && x === 0) {
-    return -Infinity
-  } else {
-    return -x / y
-  }
-}

package/src/operations/hulls/hullPoints3.d.ts

@@ -0,0 +1,4 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Poly3 } from '../../geometries/poly3/type.d.ts'
+
+export function hullPoints3(uniquePoints: Array<Vec3>): Array<Poly3>

package/src/operations/hulls/hullPoints3.js

@@ -0,0 +1,21 @@
+import * as poly3 from '../../geometries/poly3/index.js'
+
+import { runner } from './quickhull/index.js'
+
+/**
+ * Create a convex hull of the given set of points, where each point is an array of [x,y,z].
+ *
+ * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
+ * @returns {Array} a list of polygons (poly3)
+ * @alias module:modeling/hulls.hullPoints3
+ */
+export const hullPoints3 = (uniquePoints) => {
+  const faces = runner(uniquePoints, { skipTriangulation: true })
+
+  const polygons = faces.map((face) => {
+    const vertices = face.map((index) => uniquePoints[index])
+    return poly3.create(vertices)
+  })
+
+  return polygons
+}

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

@@ -1,2 +1,4 @@
 export { hull } from './hull.js'
 export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/hulls/index.js

@@ -4,7 +4,9 @@
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/hulls
  * @example
- * import { hull, hullChain } from '@jscad/modeling'
+ * import { hull, hullChain, hullPoints2, hullPoints3 } from '@jscad/modeling'
  */
 export { hull } from './hull.js'
 export { hullChain } from './hullChain.js'
+export { hullPoints2 } from './hullPoints2.js'
+export { hullPoints3 } from './hullPoints3.js'

package/src/operations/modifiers/generalize.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -67,14 +65,12 @@ const generalizeGeom3 = (options, geometry) => {
  * @alias module:modeling/modifiers.generalize
  */
 export const generalize = (options, ...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 generalizePath2(options, geometry)
     if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)
-    throw new Error('invalid geometry')
+    if (Array.isArray(geometry)) return generalize(options, ...geometry)
+    return geometry
   })
   return results.length === 1 ? results[0] : results
 }

package/src/operations/modifiers/index.js

@@ -3,7 +3,7 @@
  * In all cases, these functions returns the results, and never changes the original geometry.
  * @module modeling/modifiers
  * @example
- * import { generalize, snap } from '@jscad/modeling'
+ * import { generalize, snap, retessellate } from '@jscad/modeling'
  */
 export { generalize } from './generalize.js'
 export { snap } from './snap.js'

package/src/operations/modifiers/mergePolygons.js

@@ -67,7 +67,6 @@ const calculateAngle = (prevVertex, midVertex, nextVertex, normal) => {
 
 // create a polygon starting from the given edge (if possible)
 const createPolygonAnd = (edge) => {
-  let polygon
   const vertices = []
   while (edge.next) {
     const next = edge.next
@@ -81,8 +80,8 @@ const createPolygonAnd = (edge) => {
 
     edge = next
   }
-  if (vertices.length > 0) polygon = poly3.create(vertices)
-  return polygon
+  if (vertices.length > 0) return poly3.create(vertices)
+  return null
 }
 
 /*

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -31,7 +31,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
   // Make a list of all encountered y coordinates
   // And build a map of all polygons that have a vertex at a certain y coordinate:
   const yCoordinateBins = new Map()
-  const yCoordinateBinningFactor = 10 / EPS
+  const yCoordinateBinningFactor = 10 / EPS // FIXME
   for (let polygonIndex = 0; polygonIndex < numPolygons; polygonIndex++) {
     const poly3d = sourcePolygons[polygonIndex]
     let vertices2d = []
@@ -68,7 +68,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         }
         let polygonIndexes = yCoordinateToPolygonIndexes.get(y)
         if (!polygonIndexes) {
-          polygonIndexes = {} // PERF
+          polygonIndexes = []
           yCoordinateToPolygonIndexes.set(y, polygonIndexes)
         }
         polygonIndexes[polygonIndex] = true
@@ -242,7 +242,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         const prevOutPolygon = newOutPolygonRow[newOutPolygonRow.length - 1]
         const d1 = vec2.distance(outPolygon.topLeft, prevOutPolygon.topRight)
         const d2 = vec2.distance(outPolygon.bottomLeft, prevOutPolygon.bottomRight)
-        if ((d1 < EPS) && (d2 < EPS)) {
+        if ((d1 < EPS) && (d2 < EPS)) { // FIXME
           // we can join this polygon with the one to the left:
           outPolygon.topLeft = prevOutPolygon.topLeft
           outPolygon.leftLine = prevOutPolygon.leftLine
@@ -263,8 +263,8 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
             // We have a match if the sidelines are equal or if the top coordinates
             // are on the sidelines of the previous polygon
             const prevPolygon = prevOutPolygonRow[ii]
-            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) {
-              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) {
+            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) { // FIXME
+              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) { // FIXME
                 // Yes, the top of this polygon matches the bottom of the previous:
                 matchedIndexes.add(ii)
                 // Now check if the joined polygon would remain convex:
@@ -300,7 +300,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           // Finish the polygon with the last point(s):
           const prevPolygon = prevOutPolygonRow[ii]
           prevPolygon.outPolygon.rightPoints.push(prevPolygon.bottomRight)
-          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) {
+          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) { // FIXME
             // polygon ends with a horizontal line:
             prevPolygon.outPolygon.leftPoints.push(prevPolygon.bottomLeft)
           }
@@ -324,7 +324,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           rightPoints: []
         }
         thisPolygon.outPolygon.leftPoints.push(thisPolygon.topLeft)
-        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) {
+        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) { // FIXME
           // we have a horizontal line at the top:
           thisPolygon.outPolygon.rightPoints.push(thisPolygon.topRight)
         }

package/src/operations/modifiers/snap.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as vec2 from '../../maths/vec2/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
@@ -48,20 +46,18 @@ const snapGeom3 = (geometry) => {
 }
 
 /**
- * Snap the given geometries to the overall precision (epsilon) of the geometry.
+ * Snap the given geometries to the precision (calculated epsilon) of the geometry.
  * @see measurements.measureEpsilon()
  * @param {...Object} geometries - the geometries to snap
  * @return {Object|Array} the snapped geometry, or a list of snapped geometries
  * @alias module:modeling/modifiers.snap
  */
 export const snap = (...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 snapPath2(geometry)
     if (geom2.isA(geometry)) return snapGeom2(geometry)
     if (geom3.isA(geometry)) return snapGeom3(geometry)
+    if (Array.isArray(geometry)) return snap(...geometry)
     return geometry
   })
   return results.length === 1 ? results[0] : results

package/src/operations/offsets/offset.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'
@@ -23,13 +21,11 @@ import { offsetPath2 } from './offsetPath2.js'
  * let small = offset({ delta: -4, corners: 'chamfer' }, square({size: 40})) // contract
  */
 export const offset = (options, ...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 offsetPath2(options, object)
     if (geom2.isA(object)) return offsetGeom2(options, object)
     if (geom3.isA(object)) return offsetGeom3(options, object)
+    if (Array.isArray(object)) return offset(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/offsets/offsetFromPoints.test.js

@@ -200,7 +200,6 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
 
 test('offset (corners: round): offset of a path2 produces expected offset path2', (t) => {
   const openline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5]]
-  const closeline = [[-5, -5], [5, -5], [5, 5], [3, 5], [3, 0], [-3, 0], [-3, 5], [-5, 5], [-5, -5]]
 
   let pts = offsetFromPoints({ delta: 1, corners: 'round', segments: 16 }, openline)
   let obs = path2.create(pts)

package/src/operations/offsets/offsetGeom2.test.js

@@ -61,6 +61,7 @@ test('offset: offset of a geom2 produces expected changes to points', (t) => {
     [-10, -8]
   ]
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 395.3137084989848)
   t.is(pts.length, 12)
   t.true(comparePoints(pts, exp))
 })

package/src/operations/offsets/offsetGeom3.js

@@ -1,5 +1,3 @@
-import * as geom3 from '../../geometries/geom3/index.js'
-
 import { union } from '../booleans/union.js'
 
 import { offsetShell } from './offsetShell.js'

package/src/operations/offsets/offsetGeom3.test.js

@@ -3,8 +3,11 @@ import test from 'ava'
 import { comparePoints } from '../../../test/helpers/index.js'
 
 import { colorize } from '../../colors/index.js'
+
 import { geom3, poly3 } from '../../geometries/index.js'
-import { measureVolume } from '../../measurements/index.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
 import { cube, sphere } from '../../primitives/index.js'
 
 import { offset } from './index.js'
@@ -13,6 +16,7 @@ test('offset: offset empty geom3', (t) => {
   const geometry = geom3.create()
   const result = offset({ }, geometry)
   t.notThrows(() => geom3.validate(result))
+  t.is(measureArea(result), 0)
   t.is(measureVolume(result), 0)
   t.is(geom3.toPolygons(result).length, 0)
   t.is(geom3.toPoints(result).length, 0)
@@ -50,6 +54,8 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
   ]
 
   t.notThrows.skip(() => geom3.validate(obs))
+  t.is(measureArea(obs), 3178.8059464475555)
+  t.is(measureVolume(obs), 13504.574121271067)
   t.is(pts.length, 62)
   t.true(comparePoints(pts[0], exp0))
   t.true(comparePoints(pts[61], exp61))
@@ -58,6 +64,8 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
   const obs2 = offset({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
   t.notThrows.skip(() => geom3.validate(obs2))
+  t.is(measureArea(obs), 3178.8059464475555)
+  t.is(measureVolume(obs), 13504.574121271067)
   t.is(pts2.length, 864)
 })
 

package/src/operations/offsets/offsetPath2.js

@@ -85,9 +85,9 @@ export const offsetPath2 = (options, geometry) => {
     internal: offsetFromPoints({ delta: -delta, corners, segments, closed }, points)
   }
 
-  const output = geometry.isClosed ?
-    createGeometryFromClosedPath(paths) :
-    createGeometryFromOpenPath(paths, segments, corners, delta)
+  const output = geometry.isClosed
+    ? createGeometryFromClosedPath(paths)
+    : createGeometryFromOpenPath(paths, segments, corners, delta)
   if (geometry.color) output.color = geometry.color
   return output
 }

package/src/operations/transforms/align.js

@@ -1,4 +1,6 @@
-import { flatten } from '../../utils/flatten.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { coalesce } from '../../utils/coalesce.js'
 import { padArrayToLength } from '../../utils/padArrayToLength.js'
 
 import { measureAggregateBoundingBox } from '../../measurements/measureAggregateBoundingBox.js'
@@ -34,9 +36,9 @@ const populateRelativeToFromBounds = (relativeTo, modes, bounds) => {
   return relativeTo
 }
 
-const alignGeometries = (geometry, modes, relativeTo) => {
-  const bounds = measureAggregateBoundingBox(geometry)
-  const translation = [0, 0, 0]
+const alignGeometries = (geometries, modes, relativeTo) => {
+  const bounds = measureAggregateBoundingBox(geometries)
+  const translation = vec3.create()
   for (let i = 0; i < 3; i++) {
     if (modes[i] === 'center') {
       translation[i] = relativeTo[i] - (bounds[0][i] + bounds[1][i]) / 2
@@ -47,7 +49,7 @@ const alignGeometries = (geometry, modes, relativeTo) => {
     }
   }
 
-  return translate(translation, geometry)
+  return translate(translation, geometries)
 }
 
 /**
@@ -73,14 +75,13 @@ export const align = (options, ...geometries) => {
 
   options = validateOptions(options)
   let { modes, relativeTo, grouped } = options
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('align(): No geometries were provided to act upon')
 
   if (relativeTo.filter((val) => val == null).length) {
     const bounds = measureAggregateBoundingBox(geometries)
     relativeTo = populateRelativeToFromBounds(relativeTo, modes, bounds)
   }
   if (grouped) {
+    geometries = coalesce(geometries)
     geometries = alignGeometries(geometries, modes, relativeTo)
   } else {
     geometries = geometries.map((geometry) => alignGeometries(geometry, modes, relativeTo))

package/src/operations/transforms/align.test.js

@@ -53,7 +53,7 @@ test('align: multiple objects ungrouped returns geometry aligned, different mode
     cube({ size: 4, center: [10, 10, 10] }),
     cube({ size: 2, center: [4, 4, 4] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, original)
+  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, ...original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[28, 30, 26], [32, 34, 30]]
   t.notThrows(() => geom3.validate(aligned[0]))
@@ -79,7 +79,7 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
     cube({ size: 2, center: [4, 4, 4] }),
     cube({ size: 4, center: [10, 10, 10] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, original)
+  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, ...original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[5.5, 3, 8], [9.5, 7, 12]]
   t.notThrows(() => geom3.validate(aligned[0]))