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

package/src/operations/booleans/unionGeom2.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 { center, translate } from '../transforms/index.js'
 
@@ -209,3 +209,27 @@ test('union of geom2 with colinear edge (martinez issue #155)', (t) => {
   t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
+
+test('union 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 = union(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})
+
+test('union 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 = union(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})

package/src/operations/booleans/unionGeom3.js

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

package/src/operations/booleans/unionGeom3.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('union of one or more geom3 objects produces expected geometry', (t) => {
     [[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('union of one or more geom3 objects produces expected geometry', (t) => {
   const result2 = union(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows.skip(() => geom3.validate(result2))
+  t.is(measureArea(result2), 140.05375630658983)
   t.is(measureVolume(result2), 89.75161133197969)
   t.is(obs.length, 38)
 
@@ -108,6 +110,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, 8, 9], [-9, -9, 9], [9, -9, 9], [9, 8, 9]]
   ]
   t.notThrows.skip(() => geom3.validate(result3))
+  t.is(measureArea(result3), 2034)
   t.is(measureVolume(result3), 5895)
   t.is(obs.length, 18)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -124,6 +127,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, -9, 9], [9, -9, 9], [9, 9, 9], [-9, 9, 9]]
   ]
   t.notThrows(() => geom3.validate(result4))
+  t.is(measureArea(result4), 1944)
   t.is(measureVolume(result4), 5832)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -136,6 +140,7 @@ test('union of geom3 with rounding issues #137', (t) => {
   const result = union(geometry1, geometry2)
   const pts = geom3.toPoints(result)
   t.notThrows(() => geom3.validate(result))
+  t.is(measureArea(result), 3240.00014)
   t.is(measureVolume(result), 7779.201144000001)
   t.is(pts.length, 6) // number of polygons in union
 })

package/src/operations/extrusions/extrudeFromSlices.test.js

@@ -7,7 +7,7 @@ import { mat4 } from '../../maths/index.js'
 
 import { geom2, geom3, poly3, slice } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { circle, square } from '../../primitives/index.js'
 
@@ -32,6 +32,8 @@ test('extrudeFromSlices (defaults)', (t) => {
     [[-10, -10, 0], [-10, 10, 0], [10, 10, 0]],
     [[10, 10, 0], [10, -10, 0], [-10, -10, 0]]
   ]
+  t.is(measureArea(geometry3), 880)
+  t.is(measureVolume(geometry3), 400.00000000000006)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -40,6 +42,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   pts = geom3.toPoints(geometry3)
 
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 880)
   t.is(measureVolume(geometry3), 400.00000000000006)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -74,6 +77,7 @@ test('extrudeFromSlices (torus)', (t) => {
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7070.694617452831)
   t.is(measureVolume(geometry3), 29393.876913398108)
   t.is(pts.length, 96)
 })
@@ -95,6 +99,7 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
   const pts = geom3.toPoints(geometry3)
   // expected to throw because capEnd is false (non-closed geometry)
   t.throws(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 53.70100297794013)
   t.is(measureVolume(geometry3), 8.5)
   t.is(pts.length, 26)
 })
@@ -114,6 +119,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows.skip(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1965.8643589631802)
   t.is(measureVolume(geometry3), 5260.067107417433)
   t.is(pts.length, 304)
 })
@@ -160,6 +166,7 @@ test('extrudeFromSlices (holes)', (t) => {
     [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 720)
   t.is(measureVolume(geometry3), 300)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/extrudeHelical.js

@@ -19,14 +19,8 @@ import { extrudeFromSlices } from './extrudeFromSlices.js'
  * @alias module:modeling/extrusions.extrudeHelical
  *
  * @example
- * const myshape = extrudeHelical(
- *  {
- *      angle: Math.PI * 4,
- *      pitch: 10,
- *      segmentsPerRotation: 64
- *  },
- *  circle({size: 3, center: [10, 0]})
- * )
+ * const myshape = circle({size: 3, center: [10, 0]}) // position for extrusion about Z
+ * const mycoil = extrudeHelical({angle: TAU*2, pitch: 10, segmentsPerRotation: 64}, myshape))
  */
 export const extrudeHelical = (options, geometry) => {
   const defaults = {

package/src/operations/extrusions/extrudeLinear.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as path2 from '../../geometries/path2/index.js'
 
@@ -30,15 +28,13 @@ export const extrudeLinear = (options, ...objects) => {
   }
   const { height, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   options = { offset: [0, 0, height], twistAngle, twistSteps, repair }
 
   const results = objects.map((object) => {
     if (path2.isA(object)) return extrudeLinearPath2(options, object)
     if (geom2.isA(object)) return extrudeLinearGeom2(options, object)
     // if (geom3.isA(object)) return geom3.extrude(options, object)
+    if (Array.isArray(object)) return extrudeLinear(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/extrusions/extrudeLinear.test.js

@@ -8,7 +8,7 @@ import { colorize } from '../../colors/index.js'
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { square } from '../../primitives/index.js'
 
@@ -34,6 +34,7 @@ test('extrudeLinear (defaults)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 240)
   t.is(measureVolume(geometry3), 100.00000000000001)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -70,6 +71,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 800)
   t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -91,6 +93,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, -5, 0], [5, 5, 0], [-5, 5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 800)
   t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -124,6 +127,7 @@ test('extrudeLinear (twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 805.6920958788816)
   t.is(measureVolume(geometry3), 1707.1067811865476)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -166,6 +170,7 @@ test('extrudeLinear (twist)', (t) => {
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1091.9932843446968)
   t.is(measureVolume(geometry3), 1444.9967160503095)
   t.is(pts.length, 244)
 })
@@ -212,6 +217,7 @@ test('extrudeLinear (holes)', (t) => {
     [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1008)
   t.is(measureVolume(geometry3), 1260)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/extrudeRotate.js

@@ -4,6 +4,7 @@ import * as mat4 from '../../maths/mat4/index.js'
 import { mirrorX } from '../transforms/mirror.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
 import * as slice from '../../geometries/slice/index.js'
 
 import { extrudeFromSlices } from './extrudeFromSlices.js'
@@ -58,7 +59,7 @@ export const extrudeRotate = (options, geometry) => {
 
   // convert geometry to an array of sides, easier to deal with
   let shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) return geometry
+  if (shapeSides.length === 0) return geom3.create()
   let sliceGeometry = geometry
 
   // determine if the extrusion can be computed in the first place
@@ -88,7 +89,7 @@ export const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      sliceGeometry = geom2.reverse(geom2.fromSides(shapeSides))
+      sliceGeometry = geom2.fromSides(shapeSides)
       sliceGeometry = mirrorX(sliceGeometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {

package/src/operations/extrusions/extrudeRotate.test.js

@@ -8,7 +8,7 @@ import { colorize } from '../../colors/index.js'
 
 import { geom2, geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { square } from '../../primitives/index.js'
 
@@ -20,6 +20,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7033.914479497244)
   t.is(measureVolume(geometry3), 27648.000000000007)
   t.is(pts.length, 96)
 })
@@ -51,6 +52,7 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1360.144820048035)
   t.is(measureVolume(geometry3), 3258.3480477076105)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -58,12 +60,14 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.850393739846)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 4525.8503937398455)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 })
@@ -80,6 +84,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [-11.803752993228215, 23.166169628897567, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.6858201346895)
   t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
   t.true(comparePoints(pts[6], exp))
@@ -92,6 +97,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [23.166169628897567, 11.803752993228215, 8]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 6124.685820134688)
   t.is(measureVolume(geometry3), 21912.342135440336)
   t.is(pts.length, 40)
   t.true(comparePoints(pts[6], exp))
@@ -104,12 +110,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 5562.34804770761)
   t.is(measureVolume(geometry3), 18432)
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7230.965353920782)
   t.is(measureVolume(geometry3), 28906.430888871357)
   t.is(pts.length, 512)
 
@@ -118,6 +126,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 84.28200374166053)
   t.is(measureVolume(geometry3), 33.94112549695427)
   t.is(pts.length, 64)
 
@@ -126,6 +135,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 17692.315375839215)
   t.is(measureVolume(geometry3), 147078.2104868019)
   t.is(pts.length, 80)
 })
@@ -147,6 +157,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[7, 0, -8], [7, 0, 8], [0, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 431.3919189857867)
   t.is(measureVolume(obs), 391.99999999999994)
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -177,6 +188,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[2, 0, 4], [0, 0, 8], [0, 0, -8]]
   ]
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 86.47516025670329)
   t.is(measureVolume(obs), 26.398653164297773)
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/extrudeWalls.js

@@ -25,10 +25,11 @@ const repartitionEdges = (newLength, edges) => {
   }
 
   const divisor = vec3.fromValues(multiple, multiple, multiple)
+  const increment = vec3.create()
 
   const newEdges = []
   edges.forEach((edge) => {
-    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.subtract(increment, edge[1], edge[0])
     vec3.divide(increment, increment, divisor)
 
     // repartition the edge
@@ -48,6 +49,7 @@ const EPSAREA = (EPS * EPS / 2) * Math.sin(Math.PI / 3)
  * Extrude (build) walls between the given slices.
  * Each wall consists of two triangles, which may be invalid if slices are overlapping.
  */
+// FIXME this function should take an eps parameter
 export const extrudeWalls = (slice0, slice1) => {
   let edges0 = slice.toEdges(slice0)
   let edges1 = slice.toEdges(slice1)

package/src/operations/extrusions/project.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { aboutEqualNormals } from '../../maths/utils/aboutEqualNormals.js'
 
 import * as plane from '../../maths/plane/index.js'
@@ -80,15 +78,13 @@ export const project = (options, ...objects) => {
   }
   const { axis, origin } = Object.assign({ }, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   options = { axis, origin }
 
   const results = objects.map((object) => {
     // if (path.isA(object)) return project(options, object)
     // if (geom2.isA(object)) return project(options, object)
     if (geom3.isA(object)) return projectGeom3(options, object)
+    if (Array.isArray(object)) return project(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

package/src/operations/hulls/hull.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'
@@ -12,8 +12,8 @@ import { hullGeom3 } from './hullGeom3.js'
 /**
  * Create a convex hull of the given geometries.
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
- * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {Geom2|Geom3} new geometry
+ * @param {...Object} geometries - list of geometries from which to create a hull
+ * @returns {Geom2|Geom3|Path2} new geometry
  * @alias module:modeling/hulls.hull
  *
  * @example
@@ -33,8 +33,9 @@ import { hullGeom3 } from './hullGeom3.js'
  *       +-------+           +-------+
  */
 export const hull = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
+  geometries = coalesce(geometries)
+
+  if (geometries.length === 0) return undefined
 
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('only hulls of the same type are supported')

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

@@ -1,8 +1,11 @@
 import test from 'ava'
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
-import { measureArea } from '../../measurements/measureArea.js'
-import { sphere, cuboid, ellipsoid } from '../../primitives/index.js'
+
+import { measureArea, measureVolume } from '../../measurements/index.js'
+
+import { cuboid, ellipsoid, sphere, square, torus } from '../../primitives/index.js'
+
 import { center } from '../transforms/index.js'
 
 import { hull } from './index.js'
@@ -41,6 +44,7 @@ test('hull (single, geom2)', (t) => {
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 232.09469999999993)
   t.is(pts.length, 7)
 })
 
@@ -68,6 +72,7 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 100)
   t.is(pts.length, 4)
 
   // one inside another
@@ -75,6 +80,7 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 100)
   t.is(pts.length, 4)
 
   // one overlapping another
@@ -82,12 +88,14 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 116)
   t.is(pts.length, 8)
 
   obs = hull(geometry2, geometry4)
   pts = geom2.toPoints(obs)
 
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 232.09469999999993)
   t.is(pts.length, 7)
 })
 
@@ -114,26 +122,31 @@ test('hull (multiple, various, geom2)', (t) => {
   let obs = hull(geometry1, geometry2)
   let pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 99)
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 308)
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 308)
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 341)
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = geom2.toPoints(obs)
   t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 513.39595)
   t.is(pts.length, 8)
 })
 
@@ -215,7 +228,9 @@ test('hull (single, geom3)', (t) => {
   obs = hull(geometry)
   pts = geom3.toPoints(obs)
 
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 44.05375630658983)
+  t.is(measureVolume(obs), 25.75161133197968)
   t.is(pts.length, 32)
 })
 
@@ -234,6 +249,8 @@ test('hull (multiple, geom3)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 24)
+  t.is(measureVolume(obs), 7.999999999999999)
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -257,6 +274,8 @@ test('hull (multiple, geom3)', (t) => {
   ]
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 145.59502802663923)
+  t.is(measureVolume(obs), 112.49999999999999)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -270,5 +289,39 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 282.26819685563686)
+  t.is(measureVolume(obs), 366.67641200012866)
   t.is(pts.length, 92)
 })
+
+test('hull (multiple with undefined/null values)', (t) => {
+  const square1 = square({ size: 4 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 8 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = hull(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 64)
+  t.is(pts.length, 4)
+})
+
+test('hull (multiple with nested arrays)', (t) => {
+  const square1 = square({ size: 4 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 8 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = hull(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(measureArea(obs), 64)
+  t.is(pts.length, 4)
+})
+
+test('hull (single, unconvex, geom3)', (t) => {
+  const geometry = torus()
+  const obs = hull(geometry)
+  t.assert(measureVolume(obs) > measureVolume(geometry))
+})

package/src/operations/hulls/hullChain.js

@@ -1,4 +1,5 @@
-import { flatten } from '../../utils/flatten.js'
+import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import { union } from '../booleans/union.js'
 
@@ -10,7 +11,7 @@ import { hull } from './hull.js'
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  *
  * @param {...Objects} geometries - list of geometries from which to create a hull
- * @returns {Geom2|Geom3} new geometry
+ * @returns {Geom2|Geom3|Path2} new geometry
  * @alias module:modeling/hulls.hullChain
  *
  * @example
@@ -30,12 +31,16 @@ import { hull } from './hull.js'
  *       +-------+                +-------+
  */
 export const hullChain = (...geometries) => {
-  geometries = flatten(geometries)
-  const hulls = []
+  geometries = coalesce(geometries)
+
+  if (geometries.length === 0) return undefined
+  if (geometries.length === 1) return geometries[0]
 
-  if (geometries.length === 0) throw new Error('wrong number of arguments')
-  if (geometries.length === 1) hulls.push(geometries[0])
+  if (!areAllShapesTheSameType(geometries)) {
+    throw new Error('only hulls of the same type are supported')
+  }
 
+  const hulls = []
   for (let i = 1; i < geometries.length; i++) {
     hulls.push(hull(geometries[i - 1], geometries[i]))
   }