@jscad/modeling 2.8.0 → 2.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.8.0",
+  "version": "2.9.2",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -60,5 +60,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "92fb9c75eb070fca5f5ee8c2bab6614b1f54514e"
+  "gitHead": "0cebde0166c104e3c08cc05d2c03d9defc7eca26"
 }

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

@@ -10,6 +10,7 @@ export { default as toSides } from './toSides'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Geom2 } from './type'
 export as namespace geom2

package/src/geometries/geom2/index.js

@@ -25,5 +25,6 @@ module.exports = {
   toSides: require('./toSides'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/geom2/validate.d.ts

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/geom2/validate.js

@@ -0,0 +1,36 @@
+const vec2 = require('../../maths/vec2')
+const isA = require('./isA')
+const toOutlines = require('./toOutlines')
+
+/**
+ * Determine if the given object is a valid geom2.
+ * Checks for closedness, self-edges, and valid data 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/geom2.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid geom2 structure')
+  }
+
+  // check for closedness
+  toOutlines(object)
+
+  // check for self-edges
+  object.sides.forEach((side) => {
+    if (vec2.equals(side[0], side[1])) {
+      throw new Error(`geom2 self-edge ${side[0]}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`geom2 invalid transforms ${object.transforms}`)
+  }
+}
+
+module.exports = validate

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

@@ -9,6 +9,7 @@ export { default as toPolygons } from './toPolygons'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Geom3 } from './type'
 export as namespace geom3

package/src/geometries/geom3/index.js

@@ -31,5 +31,6 @@ module.exports = {
   toPolygons: require('./toPolygons'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/geom3/isA.js

@@ -1,6 +1,6 @@
 /**
  * Determine if the given object is a 3D geometry.
- * @param {object} object - the object to interrogate
+ * @param {Object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a geom3
  * @alias module:modeling/geometries/geom3.isA
  */

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

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/geom3/validate.js

@@ -0,0 +1,62 @@
+const poly3 = require('../poly3')
+const isA = require('./isA')
+
+/**
+ * Determine if the given object is a valid 3D geometry.
+ * Checks for valid data structure, convex polygon faces, and manifold edges.
+ *
+ * **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/geom3.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid geom3 structure')
+  }
+
+  // check polygons
+  object.polygons.forEach(poly3.validate)
+  validateManifold(object)
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`geom3 invalid transforms ${object.transforms}`)
+  }
+
+  // TODO: check for self-intersecting
+}
+
+/*
+ * Check manifold edge condition: Every edge is in exactly 2 faces
+ */
+const validateManifold = (object) => {
+  // count of each edge
+  const edgeCount = new Map()
+  object.polygons.forEach(({ vertices }) => {
+    vertices.forEach((v, i) => {
+      const v1 = `${v}`
+      const v2 = `${vertices[(i + 1) % vertices.length]}`
+      // sort for undirected edge
+      const edge = `${v1}/${v2}`
+      const count = edgeCount.has(edge) ? edgeCount.get(edge) : 0
+      edgeCount.set(edge, count + 1)
+    })
+  })
+
+  // check that edges are always matched
+  const nonManifold = []
+  edgeCount.forEach((count, edge) => {
+    const complementEdge = edge.split('/').reverse().join('/')
+    const complementCount = edgeCount.get(complementEdge)
+    if (count !== complementCount) {
+      nonManifold.push(edge.replace('/', ' -> '))
+    }
+  })
+  if (nonManifold.length > 0) {
+    throw new Error(`non-manifold edges ${nonManifold.length}\n${nonManifold.join('\n')}`)
+  }
+}
+
+module.exports = validate

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

@@ -15,6 +15,7 @@ export { default as toPoints } from './toPoints'
 export { default as toString } from './toString'
 export { default as toCompactBinary } from './toCompactBinary'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Path2 } from './type'
 export as namespace path2

package/src/geometries/path2/index.js

@@ -31,5 +31,6 @@ module.exports = {
   toPoints: require('./toPoints'),
   toString: require('./toString'),
   toCompactBinary: require('./toCompactBinary'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/path2/validate.d.ts

@@ -0,0 +1,3 @@
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/path2/validate.js

@@ -0,0 +1,41 @@
+const vec2 = require('../../maths/vec2')
+const isA = require('./isA')
+
+/**
+ * Determine if the given object is a valid path2.
+ * Checks for valid data points, 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/path2.validate
+ */
+const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid path2 structure')
+  }
+
+  // check for duplicate points
+  if (object.points.length > 1) {
+    for (let i = 0; i < object.points.length; i++) {
+      if (vec2.equals(object.points[i], object.points[(i + 1) % object.points.length])) {
+        throw new Error(`path2 duplicate points ${object.points[i]}`)
+      }
+    }
+  }
+
+  // check for infinity, nan
+  object.points.forEach((point) => {
+    if (!point.every(Number.isFinite)) {
+      throw new Error(`path2 invalid point ${point}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`path2 invalid transforms ${object.transforms}`)
+  }
+}
+
+module.exports = validate

package/src/geometries/poly2/arePointsInside.js

@@ -23,41 +23,6 @@ const arePointsInside = (points, polygon) => {
   return sum === points.length ? 1 : 0
 }
 
-/*
- * Determine if the given point is inside the polygon.
- *
- * @see http://geomalgorithms.com/a03-_inclusion.html
- * @param {Array} point - an array with X and Y values
- * @param {Array} polygon - a list of points, where each point is an array with X and Y values
- * @return {Integer} 1 if the point is inside, 0 if outside
- */
-const isPointInsideOld = (point, polygon) => {
-  let wn = 0
-  const n = polygon.length
-  const x = point[0]
-  const y = point[1]
-  for (let i = 0; i < polygon.length; i++) {
-    const p1 = polygon[i]
-    const p2 = polygon[(i + 1) % n]
-    if (x !== p1[0] && y !== p1[1] && x !== p2[0] && y !== p2[1]) { // no overlap of points
-      if (p1[1] <= y) {
-        if (p2[1] > y) { // upward crossing
-          if (isLeft(p1, p2, point) > 0) { // point left of edge
-            wn++
-          }
-        }
-      } else {
-        if (p2[1] <= y) { // downward crossing
-          if (isLeft(p1, p2, point) < 0) { // point right of edge
-            wn--
-          }
-        }
-      }
-    }
-  }
-  return wn === 0 ? 1 : 0
-}
-
 /*
  * Determine if the given point is inside the polygon.
  *

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

@@ -13,6 +13,7 @@ export { default as plane } from './plane'
 export { default as toPoints } from './toPoints'
 export { default as toString } from './toString'
 export { default as transform } from './transform'
+export { default as validate } from './validate'
 
 export { default as Poly3 } from './type'
 export as namespace poly3

package/src/geometries/poly3/index.js

@@ -24,5 +24,6 @@ module.exports = {
   plane: require('./plane'),
   toPoints: require('./toPoints'),
   toString: require('./toString'),
-  transform: require('./transform')
+  transform: require('./transform'),
+  validate: require('./validate')
 }

package/src/geometries/poly3/invert.js

@@ -1,3 +1,4 @@
+const plane = require('../../maths/plane')
 const create = require('./create')
 
 /**
@@ -9,7 +10,12 @@ const create = require('./create')
  */
 const invert = (polygon) => {
   const vertices = polygon.vertices.slice().reverse()
-  return create(vertices)
+  const inverted = create(vertices)
+  if (polygon.plane) {
+    // Flip existing plane to save recompute
+    inverted.plane = plane.flip(plane.create(), polygon.plane)
+  }
+  return inverted
 }
 
 module.exports = invert

package/src/geometries/poly3/measureArea.test.js

@@ -62,10 +62,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromYRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -76,10 +76,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   rotation = mat4.fromXRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)
@@ -90,10 +90,10 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON)
 
   // inverted
   ply1 = invert(ply1)
@@ -104,8 +104,8 @@ test('poly3: measureArea() should return correct values', (t) => {
   ret2 = measureArea(ply2)
   ret3 = measureArea(ply3)
   ret4 = measureArea(ply4)
-  nearlyEqual(ret1, 0.0, Number.EPSILON)
-  nearlyEqual(ret2, 50.0, Number.EPSILON)
-  nearlyEqual(ret3, 100.0, Number.EPSILON)
-  nearlyEqual(ret4, 19.5, Number.EPSILON)
+  nearlyEqual(t, ret1, 0.0, Number.EPSILON)
+  nearlyEqual(t, ret2, 50.0, Number.EPSILON)
+  nearlyEqual(t, ret3, 100.0, Number.EPSILON)
+  nearlyEqual(t, ret4, 19.5, Number.EPSILON * 2)
 })

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -10,21 +10,21 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp1 = [[0, 0, 0], 0]
   let ret1 = measureBoundingSphere(ply1)
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
   let exp2 = [[0, 5, 5], 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
   let exp3 = [[0, 5, 5], 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
 
   // V-shape
   const points = [
@@ -43,7 +43,7 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let exp4 = [[0, 4.5, 3], 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -57,14 +57,14 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret4 = measureBoundingSphere(ply4)
   exp1 = [[0, 0, 0], 0]
   t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(ret1[1], exp1[1], Number.EPSILON)
+  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
   exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(ret2[1], exp2[1], Number.EPSILON)
+  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
   exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
   t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(ret3[1], exp3[1], Number.EPSILON)
+  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
   exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
   t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(ret4[1], exp4[1], Number.EPSILON)
+  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
 })

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

@@ -0,0 +1,4 @@
+
+export default validate
+
+declare function validate(object: any): void

package/src/geometries/poly3/validate.js

@@ -0,0 +1,50 @@
+const vec3 = require('../../maths/vec3')
+const isA = require('./isA')
+const isConvex = require('./isConvex')
+const measureArea = require('./measureArea')
+
+/**
+ * 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}`)
+    }
+  })
+}
+
+module.exports = validate

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/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)
 })