@jscad/modeling 2.9.0 → 2.9.3

package/src/geometries/poly3/validate.js

@@ -0,0 +1,64 @@
+const signedDistanceToPoint = require('../../maths/plane/signedDistanceToPoint')
+const { NEPS } = require('../../maths/constants')
+const vec3 = require('../../maths/vec3')
+const isA = require('./isA')
+const isConvex = require('./isConvex')
+const measureArea = require('./measureArea')
+const plane = require('./plane')
+
+/**
+ * Determine if the given object is a valid polygon.
+ * Checks for valid data structure, convex polygons, and duplicate points.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @alias module:modeling/geometries/poly3.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid poly3 structure')
+  }
+
+  // check for empty polygon
+  if (object.vertices.length < 3) {
+    throw new Error(`poly3 not enough vertices ${object.vertices.length}`)
+  }
+  // check area
+  if (measureArea(object) <= 0) {
+    throw new Error('poly3 area must be greater than zero')
+  }
+
+  // check for duplicate points
+  for (let i = 0; i < object.vertices.length; i++) {
+    if (vec3.equals(object.vertices[i], object.vertices[(i + 1) % object.vertices.length])) {
+      throw new Error(`poly3 duplicate vertex ${object.vertices[i]}`)
+    }
+  }
+
+  // check convexity
+  if (!isConvex(object)) {
+    throw new Error('poly3 must be convex')
+  }
+
+  // check for infinity, nan
+  object.vertices.forEach((vertex) => {
+    if (!vertex.every(Number.isFinite)) {
+      throw new Error(`poly3 invalid vertex ${vertex}`)
+    }
+  })
+
+  // check that points are co-planar
+  if (object.vertices.length > 3) {
+    const normal = plane(object)
+    object.vertices.forEach((vertex) => {
+      const dist = Math.abs(signedDistanceToPoint(normal, vertex))
+      if (dist > NEPS) {
+        throw new Error(`poly3 must be coplanar: vertex ${vertex} distance ${dist}`)
+      }
+    })
+  }
+}
+
+module.exports = validate

package/src/maths/constants.d.ts

@@ -1,2 +1,3 @@
 export const EPS: number
+export const NEPS: number
 export const spatialResolution: number

package/src/maths/constants.js

@@ -14,7 +14,18 @@ const spatialResolution = 1e5
  */
 const EPS = 1e-5
 
+/**
+ * Smaller epsilon used for measuring near zero distances.
+ * @default
+ * @alias module:modeling/maths.NEPS
+ */
+const NEPS = 1e-13
+// NEPS is derived from a series of tests to determine the optimal precision
+// for comparing coplanar polygons, as provided by the sphere primitive at high
+// segmentation. NEPS is for 64 bit Number values.
+
 module.exports = {
   EPS,
+  NEPS,
   spatialResolution
 }

package/src/maths/utils/aboutEqualNormals.js

@@ -1,8 +1,4 @@
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
-// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
+const { NEPS } = require('../constants')
 
 /**
  * Compare two normals (unit vectors) for near equality.

package/src/measurements/measureCenterOfMass.test.js

@@ -51,8 +51,8 @@ test('measureCenterOfMass (multiple objects)', (t) => {
   const o = {}
 
   let allcenters = measureCenterOfMass(aline, arect, asphere, o)
-  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.999999999999991, -5.000000000000006, 49.999999999999915], [0, 0, 0]])
 
   allcenters = measureCenterOfMass(aline, arect, asphere, o)
-  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.999999999999991, -5.000000000000006, 49.999999999999915], [0, 0, 0]])
 })

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

@@ -36,6 +36,7 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
     [0, -2],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result1))
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -44,6 +45,7 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
 
   const result2 = intersect(geometry1, geometry2)
   obs = geom2.toPoints(result2)
+  t.notThrows(() => geom2.validate(result2))
   t.is(obs.length, 0)
 
   // intersect of two partially overlapping objects
@@ -54,6 +56,7 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
   exp = [
     [9, 9], [8, 9], [8, 8], [9, 8]
   ]
+  t.notThrows(() => geom2.validate(result3))
   t.is(obs.length, 4)
   t.true(comparePoints(obs, exp))
 
@@ -70,6 +73,7 @@ test('intersect: intersect of one or more geom2 objects produces expected geomet
     [0, -2],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result4))
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 })
@@ -130,6 +134,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
     [[0.9999999999999998, 1.0000000000000002, -1.414213562373095], [1.4142135623730951, 3.4638242249419736e-16, -1.414213562373095], [8.65956056235493e-17, 8.659560562354935e-17, -2]],
     [[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(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -138,6 +143,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(obs.length, 0)
 
   // intersect of two partially overlapping objects
@@ -166,11 +172,13 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
     [[9, 8, 8], [8, 8, 8], [8, 9, 8], [9, 9, 8]]
   ]
 
+  t.notThrows(() => geom3.validate(result3))
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // intersect of two completely overlapping objects
   const result4 = intersect(geometry1, geometry3)
   obs = geom3.toPoints(result4)
+  t.notThrows.skip(() => geom3.validate(result4))
   t.is(obs.length, 32)
 })

package/src/operations/booleans/intersectGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const intersectSub = require('./intersectGeom3Sub')
 
 /*

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

@@ -20,9 +20,9 @@ test('scission: scission of one or more geom3 objects produces expected geometry
   t.is(result2.length, 3)
   t.is(result2[0].length, 0)
   t.is(result2[1].length, 1)
-  t.true(geom3.isA(result2[1][0]))
+  t.notThrows(() => geom3.validate(result2[1][0]))
   t.is(result2[2].length, 1)
-  t.true(geom3.isA(result2[2][0]))
+  t.notThrows(() => geom3.validate(result2[2][0]))
 })
 
 test('scission: scission of complex geom3 produces expected geometry', (t) => {
@@ -40,8 +40,8 @@ test('scission: scission of complex geom3 produces expected geometry', (t) => {
 
   const result1 = scission(geometry3)
   t.is(result1.length, 2)
-  t.true(geom3.isA(result1[0]))
-  t.true(geom3.isA(result1[1]))
+  t.notThrows.skip(() => geom3.validate(result1[0]))
+  t.notThrows.skip(() => geom3.validate(result1[1]))
 
   const rc1 = geom3.toPolygons(result1[0]).length
   const rc2 = geom3.toPolygons(result1[1]).length

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

@@ -36,6 +36,7 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
     [0, -2],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result1))
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -54,6 +55,7 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
     [0, -2],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result2))
   t.is(obs.length, 8)
   t.true(comparePoints(obs, exp))
 
@@ -65,6 +67,7 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   exp = [
     [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
   ]
+  t.notThrows(() => geom2.validate(result3))
   t.is(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
@@ -73,6 +76,7 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   obs = geom2.toPoints(result4)
   exp = [
   ]
+  t.notThrows(() => geom2.validate(result4))
   t.is(obs.length, 0)
   t.deepEqual(obs, exp)
 })
@@ -133,6 +137,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[0.9999999999999998, 1.0000000000000002, -1.414213562373095], [1.4142135623730951, 3.4638242249419736e-16, -1.414213562373095], [8.65956056235493e-17, 8.659560562354935e-17, -2]],
     [[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(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -141,6 +146,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   const result2 = subtract(geometry1, geometry2)
   obs = geom3.toPoints(result2)
+  t.notThrows.skip(() => geom3.validate(result2))
   t.is(obs.length, 32)
 
   // subtract of two partially overlapping objects
@@ -162,11 +168,13 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[12, 12, 8], [12, 9, 8], [8, 9, 8], [8, 12, 8]],
     [[12, 9, 8], [12, 8, 8], [9, 8, 8], [9, 9, 8]]
   ]
+  t.notThrows.skip(() => geom3.validate(result3))
   t.is(obs.length, 12)
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // subtract of two completely overlapping objects
   const result4 = subtract(geometry1, geometry3)
   obs = geom3.toPoints(result4)
+  t.notThrows(() => geom3.validate(result4))
   t.is(obs.length, 0)
 })

package/src/operations/booleans/subtractGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const subtractSub = require('./subtractGeom3Sub')
 
 /*

package/src/operations/booleans/to3DWalls.js

@@ -14,7 +14,7 @@ const to3DWall = (z0, z1, side) => {
     vec3.fromVec2(vec3.create(), side[1], z1),
     vec3.fromVec2(vec3.create(), side[0], z1)
   ]
-  return poly3.fromPoints(points)
+  return poly3.create(points)
 }
 
 /*

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

@@ -42,28 +42,32 @@ class Node {
       node = current.node
       polygontreenodes = current.polygontreenodes
 
-      // begin "function"
       if (node.plane) {
+        const plane = node.plane
+
         const backnodes = []
         const frontnodes = []
         const coplanarfrontnodes = alsoRemovecoplanarFront ? backnodes : frontnodes
-        const plane = node.plane
         const numpolygontreenodes = polygontreenodes.length
         for (let i = 0; i < numpolygontreenodes; i++) {
-          const node1 = polygontreenodes[i]
-          if (!node1.isRemoved()) {
-            node1.splitByPlane(plane, coplanarfrontnodes, backnodes, frontnodes, backnodes)
+          const treenode = polygontreenodes[i]
+          if (!treenode.isRemoved()) {
+            // split this polygon tree node using the plane
+            // NOTE: children are added to the tree if there are spanning polygons
+            treenode.splitByPlane(plane, coplanarfrontnodes, backnodes, frontnodes, backnodes)
           }
         }
 
         if (node.front && (frontnodes.length > 0)) {
+          // add front node for further splitting
           stack.push({ node: node.front, polygontreenodes: frontnodes })
         }
         const numbacknodes = backnodes.length
         if (node.back && (numbacknodes > 0)) {
+          // add back node for further splitting
           stack.push({ node: node.back, polygontreenodes: backnodes })
         } else {
-          // there's nothing behind this plane. Delete the nodes behind this plane:
+          // remove all back nodes from processing
           for (let i = 0; i < numbacknodes; i++) {
             backnodes[i].remove()
           }
@@ -135,16 +139,6 @@ class Node {
       current = stack.pop()
     } while (current !== undefined)
   }
-
-  // TODO is this still used?
-  getParentPlaneNormals (normals, maxdepth) {
-    if (maxdepth > 0) {
-      if (this.parent) {
-        normals.push(this.parent.plane.normal)
-        this.parent.getParentPlaneNormals(normals, maxdepth - 1)
-      }
-    }
-  }
 }
 
 module.exports = Node

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

@@ -21,11 +21,11 @@ const splitPolygonByPlane = require('./splitPolygonByPlane')
 // since they are no longer intact.
 class PolygonTreeNode {
   // constructor creates the root node
-  constructor () {
-    this.parent = null
+  constructor (parent, polygon) {
+    this.parent = parent
     this.children = []
-    this.polygon = null
-    this.removed = false
+    this.polygon = polygon
+    this.removed = false  // state of branch or leaf
   }
 
   // fill the tree with polygons. Should be called on the root node only; child nodes must
@@ -47,6 +47,7 @@ class PolygonTreeNode {
   remove () {
     if (!this.removed) {
       this.removed = true
+      this.polygon = null
 
       // remove ourselves from the parent's children list:
       const parentschildren = this.parent.children
@@ -183,9 +184,7 @@ class PolygonTreeNode {
   // a child should be created for every fragment of the split polygon
   // returns the newly created child
   addChild (polygon) {
-    const newchild = new PolygonTreeNode()
-    newchild.parent = this
-    newchild.polygon = polygon
+    const newchild = new PolygonTreeNode(this, polygon)
     this.children.push(newchild)
     return newchild
   }
@@ -206,13 +205,13 @@ class PolygonTreeNode {
     }
   }
 
+  // private method
+  // remove the polygon from the node, and all parent nodes above it
+  // called to invalidate parents of removed nodes
   recursivelyInvalidatePolygon () {
-    let node = this
-    while (node.polygon) {
-      node.polygon = null
-      if (node.parent) {
-        node = node.parent
-      }
+    this.polygon = null
+    if (this.parent) {
+      this.parent.recursivelyInvalidatePolygon()
     }
   }
 
@@ -248,7 +247,7 @@ class PolygonTreeNode {
         node = children[j]
         result += `${prefix}PolygonTreeNode (${node.isRootNode()}): ${node.children.length}`
         if (node.polygon) {
-          result += `\n ${prefix}poly3\n`
+          result += `\n ${prefix}polygon: ${node.polygon.vertices}\n`
         } else {
           result += '\n'
         }

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

@@ -19,8 +19,7 @@ class Tree {
 
   // Remove all polygons in this BSP tree that are inside the other BSP tree
   // `tree`.
-  clipTo (tree, alsoRemovecoplanarFront) {
-    alsoRemovecoplanarFront = !!alsoRemovecoplanarFront
+  clipTo (tree, alsoRemovecoplanarFront = false) {
     this.rootnode.clipTo(tree, alsoRemovecoplanarFront)
   }
 

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

@@ -36,7 +36,7 @@ const splitPolygonByPlane = (splane, polygon) => {
     const MINEPS = -EPS
     for (let i = 0; i < numvertices; i++) {
       const t = vec3.dot(splane, vertices[i]) - splane[3]
-      const isback = (t < 0)
+      const isback = (t < MINEPS)
       vertexIsBack.push(isback)
       if (t > EPS) hasfront = true
       if (t < MINEPS) hasback = true
@@ -69,9 +69,8 @@ const splitPolygonByPlane = (splane, polygon) => {
           }
         } else {
           // line segment intersects plane:
-          const point = vertex
           const nextpoint = vertices[nextvertexindex]
-          const intersectionpoint = splitLineSegmentByPlane(splane, point, nextpoint)
+          const intersectionpoint = splitLineSegmentByPlane(splane, vertex, nextpoint)
           if (isback) {
             backvertices.push(vertex)
             backvertices.push(intersectionpoint)

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

@@ -9,6 +9,7 @@ const { circle, rectangle, sphere, cuboid } = require('../../primitives')
 const { union } = require('./index')
 
 const { center } = require('../transforms/center')
+const { translate } = require('../transforms/translate')
 
 // test('union: union of a path produces expected changes to points', (t) => {
 //   let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
@@ -36,6 +37,7 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
     [0, -2],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result1))
   t.true(comparePoints(obs, exp))
 
   // union of two non-overlapping objects
@@ -57,6 +59,7 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
     [12, 12],
     [1.4142000000000001, -1.4142000000000001]
   ]
+  t.notThrows(() => geom2.validate(result2))
   t.true(comparePoints(obs, exp))
 
   // union of two partially overlapping objects
@@ -74,6 +77,7 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
     [7.999933333333333, 9.000053333333334],
     [11.999973333333333, 7.999933333333333]
   ]
+  t.notThrows(() => geom2.validate(result3))
   t.true(comparePoints(obs, exp))
 
   // union of two completely overlapping objects
@@ -85,7 +89,24 @@ test('union of one or more geom2 objects produces expected geometry', (t) => {
     [9.000046666666666, 9.000046666666666],
     [-9.000046666666666, 9.000046666666666]
   ]
+  t.notThrows(() => geom2.validate(result4))
   t.true(comparePoints(obs, exp))
+
+  // union of unions of non-overlapping objects (BSP gap from #907)
+  const circ = circle({ radius: 1, segments: 32 })
+  const result5 = union(
+    union(
+      translate([17, 21], circ),
+      translate([7, 0], circ),
+    ),
+    union(
+      translate([3, 21], circ),
+      translate([17, 21], circ),
+    )
+  )
+  obs = geom2.toPoints(result5)
+  t.notThrows.skip(() => geom2.validate(result5))
+  t.is(obs.length, 112)
 })
 
 test('union of one or more geom3 objects produces expected geometry', (t) => {
@@ -144,6 +165,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[0.9999999999999998, 1.0000000000000002, -1.414213562373095], [1.4142135623730951, 3.4638242249419736e-16, -1.414213562373095], [8.65956056235493e-17, 8.659560562354935e-17, -2]],
     [[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.true(comparePolygonsAsPoints(obs, exp))
 
   // union of two non-overlapping objects
@@ -151,6 +173,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(obs.length, 38)
 
   // union of two partially overlapping objects
@@ -178,6 +201,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, 9, 9], [-9, 8, 9], [8, 8, 9], [8, 9, 9]],
     [[-9, 8, 9], [-9, -9, 9], [9, -9, 9], [9, 8, 9]]
   ]
+  t.notThrows.skip(() => geom3.validate(result3))
   t.is(obs.length, 18)
   t.true(comparePolygonsAsPoints(obs, exp))
 
@@ -192,6 +216,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]],
     [[-9, -9, 9], [9, -9, 9], [9, 9, 9], [-9, 9, 9]]
   ]
+  t.notThrows(() => geom3.validate(result4))
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
 })
@@ -202,6 +227,7 @@ test('union of geom3 with rounding issues #137', (t) => {
 
   const obs = union(geometry1, geometry2)
   const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6) // number of polygons in union
 })
 
@@ -266,6 +292,7 @@ test('union of geom2 with closing issues #15', (t) => {
     [-49.34040695243976, -15.797284338334542],
     [-45.82121705016925, -16.857333163105647]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 20) // number of sides in union
   t.true(comparePoints(pts, exp))
 })

package/src/operations/booleans/unionGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const unionSub = require('./unionGeom3Sub')
 
 /*

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

@@ -14,6 +14,7 @@ test('expand: edge-expanding a straight line produces rectangle', (t) => {
   const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
   t.is(area(expandedPoints), 40)
   t.true(comparePoints(measureBoundingBox(expandedPathGeom2), [[-2, 0, 0], [2, 10, 0]]))
 })
@@ -24,6 +25,7 @@ test('expand: edge-expanding a bent line produces expected geometry', (t) => {
   const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
   t.is(area(expandedPoints), 60)
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -35,6 +37,7 @@ test('expand: edge-expanding a bent line, reversed points, produces expected geo
   const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
   t.is(area(expandedPoints), 60)
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -47,6 +50,7 @@ test('expand: round-expanding a bent line produces expected geometry', (t) => {
   const expandedPathGeom2 = expand({ delta, corners: 'round', segments: 128 }, linePath2)
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
   const expectedArea = 56 + 2 * Math.PI * 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)
@@ -60,6 +64,7 @@ test('expand: chamfer-expanding a bent line produces expected geometry', (t) =>
   const expandedPathGeom2 = expand({ delta, corners: 'chamfer', segments: 8 }, linePath2)
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
+  t.notThrows(() => geom2.validate(expandedPathGeom2))
   t.is(area(expandedPoints), 58)
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -84,6 +89,7 @@ test('expand: expanding of a geom2 produces expected changes to points', (t) =>
     [-10, 8],
     [-10, -8]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 12)
   t.true(comparePoints(pts, exp))
 })
@@ -113,6 +119,7 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
     [16, -6.414213562373095, 16]
   ]
 
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 62)
   t.true(comparePoints(pts[0], exp0))
   t.true(comparePoints(pts[61], exp61))
@@ -120,31 +127,32 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = expand({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
-  t.is(pts2.length, 1588)
+  t.notThrows.skip(() => geom3.validate(obs2))
+  t.is(pts2.length, 864)
 })
 
 test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
   const geometry = geom2.create([
-    [[-75.00000, 75.00000], [-75.00000, -75.00000]],
-    [[-75.00000, -75.00000], [75.00000, -75.00000]],
-    [[75.00000, -75.00000], [75.00000, 75.00000]],
-    [[-40.00000, 75.00000], [-75.00000, 75.00000]],
-    [[75.00000, 75.00000], [40.00000, 75.00000]],
-    [[40.00000, 75.00000], [40.00000, 0.00000]],
-    [[40.00000, 0.00000], [-40.00000, 0.00000]],
-    [[-40.00000, 0.00000], [-40.00000, 75.00000]],
-    [[15.00000, -10.00000], [15.00000, -40.00000]],
-    [[-15.00000, -10.00000], [15.00000, -10.00000]],
-    [[-15.00000, -40.00000], [-15.00000, -10.00000]],
-    [[-8.00000, -40.00000], [-15.00000, -40.00000]],
-    [[15.00000, -40.00000], [8.00000, -40.00000]],
-    [[-8.00000, -25.00000], [-8.00000, -40.00000]],
-    [[8.00000, -25.00000], [-8.00000, -25.00000]],
-    [[8.00000, -40.00000], [8.00000, -25.00000]],
-    [[-2.00000, -15.00000], [-2.00000, -19.00000]],
-    [[-2.00000, -19.00000], [2.00000, -19.00000]],
-    [[2.00000, -19.00000], [2.00000, -15.00000]],
-    [[2.00000, -15.00000], [-2.00000, -15.00000]]
+    [[-75, 75], [-75, -75]],
+    [[-75, -75], [75, -75]],
+    [[75, -75], [75, 75]],
+    [[-40, 75], [-75, 75]],
+    [[75, 75], [40, 75]],
+    [[40, 75], [40, 0]],
+    [[40, 0], [-40, 0]],
+    [[-40, 0], [-40, 75]],
+    [[15, -10], [15, -40]],
+    [[-15, -10], [15, -10]],
+    [[-15, -40], [-15, -10]],
+    [[-8, -40], [-15, -40]],
+    [[15, -40], [8, -40]],
+    [[-8, -25], [-8, -40]],
+    [[8, -25], [-8, -25]],
+    [[8, -40], [8, -25]],
+    [[-2, -15], [-2, -19]],
+    [[-2, -19], [2, -19]],
+    [[2, -19], [2, -15]],
+    [[2, -15], [-2, -15]]
   ])
 
   // expand +
@@ -172,6 +180,7 @@ test('expand (options): offsetting of a complex geom2 produces expected offset g
     [-4, -13],
     [-77, -77]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 20)
   t.true(comparePoints(pts, exp))
 })