@jscad/modeling 2.9.3 → 2.9.6

package/src/{utils → maths/utils}/trigonometry.js

@@ -1,4 +1,4 @@
-const { NEPS } = require('../maths/constants')
+const { NEPS } = require('../constants')
 
 /*
  * Returns zero if n is within epsilon of zero, otherwise return n

package/src/maths/vec2/distance.js

@@ -9,7 +9,7 @@
 const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
-  return Math.hypot(x, y)
+  return Math.sqrt(x * x + y * y)
 }
 
 module.exports = distance

package/src/maths/vec2/fromAngleRadians.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Create a new vector in the direction of the given angle.
  *
@@ -7,8 +9,8 @@
  * @alias module:modeling/maths/vec2.fromAngleRadians
  */
 const fromAngleRadians = (out, radians) => {
-  out[0] = Math.cos(radians)
-  out[1] = Math.sin(radians)
+  out[0] = cos(radians)
+  out[1] = sin(radians)
   return out
 }
 

package/src/maths/vec2/length.js

@@ -5,6 +5,6 @@
  * @returns {Number} length
  * @alias module:modeling/maths/vec2.length
  */
-const length = (vector) => Math.hypot(vector[0], vector[1])
+const length = (vector) => Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1])
 
 module.exports = length

package/src/maths/vec2/length.test.js

@@ -25,15 +25,5 @@ test('vec2: length() should return correct values', (t) => {
   const length5 = length(vec5)
   nearlyEqual(t, length5, 2.23606, EPS)
 
-  // huge vector
-  const vec6 = fromValues(1e200, 1e200)
-  const length6 = length(vec6)
-  nearlyEqual(t, length6, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec7 = fromValues(1e-200, 1e-200)
-  const length7 = length(vec7)
-  nearlyEqual(t, length7, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/angle.js

@@ -15,8 +15,8 @@ const angle = (a, b) => {
   const bx = b[0]
   const by = b[1]
   const bz = b[2]
-  const mag1 = Math.hypot(ax, ay, az)
-  const mag2 = Math.hypot(bx, by, bz)
+  const mag1 = Math.sqrt(ax * ax + ay * ay + az * az)
+  const mag2 = Math.sqrt(bx * bx + by * by + bz * bz)
   const mag = mag1 * mag2
   const cosine = mag && dot(a, b) / mag
   return Math.acos(Math.min(Math.max(cosine, -1), 1))

package/src/maths/vec3/angle.test.js

@@ -30,17 +30,5 @@ test('vec3: angle() should return correct values', (t) => {
   const angle5 = angle(vec5a, vec5b)
   nearlyEqual(t, angle5, 0.785398, EPS)
 
-  // tiny values
-  const vec6a = fromValues(1, 0, 0)
-  const vec6b = fromValues(1e-200, 1e-200, 0)
-  const angle6 = angle(vec6a, vec6b)
-  nearlyEqual(t, angle6, 0.785398, EPS)
-
-  // huge values
-  const vec7a = fromValues(1, 0, 0)
-  const vec7b = fromValues(1e200, 1e200, 0)
-  const angle7 = angle(vec7a, vec7b)
-  nearlyEqual(t, angle7, 0.785398, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/distance.js

@@ -10,7 +10,7 @@ const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
   const z = b[2] - a[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = distance

package/src/maths/vec3/length.js

@@ -9,7 +9,7 @@ const length = (vector) => {
   const x = vector[0]
   const y = vector[1]
   const z = vector[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = length

package/src/maths/vec3/length.test.js

@@ -41,15 +41,5 @@ test('vec3: length() should return correct values', (t) => {
   const length9 = length(vec9)
   nearlyEqual(t, length9, 3.74165, EPS)
 
-  // huge vector
-  const vec10 = fromValues(1e200, 0, 1e200)
-  const length10 = length(vec10)
-  nearlyEqual(t, length10, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec11 = fromValues(1e-200, 0, 1e-200)
-  const length11 = length(vec11)
-  nearlyEqual(t, length11, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

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

@@ -0,0 +1,69 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { intersect } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // intersect of one object
+  const result1 = intersect(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  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
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = intersect(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [9, 9], [8, 9], [8, 8], [9, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 4)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two completely overlapping objects
+  const result4 = intersect(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+})

package/src/operations/booleans/{intersect.test.js → intersectGeom3.test.js}

@@ -1,83 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { intersect } = require('./index')
 
 const { center } = require('../transforms/center')
 
-//  test('intersect: intersect of a path produces expected changes to points', (t) => {
-//    let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//    geometry = intersect({normal: [1, 0, 0]}, geometry)
-//    let obs = path.toPoints(geometry)
-//    let exp = []
-//
-//    t.deepEqual(obs, exp)
-//  })
-
-test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // intersect of one object
-  const result1 = intersect(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  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
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = intersect(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [9, 9], [8, 9], [8, 8], [9, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 4)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two completely overlapping objects
-  const result4 = intersect(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-})
-
 test('intersect: intersect of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

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

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  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))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 0)
+  t.deepEqual(obs, exp)
+})

package/src/operations/booleans/{subtract.test.js → subtractGeom3.test.js}

@@ -1,86 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { subtract } = require('./index')
 
 const { center } = require('../transforms/center')
 
-// test('subtract: subtract of a path produces expected changes to points', (t) => {
-//   let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//   geometry = subtract({normal: [1, 0, 0]}, geometry)
-//   let obs = path.toPoints(geometry)
-//   let exp = []
-//
-//   t.deepEqual(obs, exp)
-// })
-
-test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // subtract of one object
-  const result1 = subtract(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = subtract(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = subtract(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  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))
-
-  // subtract of two completely overlapping objects
-  const result4 = subtract(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 0)
-  t.deepEqual(obs, exp)
-})
-
 test('subtract: subtract of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

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

@@ -132,8 +132,8 @@ class PolygonTreeNode {
     const polygon = this.polygon
     if (polygon) {
       const bound = poly3.measureBoundingSphere(polygon)
-      const sphereradius = bound[1] + EPS // ensure radius is LARGER then polygon
-      const spherecenter = bound[0]
+      const sphereradius = bound[3] + EPS // ensure radius is LARGER then polygon
+      const spherecenter = bound
       const d = vec3.dot(splane, spherecenter) - splane[3]
       if (d > sphereradius) {
         frontnodes.push(this)

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

@@ -0,0 +1,166 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { union } = require('./index')
+
+const { center } = require('../transforms/center')
+const { translate } = require('../transforms/translate')
+
+test('union of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // union of one object
+  const result1 = union(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.true(comparePoints(obs, exp))
+
+  // union of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = union(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [8, 12],
+    [8, 8],
+    [12, 8],
+    [12, 12],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.true(comparePoints(obs, exp))
+
+  // union of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = union(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [11.999973333333333, 11.999973333333333],
+    [7.999933333333333, 11.999973333333333],
+    [9.000053333333334, 7.999933333333333],
+    [-9.000053333333334, 9.000053333333334],
+    [-9.000053333333334, -9.000053333333334],
+    [9.000053333333334, -9.000053333333334],
+    [7.999933333333333, 9.000053333333334],
+    [11.999973333333333, 7.999933333333333]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.true(comparePoints(obs, exp))
+
+  // union of two completely overlapping objects
+  const result4 = union(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [-9.000046666666666, -9.000046666666666],
+    [9.000046666666666, -9.000046666666666],
+    [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 geom2 with closing issues #15', (t) => {
+  const c = geom2.create([
+    [[-45.82118740347841168159, -16.85726810555620147625], [-49.30331715865012398581, -14.68093629710870118288]],
+    [[-49.10586702080816223770, -15.27604177352110781385], [-48.16645938811709015681, -15.86317173589183227023]],
+    [[-49.60419521731581937729, -14.89550781504266296906], [-49.42407001323204696064, -15.67605088949303393520]],
+    [[-49.05727291218684626983, -15.48661638542171203881], [-49.10586702080816223770, -15.27604177352110781385]],
+    [[-49.30706235399220815907, -15.81529674600091794900], [-46.00505780290426827150, -17.21108547999804727624]],
+    [[-46.00505780290426827150, -17.21108547999804727624], [-45.85939703723252591772, -17.21502856394236857795]],
+    [[-45.85939703723252591772, -17.21502856394236857795], [-45.74972032664388166268, -17.11909303495791334626]],
+    [[-45.74972032664388166268, -17.11909303495791334626], [-45.73424573227583067592, -16.97420292661295349035]],
+    [[-45.73424573227583067592, -16.97420292661295349035], [-45.82118740347841168159, -16.85726810555620147625]],
+    [[-49.30331715865012398581, -14.68093629710870118288], [-49.45428884427643367871, -14.65565769658912387285]],
+    [[-49.45428884427643367871, -14.65565769658912387285], [-49.57891661679624917269, -14.74453612941635327616]],
+    [[-49.57891661679624917269, -14.74453612941635327616], [-49.60419521731581937729, -14.89550781504266296906]],
+    [[-49.42407001323204696064, -15.67605088949303393520], [-49.30706235399220815907, -15.81529674600091794900]],
+    [[-48.16645938811709015681, -15.86317173589183227023], [-49.05727291218684626983, -15.48661638542171203881]]
+  ])
+  const d = geom2.create([
+    [[-49.03431352173912216585, -15.58610714407888764299], [-49.21443872582289458251, -14.80556406962851667686]],
+    [[-68.31614651314507113966, -3.10790373951434872879], [-49.34036769611472550423, -15.79733157434056778357]],
+    [[-49.58572929483430868913, -14.97552686612213790340], [-49.53755741140093959984, -15.18427183431472826669]],
+    [[-49.53755741140093959984, -15.18427183431472826669], [-54.61235529924312714911, -11.79066769321313756791]],
+    [[-49.30227466841120076424, -14.68159232649114187552], [-68.09792828135776687759, -2.77270756611528668145]],
+    [[-49.21443872582289458251, -14.80556406962851667686], [-49.30227466841120076424, -14.68159232649114187552]],
+    [[-49.34036769611472550423, -15.79733157434056778357], [-49.18823337756091262918, -15.82684012194931710837]],
+    [[-49.18823337756091262918, -15.82684012194931710837], [-49.06069007212390431505, -15.73881563386780157998]],
+    [[-49.06069007212390431505, -15.73881563386780157998], [-49.03431352173912216585, -15.58610714407888764299]],
+    [[-68.09792828135776687759, -2.77270756611528668145], [-68.24753735887460948106, -2.74623350179570024920]],
+    [[-68.24753735887460948106, -2.74623350179570024920], [-68.37258141465594007968, -2.83253376987636329432]],
+    [[-68.37258141465594007968, -2.83253376987636329432], [-68.40089829889257089235, -2.98180502037078554167]],
+    [[-68.40089829889257089235, -2.98180502037078554167], [-68.31614651314507113966, -3.10790373951434872879]],
+    [[-54.61235529924312714911, -11.79066769321313756791], [-49.58572929483430868913, -14.97552686612213790340]]
+  ])
+  // geom2.toOutlines(c)
+  // geom2.toOutlines(d)
+
+  const obs = union(c, d)
+  // const outlines = geom2.toOutlines(obs)
+  const pts = geom2.toPoints(obs)
+  const exp = [
+    [-49.10585516965137, -15.276000175919414],
+    [-49.0573272145917, -15.486679335654257],
+    [-49.307011370463215, -15.815286644243773],
+    [-46.00502320253235, -17.211117609669667],
+    [-45.85943933735334, -17.215031154432545],
+    [-45.74972963250071, -17.119149307742074],
+    [-45.734205904941305, -16.974217700023555],
+    [-48.166473975068946, -15.86316234184296],
+    [-49.318621553259746, -15.801589237573706],
+    [-49.585786209072104, -14.975570389622606],
+    [-68.31614189569036, -3.1078763476921982],
+    [-49.53751915699663, -15.184292776976012],
+    [-68.09789654941396, -2.7727464644978874],
+    [-68.24752441084793, -2.7462648116024244],
+    [-68.37262739176788, -2.8324932478777995],
+    [-68.40093536555268, -2.98186020632758],
+    [-54.61234310251047, -11.79072766159384],
+    [-49.30335872868453, -14.680880468978017],
+    [-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))
+})