@jscad/modeling 2.9.3 → 2.9.6

package/src/operations/booleans/{union.test.js → unionGeom3.test.js}

@@ -1,113 +1,14 @@
 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 { 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]])
-//
-//   geometry = union({normal: [1, 0, 0]}, geometry)
-//   let obs = path.toPoints(geometry)
-//   let exp = []
-//
-//   t.deepEqual(obs, exp)
-// })
-
-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 one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
@@ -230,69 +131,3 @@ test('union of geom3 with rounding issues #137', (t) => {
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6) // number of polygons in union
 })
-
-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))
-})

package/src/operations/extrusions/extrudeFromSlices.js

@@ -5,7 +5,7 @@ const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
 const slice = require('./slice')
-const repairSlice = require('./slice/repairSlice')
+const repairSlice = require('./slice/repair')
 
 const extrudeWalls = require('./extrudeWalls')
 
@@ -59,7 +59,8 @@ const extrudeFromSlices = (options, base) => {
 
   // Repair gaps in the base slice
   if (repair) {
-    repairSlice(base)
+    // note: base must be a slice, if base is geom2 this doesn't repair
+    base = repairSlice(base)
   }
 
   const sMax = numberOfSlices - 1

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

@@ -22,18 +22,18 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   let geometry3 = extrudeRotate({ segments: 4, angle: Math.PI / 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
-    [[10, 4.898587196589413e-16, 8], [26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8]],
-    [[10, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [10, 4.898587196589413e-16, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [26, -4.898587196589413e-16, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
-    [[7.071067811865476, 7.0710678118654755, -8], [7.071067811865476, 7.0710678118654755, 8], [18.384776310850242, 18.384776310850235, 8]],
-    [[18.384776310850242, 18.384776310850235, 8], [18.384776310850242, 18.384776310850235, -8], [7.071067811865476, 7.0710678118654755, -8]],
-    [[26, 4.898587196589413e-16, 8], [10, 4.898587196589413e-16, 8], [10, -4.898587196589413e-16, -8]],
-    [[10, -4.898587196589413e-16, -8], [26, -4.898587196589413e-16, -8], [26, 4.898587196589413e-16, 8]]
+    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
+    [[7.0710678118654755, 7.071067811865475, -8], [7.0710678118654755, 7.071067811865475, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[18.38477631085024, 18.384776310850235, 8], [18.38477631085024, 18.384776310850235, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, 8], [10, 0, 8], [10, 0, -8]],
+    [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
@@ -95,14 +95,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry2 = geom2.fromPoints([[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 64)
 
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.fromPoints([[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 80)
 })
 
@@ -113,16 +113,16 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   let obs = extrudeRotate({ segments: 4, angle: Math.PI / 2 }, geometry)
   let pts = geom3.toPoints(obs)
   let exp = [
-    [[0, 4.898587196589413e-16, 8], [7, 4.898587196589413e-16, 8], [-6.123233995736767e-17, 7, 8]],
-    [[7, -4.898587196589413e-16, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [9.184850993605148e-16, 7, -8]],
-    [[7, 4.898587196589413e-16, 8], [7, -4.898587196589413e-16, -8], [9.184850993605148e-16, 7, -8]],
-    [[7, 4.898587196589413e-16, 8], [9.184850993605148e-16, 7, -8], [-6.123233995736767e-17, 7, 8]],
-    [[4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589413e-16, 2.999519565323715e-32, 8], [-6.123233995736767e-17, 7, 8]],
-    [[-6.123233995736767e-17, 7, 8], [9.184850993605148e-16, 7, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8]],
-    [[0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8], [7, 4.898587196589413e-16, 8]]
+    [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
+    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [0, 7, -8], [0, 7, 8]],
+    [[0, 0, -8], [0, 0, 8], [0, 7, 8]],
+    [[0, 7, 8], [0, 7, -8], [0, 0, -8]],
+    [[7, 0, 8], [0, 0, 8], [0, 0, -8]],
+    [[0, 0, -8], [7, 0, -8], [7, 0, 8]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -132,26 +132,26 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   obs = extrudeRotate({ segments: 8, angle: Math.PI / 2 }, geometry)
   pts = geom3.toPoints(obs)
   exp = [
-    [[1, -4.898587196589413e-16, -8], [3.4638242249419727e-16, -3.4638242249419736e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, -4.898587196589413e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [0.7071067811865479, 0.7071067811865471, -8], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [2, 2.4492935982947064e-16, 4], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [1.414213562373095, 1.4142135623730951, 4], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, 4.898587196589413e-16, 8], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0.7071067811865479, 0.7071067811865471, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [0.7071067811865479, 0.7071067811865471, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [5.51091059616309e-16, 1, -8], [-1.2246467991473532e-16, 2, 4]],
-    [[0.7071067811865472, 0.7071067811865478, 8], [1.414213562373095, 1.4142135623730951, 4], [-1.2246467991473532e-16, 2, 4]],
-    [[0.7071067811865472, 0.7071067811865478, 8], [-1.2246467991473532e-16, 2, 4], [-4.286263797015736e-16, 1, 8]],
-    [[-3.4638242249419727e-16, 3.4638242249419736e-16, 8], [0.7071067811865472, 0.7071067811865478, 8], [-4.286263797015736e-16, 1, 8]],
-    [[5.51091059616309e-16, 1, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[-4.898587196589415e-16, 2.9995195653237163e-32, 8], [-4.286263797015738e-16, 1, 8], [-1.2246467991473544e-16, 2, 4]],
-    [[-1.2246467991473544e-16, 2, 4], [5.51091059616309e-16, 1, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8], [1, -4.898587196589413e-16, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, -4.898587196589413e-16, -8], [2, 2.4492935982947064e-16, 4]]
+    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [2, 0, 4], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0, 1, -8], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [1.4142135623730951, 1.414213562373095, 4], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [0, 2, 4], [0, 1, 8]],
+    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
+    [[0, 1, -8], [0, 0, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 1, 8], [0, 2, 4]],
+    [[0, 2, 4], [0, 1, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 0, -8], [1, 0, -8]],
+    [[2, 0, 4], [1, 0, 8], [0, 0, 8]],
+    [[0, 0, 8], [1, 0, -8], [2, 0, 4]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

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

@@ -29,10 +29,10 @@ test('project (defaults)', (t) => {
     [0, -5.000013333333333],
     [5.000013333333333, 0],
     [-5.000013333333333, 0],
-    [-2.9999933333333333, 0],
-    [2.9999933333333333, 0],
     [0, 2.9999933333333333],
+    [-2.9999933333333333, 0],
     [0, -2.9999933333333333],
+    [2.9999933333333333, 0],
     [0, 5.000013333333333]
   ]
   t.true(comparePoints(pts, exp))

package/src/operations/extrusions/slice/repair.js

@@ -0,0 +1,62 @@
+const vec3 = require('../../../maths/vec3')
+const create = require('./create')
+
+/*
+ * Mend gaps in a 2D slice to make it a closed polygon
+ */
+const repair = (slice) => {
+  if (!slice.edges) return slice
+  let edges = slice.edges
+  const vertexMap = new Map() // string key to vertex map
+  const edgeCount = new Map() // count of (in - out) edges
+
+  // Remove self-edges
+  edges = edges.filter((e) => !vec3.equals(e[0], e[1]))
+
+  // build vertex and edge count maps
+  edges.forEach((edge) => {
+    const inKey = edge[0].toString()
+    const outKey = edge[1].toString()
+    vertexMap.set(inKey, edge[0])
+    vertexMap.set(outKey, edge[1])
+    edgeCount.set(inKey, (edgeCount.get(inKey) || 0) + 1) // in
+    edgeCount.set(outKey, (edgeCount.get(outKey) || 0) - 1) // out
+  })
+
+  // find vertices which are missing in or out edges
+  const missingIn = []
+  const missingOut = []
+  edgeCount.forEach((count, vertex) => {
+    if (count < 0) missingIn.push(vertex)
+    if (count > 0) missingOut.push(vertex)
+  })
+
+  // pairwise distance of bad vertices
+  missingIn.forEach((key1) => {
+    const v1 = vertexMap.get(key1)
+
+    // find the closest vertex that is missing an out edge
+    let bestDistance = Infinity
+    let bestReplacement
+    missingOut.forEach((key2) => {
+      const v2 = vertexMap.get(key2)
+      const distance = vec3.distance(v1, v2)
+      if (distance < bestDistance) {
+        bestDistance = distance
+        bestReplacement = v2
+      }
+    })
+    console.warn(`slice.repair: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
+
+    // merge broken vertices
+    edges = edges.map((edge) => {
+      if (edge[0].toString() === key1) return [bestReplacement, edge[1]]
+      if (edge[1].toString() === key1) return [edge[0], bestReplacement]
+      return edge
+    })
+  })
+
+  return create(edges)
+}
+
+module.exports = repair

package/src/operations/modifiers/insertTjunctions.js

@@ -28,15 +28,15 @@ const addSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, verte
   } else {
     sidemap.get(newsidetag).push(newsideobj)
   }
-  if (starttag in vertextag2sidestart) {
-    vertextag2sidestart[starttag].push(newsidetag)
+  if (vertextag2sidestart.has(starttag)) {
+    vertextag2sidestart.get(starttag).push(newsidetag)
   } else {
-    vertextag2sidestart[starttag] = [newsidetag]
+    vertextag2sidestart.set(starttag, [newsidetag])
   }
-  if (endtag in vertextag2sideend) {
-    vertextag2sideend[endtag].push(newsidetag)
+  if (vertextag2sideend.has(endtag)) {
+    vertextag2sideend.get(endtag).push(newsidetag)
   } else {
-    vertextag2sideend[endtag] = [newsidetag]
+    vertextag2sideend.set(endtag, [newsidetag])
   }
   return newsidetag
 }
@@ -67,18 +67,18 @@ const deleteSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, ve
   }
 
   // adjust start and end lists
-  idx = vertextag2sidestart[starttag].indexOf(sidetag)
+  idx = vertextag2sidestart.get(starttag).indexOf(sidetag)
   if (assert && idx < 0) throw new Error('assert failed')
-  vertextag2sidestart[starttag].splice(idx, 1)
-  if (vertextag2sidestart[starttag].length === 0) {
-    delete vertextag2sidestart[starttag]
+  vertextag2sidestart.get(starttag).splice(idx, 1)
+  if (vertextag2sidestart.get(starttag).length === 0) {
+    vertextag2sidestart.delete(starttag)
   }
 
-  idx = vertextag2sideend[endtag].indexOf(sidetag)
+  idx = vertextag2sideend.get(endtag).indexOf(sidetag)
   if (assert && idx < 0) throw new Error('assert failed')
-  vertextag2sideend[endtag].splice(idx, 1)
-  if (vertextag2sideend[endtag].length === 0) {
-    delete vertextag2sideend[endtag]
+  vertextag2sideend.get(endtag).splice(idx, 1)
+  if (vertextag2sideend.get(endtag).length === 0) {
+    vertextag2sideend.delete(endtag)
   }
 }
 
@@ -158,25 +158,24 @@ const insertTjunctions = (polygons) => {
   }
 
   if (sidemap.size > 0) {
-    // console.log('insertTjunctions',sidemap.size)
     // STEP 2 : create a list of starting sides and ending sides
-    const vertextag2sidestart = {}
-    const vertextag2sideend = {}
-    const sidestocheck = {}
+    const vertextag2sidestart = new Map()
+    const vertextag2sideend = new Map()
+    const sidesToCheck = new Map()
     for (const [sidetag, sideobjs] of sidemap) {
-      sidestocheck[sidetag] = true
+      sidesToCheck.set(sidetag, true)
       sideobjs.forEach((sideobj) => {
         const starttag = getTag(sideobj.vertex0)
         const endtag = getTag(sideobj.vertex1)
-        if (starttag in vertextag2sidestart) {
-          vertextag2sidestart[starttag].push(sidetag)
+        if (vertextag2sidestart.has(starttag)) {
+          vertextag2sidestart.get(starttag).push(sidetag)
         } else {
-          vertextag2sidestart[starttag] = [sidetag]
+          vertextag2sidestart.set(starttag, [sidetag])
         }
-        if (endtag in vertextag2sideend) {
-          vertextag2sideend[endtag].push(sidetag)
+        if (vertextag2sideend.has(endtag)) {
+          vertextag2sideend.get(endtag).push(sidetag)
         } else {
-          vertextag2sideend[endtag] = [sidetag]
+          vertextag2sideend.set(endtag, [sidetag])
         }
       })
     }
@@ -187,13 +186,13 @@ const insertTjunctions = (polygons) => {
       if (sidemap.size === 0) break
 
       for (const sidetag of sidemap.keys()) {
-        sidestocheck[sidetag] = true
+        sidesToCheck.set(sidetag, true)
       }
 
       let donesomething = false
       while (true) {
-        const sidetags = Object.keys(sidestocheck)
-        if (sidetags.length === 0) break // sidestocheck is empty, we're done!
+        const sidetags = Array.from(sidesToCheck.keys())
+        if (sidetags.length === 0) break // sidesToCheck is empty, we're done!
         const sidetagtocheck = sidetags[0]
         let donewithside = true
         if (sidemap.has(sidetagtocheck)) {
@@ -207,12 +206,12 @@ const insertTjunctions = (polygons) => {
             const endvertextag = getTag(endvertex)
             let matchingsides = []
             if (directionindex === 0) {
-              if (startvertextag in vertextag2sideend) {
-                matchingsides = vertextag2sideend[startvertextag]
+              if (vertextag2sideend.has(startvertextag)) {
+                matchingsides = vertextag2sideend.get(startvertextag)
               }
             } else {
-              if (startvertextag in vertextag2sidestart) {
-                matchingsides = vertextag2sidestart[startvertextag]
+              if (vertextag2sidestart.has(startvertextag)) {
+                matchingsides = vertextag2sidestart.get(startvertextag)
               }
             }
             for (let matchingsideindex = 0; matchingsideindex < matchingsides.length; matchingsideindex++) {
@@ -267,8 +266,8 @@ const insertTjunctions = (polygons) => {
                     deleteSide(sidemap, vertextag2sidestart, vertextag2sideend, matchingside.vertex0, matchingside.vertex1, polygonindex)
                     const newsidetag1 = addSide(sidemap, vertextag2sidestart, vertextag2sideend, matchingside.vertex0, endvertex, polygonindex)
                     const newsidetag2 = addSide(sidemap, vertextag2sidestart, vertextag2sideend, endvertex, matchingside.vertex1, polygonindex)
-                    if (newsidetag1 !== null) sidestocheck[newsidetag1] = true
-                    if (newsidetag2 !== null) sidestocheck[newsidetag2] = true
+                    if (newsidetag1 !== null) sidesToCheck.set(newsidetag1, true)
+                    if (newsidetag2 !== null) sidesToCheck.set(newsidetag2, true)
                     donewithside = false
                     directionindex = 2 // skip reverse direction check
                     donesomething = true
@@ -280,7 +279,7 @@ const insertTjunctions = (polygons) => {
           } // for directionindex
         } // if(sidetagtocheck in sidemap)
         if (donewithside) {
-          delete sidestocheck[sidetagtocheck]
+          sidesToCheck.delete(sidetagtocheck)
         }
       }
       if (!donesomething) break