@jscad/modeling 2.11.1 → 2.12.0

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

@@ -25,7 +25,7 @@ class PolygonTreeNode {
     this.parent = parent
     this.children = []
     this.polygon = polygon
-    this.removed = false  // state of branch or leaf
+    this.removed = false // state of branch or leaf
   }
 
   // fill the tree with polygons. Should be called on the root node only; child nodes must

package/src/operations/expansions/expand.test.js

@@ -53,7 +53,7 @@ test('expand: round-expanding a bent line produces expected geometry', (t) => {
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
   t.notThrows(() => geom2.validate(expandedPathGeom2))
-  const expectedArea = 56 + TAU  * delta * 1.25 // shape will have 1 and 1/4 circles
+  const expectedArea = 56 + TAU * delta * 1.25 // shape will have 1 and 1/4 circles
   nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))

package/src/operations/extrusions/extrudeHelical.js

@@ -40,7 +40,7 @@ const extrudeHelical = (options, geometry) => {
 
   let pitch
   // ignore height if pitch is set
-  if(!options.pitch && options.height) {
+  if (!options.pitch && options.height) {
     pitch = options.height / (angle / TAU)
   } else {
     pitch = options.pitch ? options.pitch : defaults.pitch
@@ -49,18 +49,17 @@ const extrudeHelical = (options, geometry) => {
   // needs at least 3 segments for each revolution
   const minNumberOfSegments = 3
 
-  if (segmentsPerRotation < minNumberOfSegments)
-    throw new Error(`The number of segments per rotation needs to be at least 3.`)
+  if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
-  let shapeSides = geom2.toSides(geometry)
+  const shapeSides = geom2.toSides(geometry)
   if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
 
   // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
   const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
-  
+
   let baseSlice = slice.fromSides(shapeSides)
-  
-  if(pointsWithPositiveX.length === 0) {
+
+  if (pointsWithPositiveX.length === 0) {
     // only points in negative x plane, reverse
     baseSlice = slice.reverse(baseSlice)
   }

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

@@ -1,5 +1,4 @@
 const test = require('ava')
-const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 const { TAU } = require('../../maths/constants')
 const { geom2, geom3 } = require('../../geometries')
 const { circle } = require('../../primitives')
@@ -7,56 +6,55 @@ const { circle } = require('../../primitives')
 const { extrudeHelical } = require('./index')
 
 test('extrudeHelical: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
-    const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+  const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    const pts = geom3.toPoints(geometry3)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (defaults) extruding of a circle produces an expected geom3', (t) => {
-    const geometry2 = circle({ size: 3, center: [10, 0] })
+  const geometry2 = circle({ size: 3, center: [10, 0] })
 
-    const geometry3 = extrudeHelical({}, geometry2)
-    t.notThrows(() => geom3.validate(geometry3))
+  const geometry3 = extrudeHelical({}, geometry2)
+  t.notThrows(() => geom3.validate(geometry3))
 })
 
 test('extrudeHelical: (angle) extruding of a circle produces an expected geom3', (t) => {
-    const maxRevolutions = 10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(maxRevolutions).keys()]) {
-        // also test negative angles
-        const geometry3 = extrudeHelical({angle: TAU * (index - maxRevolutions / 2)}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const maxRevolutions = 10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(maxRevolutions).keys()]) {
+    // also test negative angles
+    const geometry3 = extrudeHelical({ angle: TAU * (index - maxRevolutions / 2) }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3', (t) => {
-    const startPitch = -10
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(20).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({pitch: startPitch + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startPitch = -10
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(20).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ pitch: startPitch + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expected geom3', (t) => {
-    const startOffset = -5
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(10).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({endRadiusOffset: startOffset + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
+  const startOffset = -5
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(10).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ endRadiusOffset: startOffset + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
 })
 
 test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
-    const startSegments = 3
-    const geometry2 = circle({ size: 3, center: [10, 0] })
-    for (const index of [...Array(30).keys()]) {
-        // also test negative pitches
-        const geometry3 = extrudeHelical({segments: startSegments + index}, geometry2)
-        t.notThrows(() => geom3.validate(geometry3))
-    }
-})
+  const startSegments = 3
+  const geometry2 = circle({ size: 3, center: [10, 0] })
+  for (const index of [...Array(30).keys()]) {
+    // also test negative pitches
+    const geometry3 = extrudeHelical({ segments: startSegments + index }, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+  }
+})

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

@@ -2,6 +2,7 @@ export { default as extrudeFromSlices, ExtrudeFromSlicesOptions } from './extrud
 export { default as extrudeLinear, ExtrudeLinearOptions } from './extrudeLinear'
 export { default as extrudeRectangular, ExtrudeRectangularOptions } from './extrudeRectangular'
 export { default as extrudeRotate, ExtrudeRotateOptions } from './extrudeRotate'
+export { default as extrudeHelical, ExtrudeHelicalOptions } from './extrudeHelical'
 export { default as project, ProjectOptions } from './project'
 export * as slice from './slice'
 

package/src/operations/hulls/hullPoints2.js

@@ -25,8 +25,9 @@ const hullPoints2 = (uniquePoints) => {
   })
 
   // sort by polar coordinates
-  points.sort((pt1, pt2) => pt1.angle < pt2.angle ? -1 : pt1.angle > pt2.angle ? 1 :
-    pt1.distSq < pt2.distSq ? -1 : pt1.distSq > pt2.distSq ? 1 : 0)
+  points.sort((pt1, pt2) => pt1.angle !== pt2.angle
+    ? pt1.angle - pt2.angle
+    : pt1.distSq - pt2.distSq)
 
   const stack = [] // start with empty stack
   points.forEach((point) => {

package/src/operations/modifiers/index.js

@@ -8,5 +8,5 @@
 module.exports = {
   generalize: require('./generalize'),
   snap: require('./snap'),
-  retessellate: require('./retessellate'),
+  retessellate: require('./retessellate')
 }

package/src/operations/modifiers/retessellate.js

@@ -1,18 +1,8 @@
 const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
-
-const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
-
+const { NEPS } = require('../../maths/constants')
 const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
 
-const coplanar = (plane1, plane2) => {
-  // expect the same distance from the origin, within tolerance
-  if (Math.abs(plane1[3] - plane2[3]) < 0.00000015) {
-    return aboutEqualNormals(plane1, plane2)
-  }
-  return false
-}
-
 /*
   After boolean operations all coplanar polygon fragments are joined by a retesselating
   operation. geom3.reTesselate(geom).
@@ -26,29 +16,78 @@ const retessellate = (geometry) => {
     return geometry
   }
 
-  const polygons = geom3.toPolygons(geometry)
-  const polygonsPerPlane = [] // elements: [plane, [poly3...]]
-  polygons.forEach((polygon) => {
-    const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon)))
-    if (mapping) {
-      const polygons = mapping[1]
-      polygons.push(polygon)
+  const polygons = geom3.toPolygons(geometry).map((polygon, index) => ({ vertices: polygon.vertices, plane: poly3.plane(polygon), index: index }))
+  const classified = classifyPolygons(polygons)
+
+  const destPolygons = []
+  classified.forEach((group) => {
+    if (Array.isArray(group)) {
+      const reTessellateCoplanarPolygons = reTesselateCoplanarPolygons(group)
+      destPolygons.push(...reTessellateCoplanarPolygons)
     } else {
-      polygonsPerPlane.push([poly3.plane(polygon), [polygon]])
+      destPolygons.push(group)
     }
   })
 
-  let destpolygons = []
-  polygonsPerPlane.forEach((mapping) => {
-    const sourcepolygons = mapping[1]
-    const retesselayedpolygons = reTesselateCoplanarPolygons(sourcepolygons)
-    destpolygons = destpolygons.concat(retesselayedpolygons)
-  })
-
-  const result = geom3.create(destpolygons)
+  const result = geom3.create(destPolygons)
   result.isRetesselated = true
 
   return result
 }
 
+const classifyPolygons = (polygons) => {
+  let clusters = [polygons] // a cluster is an array of potentially coplanar polygons
+  const nonCoplanar = [] // polygons that are known to be non-coplanar
+  // go through each component of the plane starting with the last one (the distance from origin)
+  for (let component = 3; component >= 0; component--) {
+    const maybeCoplanar = []
+    const tolerance = component === 3 ? 0.000000015 : NEPS
+    clusters.forEach((cluster) => {
+      // sort the cluster by the current component
+      cluster.sort(byPlaneComponent(component, tolerance))
+      // iterate through the cluster and check if there are polygons which are not coplanar with the others
+      // or if there are sub-clusters of coplanar polygons
+      let startIndex = 0
+      for (let i = 1; i < cluster.length; i++) {
+        // if there's a difference larger than the tolerance, split the cluster
+        if (cluster[i].plane[component] - cluster[startIndex].plane[component] > tolerance) {
+          // if there's a single polygon it's definitely not coplanar with any others
+          if (i - startIndex === 1) {
+            nonCoplanar.push(cluster[startIndex])
+          } else { // we have a new sub cluster of potentially coplanar polygons
+            maybeCoplanar.push(cluster.slice(startIndex, i))
+          }
+          startIndex = i
+        }
+      }
+      // handle the last elements of the cluster
+      if (cluster.length - startIndex === 1) {
+        nonCoplanar.push(cluster[startIndex])
+      } else {
+        maybeCoplanar.push(cluster.slice(startIndex))
+      }
+    })
+    // replace previous clusters with the new ones
+    clusters = maybeCoplanar
+  }
+  // restore the original order of the polygons
+  const result = []
+  // polygons inside the cluster should already be sorted by index
+  clusters.forEach((cluster) => {
+    if (cluster[0]) result[cluster[0].index] = cluster
+  })
+  nonCoplanar.forEach((polygon) => { result[polygon.index] = polygon })
+
+  return result
+}
+
+const byPlaneComponent = (component, tolerance) => (a, b) => {
+  if (a.plane[component] - b.plane[component] > tolerance) {
+    return 1
+  } else if (b.plane[component] - a.plane[component] > tolerance) {
+    return -1
+  }
+  return 0
+}
+
 module.exports = retessellate

package/src/primitives/circle.js

@@ -2,7 +2,7 @@ const { TAU } = require('../maths/constants')
 
 const ellipse = require('./ellipse')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a circle in two dimensional space where all points are at the same distance from the center.
@@ -28,7 +28,7 @@ const circle = (options) => {
   }
   let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
 
   radius = [radius, radius]
 

package/src/primitives/circle.test.js

@@ -146,3 +146,10 @@ test('circle (options)', (t) => {
   t.deepEqual(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
+
+test('circle (radius zero)', (t) => {
+  const geometry = circle({ radius: 0 })
+  const pts = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(pts.length, 0)
+})

package/src/primitives/cube.js

@@ -1,6 +1,6 @@
 const cuboid = require('./cuboid')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct an axis-aligned solid cube in three dimensional space with six square faces.
@@ -20,7 +20,7 @@ const cube = (options) => {
   }
   let { center, size } = Object.assign({}, defaults, options)
 
-  if (!isGT(size, 0)) throw new Error('size must be greater than zero')
+  if (!isGTE(size, 0)) throw new Error('size must be positive')
 
   size = [size, size, size]
 

package/src/primitives/cube.test.js

@@ -46,3 +46,10 @@ test('cube (options)', (t) => {
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('cube (zero size)', (t) => {
+  const obs = cube({ size: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cuboid.js

@@ -23,7 +23,10 @@ const cuboid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of width, depth and height values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom3.create()
 
   const result = geom3.create(
     // adjust a basic shape to size

package/src/primitives/cuboid.test.js

@@ -55,3 +55,10 @@ test('cuboid (options)', (t) => {
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('cuboid (zero size)', (t) => {
+  const obs = cuboid({ size: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/cylinder.js

@@ -1,6 +1,8 @@
+const geom3 = require('../geometries/geom3')
+
 const cylinderElliptic = require('./cylinderElliptic')
 
-const { isGT } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a Z axis-aligned cylinder in three dimensional space.
@@ -25,7 +27,10 @@ const cylinder = (options) => {
   }
   const { center, height, radius, segments } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+
+  // if size is zero return empty geometry
+  if (height === 0 || radius === 0) return geom3.create()
 
   const newoptions = {
     center,

package/src/primitives/cylinder.test.js

@@ -14,6 +14,20 @@ test('cylinder (defaults)', (t) => {
   t.is(pts.length, 96)
 })
 
+test('cylinder (zero height)', (t) => {
+  const obs = cylinder({ height: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('cylinder (zero radius)', (t) => {
+  const obs = cylinder({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
 test('cylinder (options)', (t) => {
   let obs = cylinder({ height: 10, radius: 4, segments: 5 })
   let pts = geom3.toPoints(obs)

package/src/primitives/ellipse.js

@@ -34,11 +34,14 @@ const ellipse = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(radius, 2)) throw new Error('radius must be an array of X and Y values')
-  if (!radius.every((n) => n > 0)) throw new Error('radius values must be greater than zero')
+  if (!radius.every((n) => n >= 0)) throw new Error('radius values must be positive')
   if (!isGTE(startAngle, 0)) throw new Error('startAngle must be positive')
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 3)) throw new Error('segments must be three or more')
 
+  // if any radius is zero return empty geometry
+  if (radius[0] === 0 || radius[1] === 0) return geom2.create()
+
   startAngle = startAngle % TAU
   endAngle = endAngle % TAU
 

package/src/primitives/ellipse.test.js

@@ -137,3 +137,10 @@ test('ellipse (options)', (t) => {
   t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(obs.length, 72)
 })
+
+test('ellipse (zero radius)', (t) => {
+  const geometry = ellipse({ radius: [1, 0] })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/ellipsoid.js

@@ -32,9 +32,12 @@ const ellipsoid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(radius, 3)) throw new Error('radius must be an array of X, Y and Z values')
-  if (!radius.every((n) => n > 0)) throw new Error('radius values must be greater than zero')
+  if (!radius.every((n) => n >= 0)) throw new Error('radius values must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if any radius is zero return empty geometry
+  if (radius[0] === 0 || radius[1] === 0 || radius[2] === 0) return geom3.create()
+
   const xvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[0]), radius[0])
   const yvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[1]), radius[1])
   const zvector = vec3.scale(vec3.create(), vec3.normalize(vec3.create(), axes[2]), radius[2])

package/src/primitives/ellipsoid.test.js

@@ -207,3 +207,10 @@ test('ellipsoid (options)', (t) => {
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
+
+test('ellipsoid (zero radius)', (t) => {
+  const obs = ellipsoid({ radius: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/geodesicSphere.js

@@ -5,7 +5,7 @@ const geom3 = require('../geometries/geom3')
 
 const polyhedron = require('./polyhedron')
 
-const { isGT, isGTE } = require('./commonChecks')
+const { isGTE } = require('./commonChecks')
 
 /**
  * Construct a geodesic sphere based on icosahedron symmetry.
@@ -25,9 +25,12 @@ const geodesicSphere = (options) => {
   }
   let { radius, frequency } = Object.assign({}, defaults, options)
 
-  if (!isGT(radius, 0)) throw new Error('radius must be greater than zero')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
   if (!isGTE(frequency, 6)) throw new Error('frequency must be six or more')
 
+  // if radius is zero return empty geometry
+  if (radius === 0) return geom3.create()
+
   // adjust the frequency to base 6
   frequency = Math.floor(frequency / 6)
 

package/src/primitives/geodesicSphere.test.js

@@ -51,3 +51,10 @@ test('geodesicSphere (options)', (t) => {
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 180)
 })
+
+test('geodesicSphere (zero radius)', (t) => {
+  const obs = geodesicSphere({ radius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})

package/src/primitives/rectangle.js

@@ -24,7 +24,10 @@ const rectangle = (options) => {
 
   if (!isNumberArray(center, 2)) throw new Error('center must be an array of X and Y values')
   if (!isNumberArray(size, 2)) throw new Error('size must be an array of X and Y values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0) return geom2.create()
 
   const point = [size[0] / 2, size[1] / 2]
   const pswap = [point[0], -point[1]]

package/src/primitives/rectangle.test.js

@@ -50,3 +50,10 @@ test('rectangle (options)', (t) => {
   t.deepEqual(obs.length, 4)
   t.true(comparePoints(obs, exp))
 })
+
+test('rectangle (zero size)', (t) => {
+  const geometry = rectangle({ size: [1, 0] })
+  const obs = geom2.toPoints(geometry)
+  t.notThrows(() => geom2.validate(geometry))
+  t.is(obs.length, 0)
+})

package/src/primitives/roundedCuboid.js

@@ -8,7 +8,8 @@ const poly3 = require('../geometries/poly3')
 
 const { sin, cos } = require('../maths/utils/trigonometry')
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+const { isGTE, isNumberArray } = require('./commonChecks')
+const cuboid = require('./cuboid')
 
 const createCorners = (center, size, radius, segments, slice, positive) => {
   const pitch = (TAU / 4) * slice / segments
@@ -135,10 +136,16 @@ const roundedCuboid = (options) => {
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
   if (!isNumberArray(size, 3)) throw new Error('size must be an array of X, Y and Z values')
-  if (!size.every((n) => n > 0)) throw new Error('size values must be greater than zero')
-  if (!isGT(roundRadius, 0)) throw new Error('roundRadius must be greater than zero')
+  if (!size.every((n) => n >= 0)) throw new Error('size values must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if any size is zero return empty geometry
+  if (size[0] === 0 || size[1] === 0 || size[2] === 0) return geom3.create()
+
+  // if roundRadius is zero, return cuboid
+  if (roundRadius === 0) return cuboid({ center, size })
+
   size = size.map((v) => v / 2) // convert to radius
 
   if (roundRadius > (size[0] - EPS) ||

package/src/primitives/roundedCuboid.test.js

@@ -14,6 +14,20 @@ test('roundedCuboid (defaults)', (t) => {
   t.deepEqual(pts.length, 614)
 })
 
+test('roundedCuboid (zero size)', (t) => {
+  const obs = roundedCuboid({ size: [1, 1, 0] })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 0)
+})
+
+test('roundedCuboid (zero radius)', (t) => {
+  const obs = roundedCuboid({ roundRadius: 0 })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.deepEqual(pts.length, 6)
+})
+
 test('roundedCuboid (options)', (t) => {
   // test segments
   let obs = roundedCuboid({ segments: 8 })

package/src/primitives/roundedCylinder.js

@@ -7,7 +7,8 @@ const poly3 = require('../geometries/poly3')
 
 const { sin, cos } = require('../maths/utils/trigonometry')
 
-const { isGT, isGTE, isNumberArray } = require('./commonChecks')
+const { isGTE, isNumberArray } = require('./commonChecks')
+const cylinder = require('./cylinder')
 
 /**
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
@@ -34,12 +35,18 @@ const roundedCylinder = (options) => {
   const { center, height, radius, roundRadius, segments } = Object.assign({}, defaults, options)
 
   if (!isNumberArray(center, 3)) throw new Error('center must be an array of X, Y and Z values')
-  if (!isGT(height, 0)) throw new Error('height must be greater then zero')
-  if (!isGT(radius, 0)) throw new Error('radius must be greater then zero')
-  if (!isGT(roundRadius, 0)) throw new Error('roundRadius must be greater then zero')
-  if (roundRadius > (radius - EPS)) throw new Error('roundRadius must be smaller then the radius')
+  if (!isGTE(height, 0)) throw new Error('height must be positive')
+  if (!isGTE(radius, 0)) throw new Error('radius must be positive')
+  if (!isGTE(roundRadius, 0)) throw new Error('roundRadius must be positive')
+  if (roundRadius > radius) throw new Error('roundRadius must be smaller then the radius')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
+  // if size is zero return empty geometry
+  if (height === 0 || radius === 0) return geom3.create()
+
+  // if roundRadius is zero, return cylinder
+  if (roundRadius === 0) return cylinder({ center, height, radius })
+
   const start = [0, 0, -(height / 2)]
   const end = [0, 0, height / 2]
   const direction = vec3.subtract(vec3.create(), end, start)