@jbroll/jscad-modeling 2.12.7

package/src/operations/modifiers/insertTjunctions.js

@@ -0,0 +1,294 @@
+const constants = require('../../maths/constants')
+const vec3 = require('../../maths/vec3')
+const poly3 = require('../../geometries/poly3')
+
+const assert = false
+
+const getTag = (vertex) => `${vertex}`
+
+const addSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, vertex1, polygonindex) => {
+  const starttag = getTag(vertex0)
+  const endtag = getTag(vertex1)
+  if (assert && starttag === endtag) throw new Error('assert failed')
+  const newsidetag = `${starttag}/${endtag}`
+  const reversesidetag = `${endtag}/${starttag}`
+  if (sidemap.has(reversesidetag)) {
+    // remove the opposing side from mappings
+    deleteSide(sidemap, vertextag2sidestart, vertextag2sideend, vertex1, vertex0, null)
+    return null
+  }
+  // add the side to the mappings
+  const newsideobj = {
+    vertex0: vertex0,
+    vertex1: vertex1,
+    polygonindex: polygonindex
+  }
+  if (!(sidemap.has(newsidetag))) {
+    sidemap.set(newsidetag, [newsideobj])
+  } else {
+    sidemap.get(newsidetag).push(newsideobj)
+  }
+  if (vertextag2sidestart.has(starttag)) {
+    vertextag2sidestart.get(starttag).push(newsidetag)
+  } else {
+    vertextag2sidestart.set(starttag, [newsidetag])
+  }
+  if (vertextag2sideend.has(endtag)) {
+    vertextag2sideend.get(endtag).push(newsidetag)
+  } else {
+    vertextag2sideend.set(endtag, [newsidetag])
+  }
+  return newsidetag
+}
+
+const deleteSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, vertex1, polygonindex) => {
+  const starttag = getTag(vertex0)
+  const endtag = getTag(vertex1)
+  const sidetag = `${starttag}/${endtag}`
+  if (assert && !(sidemap.has(sidetag))) throw new Error('assert failed')
+  let idx = -1
+  const sideobjs = sidemap.get(sidetag)
+  for (let i = 0; i < sideobjs.length; i++) {
+    const sideobj = sideobjs[i]
+    let sidetag = getTag(sideobj.vertex0)
+    if (sidetag !== starttag) continue
+    sidetag = getTag(sideobj.vertex1)
+    if (sidetag !== endtag) continue
+    if (polygonindex !== null) {
+      if (sideobj.polygonindex !== polygonindex) continue
+    }
+    idx = i
+    break
+  }
+  if (assert && idx < 0) throw new Error('assert failed')
+  sideobjs.splice(idx, 1)
+  if (sideobjs.length === 0) {
+    sidemap.delete(sidetag)
+  }
+
+  // adjust start and end lists
+  idx = vertextag2sidestart.get(starttag).indexOf(sidetag)
+  if (assert && idx < 0) throw new Error('assert failed')
+  vertextag2sidestart.get(starttag).splice(idx, 1)
+  if (vertextag2sidestart.get(starttag).length === 0) {
+    vertextag2sidestart.delete(starttag)
+  }
+
+  idx = vertextag2sideend.get(endtag).indexOf(sidetag)
+  if (assert && idx < 0) throw new Error('assert failed')
+  vertextag2sideend.get(endtag).splice(idx, 1)
+  if (vertextag2sideend.get(endtag).length === 0) {
+    vertextag2sideend.delete(endtag)
+  }
+}
+
+/*
+  Suppose we have two polygons ACDB and EDGF:
+
+   A-----B
+   |     |
+   |     E--F
+   |     |  |
+   C-----D--G
+
+  Note that vertex E forms a T-junction on the side BD. In this case some STL slicers will complain
+  that the solid is not watertight. This is because the watertightness check is done by checking if
+  each side DE is matched by another side ED.
+
+  This function will return a new solid with ACDB replaced by ACDEB
+
+  Note that this can create polygons that are slightly non-convex (due to rounding errors). Therefore the result should
+  not be used for further CSG operations!
+
+  Note this function is meant to be used to preprocess geometries when triangulation is required, i.e. AMF, STL, etc.
+  Do not use the results in other operations.
+*/
+
+/*
+ * Insert missing vertices for T junctions, which creates polygons that can be triangulated.
+ * @param {Array} polygons - the original polygons which may or may not have T junctions
+ * @return original polygons (if no T junctions found) or new polygons with updated vertices
+ */
+const insertTjunctions = (polygons) => {
+  // STEP 1 : build a map of 'unmatched' sides from the polygons
+  // i.e. side AB in one polygon does not have a matching side BA in another polygon
+  const sidemap = new Map()
+  for (let polygonindex = 0; polygonindex < polygons.length; polygonindex++) {
+    const polygon = polygons[polygonindex]
+    const numvertices = polygon.vertices.length
+    if (numvertices >= 3) {
+      let vertex = polygon.vertices[0]
+      let vertextag = getTag(vertex)
+      for (let vertexindex = 0; vertexindex < numvertices; vertexindex++) {
+        let nextvertexindex = vertexindex + 1
+        if (nextvertexindex === numvertices) nextvertexindex = 0
+
+        const nextvertex = polygon.vertices[nextvertexindex]
+        const nextvertextag = getTag(nextvertex)
+
+        const sidetag = `${vertextag}/${nextvertextag}`
+        const reversesidetag = `${nextvertextag}/${vertextag}`
+        if (sidemap.has(reversesidetag)) {
+          // this side matches the same side in another polygon. Remove from sidemap
+          // FIXME is this check necessary? there should only be ONE(1) opposing side
+          // FIXME assert ?
+          const ar = sidemap.get(reversesidetag)
+          ar.splice(-1, 1)
+          if (ar.length === 0) {
+            sidemap.delete(reversesidetag)
+          }
+        } else {
+          const sideobj = {
+            vertex0: vertex,
+            vertex1: nextvertex,
+            polygonindex: polygonindex
+          }
+          if (!(sidemap.has(sidetag))) {
+            sidemap.set(sidetag, [sideobj])
+          } else {
+            sidemap.get(sidetag).push(sideobj)
+          }
+        }
+        vertex = nextvertex
+        vertextag = nextvertextag
+      }
+    } else {
+      console.warn('warning: invalid polygon found during insertTjunctions')
+    }
+  }
+
+  if (sidemap.size > 0) {
+    // STEP 2 : create a list of starting sides and ending sides
+    const vertextag2sidestart = new Map()
+    const vertextag2sideend = new Map()
+    const sidesToCheck = new Map()
+    for (const [sidetag, sideobjs] of sidemap) {
+      sidesToCheck.set(sidetag, true)
+      sideobjs.forEach((sideobj) => {
+        const starttag = getTag(sideobj.vertex0)
+        const endtag = getTag(sideobj.vertex1)
+        if (vertextag2sidestart.has(starttag)) {
+          vertextag2sidestart.get(starttag).push(sidetag)
+        } else {
+          vertextag2sidestart.set(starttag, [sidetag])
+        }
+        if (vertextag2sideend.has(endtag)) {
+          vertextag2sideend.get(endtag).push(sidetag)
+        } else {
+          vertextag2sideend.set(endtag, [sidetag])
+        }
+      })
+    }
+
+    // STEP 3 : if sidemap is not empty
+    const newpolygons = polygons.slice(0) // make a copy in order to replace polygons inline
+    while (true) {
+      if (sidemap.size === 0) break
+
+      for (const sidetag of sidemap.keys()) {
+        sidesToCheck.set(sidetag, true)
+      }
+
+      let donesomething = false
+      while (true) {
+        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)) {
+          const sideobjs = sidemap.get(sidetagtocheck)
+          if (assert && sideobjs.length === 0) throw new Error('assert failed')
+          const sideobj = sideobjs[0]
+          for (let directionindex = 0; directionindex < 2; directionindex++) {
+            const startvertex = (directionindex === 0) ? sideobj.vertex0 : sideobj.vertex1
+            const endvertex = (directionindex === 0) ? sideobj.vertex1 : sideobj.vertex0
+            const startvertextag = getTag(startvertex)
+            const endvertextag = getTag(endvertex)
+            let matchingsides = []
+            if (directionindex === 0) {
+              if (vertextag2sideend.has(startvertextag)) {
+                matchingsides = vertextag2sideend.get(startvertextag)
+              }
+            } else {
+              if (vertextag2sidestart.has(startvertextag)) {
+                matchingsides = vertextag2sidestart.get(startvertextag)
+              }
+            }
+            for (let matchingsideindex = 0; matchingsideindex < matchingsides.length; matchingsideindex++) {
+              const matchingsidetag = matchingsides[matchingsideindex]
+              const matchingside = sidemap.get(matchingsidetag)[0]
+              const matchingsidestartvertex = (directionindex === 0) ? matchingside.vertex0 : matchingside.vertex1
+              const matchingsideendvertex = (directionindex === 0) ? matchingside.vertex1 : matchingside.vertex0
+              const matchingsidestartvertextag = getTag(matchingsidestartvertex)
+              const matchingsideendvertextag = getTag(matchingsideendvertex)
+              if (assert && matchingsideendvertextag !== startvertextag) throw new Error('assert failed')
+              if (matchingsidestartvertextag === endvertextag) {
+                // matchingside cancels sidetagtocheck
+                deleteSide(sidemap, vertextag2sidestart, vertextag2sideend, startvertex, endvertex, null)
+                deleteSide(sidemap, vertextag2sidestart, vertextag2sideend, endvertex, startvertex, null)
+                donewithside = false
+                directionindex = 2 // skip reverse direction check
+                donesomething = true
+                break
+              } else {
+                const startpos = startvertex
+                const endpos = endvertex
+                const checkpos = matchingsidestartvertex
+                const direction = vec3.subtract(vec3.create(), checkpos, startpos)
+                // Now we need to check if endpos is on the line startpos-checkpos:
+                const t = vec3.dot(vec3.subtract(vec3.create(), endpos, startpos), direction) / vec3.dot(direction, direction)
+                if ((t > 0) && (t < 1)) {
+                  const closestpoint = vec3.scale(vec3.create(), direction, t)
+                  vec3.add(closestpoint, closestpoint, startpos)
+                  const distancesquared = vec3.squaredDistance(closestpoint, endpos)
+                  if (distancesquared < (constants.EPS * constants.EPS)) {
+                    // Yes it's a t-junction! We need to split matchingside in two:
+                    const polygonindex = matchingside.polygonindex
+                    const polygon = newpolygons[polygonindex]
+                    // find the index of startvertextag in polygon:
+                    const insertionvertextag = getTag(matchingside.vertex1)
+                    let insertionvertextagindex = -1
+                    for (let i = 0; i < polygon.vertices.length; i++) {
+                      if (getTag(polygon.vertices[i]) === insertionvertextag) {
+                        insertionvertextagindex = i
+                        break
+                      }
+                    }
+                    if (assert && insertionvertextagindex < 0) throw new Error('assert failed')
+                    // split the side by inserting the vertex:
+                    const newvertices = polygon.vertices.slice(0)
+                    newvertices.splice(insertionvertextagindex, 0, endvertex)
+                    const newpolygon = poly3.create(newvertices)
+
+                    newpolygons[polygonindex] = newpolygon
+
+                    // remove the original sides from our maps
+                    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.set(newsidetag1, true)
+                    if (newsidetag2 !== null) sidesToCheck.set(newsidetag2, true)
+                    donewithside = false
+                    directionindex = 2 // skip reverse direction check
+                    donesomething = true
+                    break
+                  } // if(distancesquared < 1e-10)
+                } // if( (t > 0) && (t < 1) )
+              } // if(endingstidestartvertextag === endvertextag)
+            } // for matchingsideindex
+          } // for directionindex
+        } // if(sidetagtocheck in sidemap)
+        if (donewithside) {
+          sidesToCheck.delete(sidetagtocheck)
+        }
+      }
+      if (!donesomething) break
+    }
+    polygons = newpolygons
+  }
+  sidemap.clear()
+
+  return polygons
+}
+
+module.exports = insertTjunctions

package/src/operations/modifiers/insertTjunctions.test.js

@@ -0,0 +1,89 @@
+const test = require('ava')
+
+const { comparePolygonLists } = require('../../../test/helpers')
+
+const { geom3, poly3 } = require('../../geometries')
+
+const { cuboid } = require('../../primitives')
+
+const insertTjunctions = require('./insertTjunctions')
+
+test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
+  const geometry1 = geom3.create()
+  const geometry2 = cuboid({ size: [2, 2, 2] })
+  const geometry3 = geom3.fromPoints(
+    [
+      [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
+      [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
+      [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
+      [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
+      [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
+      // T junction
+      [[-1, -1, 1], [1, -1, 1], [1, 1, 1]],
+      [[1, 1, 1], [-1, 1, 1], [0, 0, 1]],
+      [[-1, 1, 1], [-1, -1, 1], [0, 0, 1]]
+    ]
+  )
+  const geometry4 = geom3.fromPoints(
+    [
+      [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
+      [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
+      [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
+      [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
+      [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
+      // T junctions
+      [[-1, -1, 1], [0, -1, 1], [0, 0, 1]],
+      [[-1, 0, 1], [-1, -1, 1], [0, 0, 1]],
+
+      [[0, -1, 1], [1, -1, 1], [0, 0, 1]],
+      [[1, -1, 1], [1, 0, 1], [0, 0, 1]],
+
+      [[1, 0, 1], [1, 1, 1], [0, 0, 1]],
+      [[1, 1, 1], [0, 1, 1], [0, 0, 1]],
+
+      [[0, 1, 1], [-1, 1, 1], [0, 0, 1]],
+      [[-1, 1, 1], [-1, 0, 1], [0, 0, 1]]
+    ]
+  )
+
+  const result1 = insertTjunctions(geom3.toPolygons(geometry1))
+  t.is(result1, geom3.toPolygons(geometry1)) // no T junctions
+
+  const result2 = insertTjunctions(geom3.toPolygons(geometry2))
+  t.is(result2, geom3.toPolygons(geometry2)) // no T junctions
+
+  // NOTE: insertTjunctions does NOT split the polygon, it just adds a new point at each T
+
+  const result3 = insertTjunctions(geom3.toPolygons(geometry3))
+  let exp = [
+    poly3.create([[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]]),
+    poly3.create([[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]]),
+    poly3.create([[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]]),
+    poly3.create([[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]]),
+    poly3.create([[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]]),
+    poly3.create([[0, 0, 1], [-1, -1, 1], [1, -1, 1], [1, 1, 1]]),
+    poly3.create([[1, 1, 1], [-1, 1, 1], [0, 0, 1]]),
+    poly3.create([[-1, 1, 1], [-1, -1, 1], [0, 0, 1]])
+  ]
+  t.not(result3, geom3.toPolygons(geometry3))
+  t.true(comparePolygonLists(result3, exp))
+
+  const result4 = insertTjunctions(geom3.toPolygons(geometry4))
+  exp = [
+    poly3.create([[-1, -1, -1], [-1, -1, 1], [-1, 0, 1], [-1, 1, 1], [-1, 1, -1]]),
+    poly3.create([[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, 0, 1], [1, -1, 1]]),
+    poly3.create([[-1, -1, -1], [1, -1, -1], [1, -1, 1], [0, -1, 1], [-1, -1, 1]]),
+    poly3.create([[-1, 1, -1], [-1, 1, 1], [0, 1, 1], [1, 1, 1], [1, 1, -1]]),
+    poly3.create([[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]]),
+    poly3.create([[-1, -1, 1], [0, -1, 1], [0, 0, 1]]),
+    poly3.create([[-1, 0, 1], [-1, -1, 1], [0, 0, 1]]),
+    poly3.create([[0, -1, 1], [1, -1, 1], [0, 0, 1]]),
+    poly3.create([[1, -1, 1], [1, 0, 1], [0, 0, 1]]),
+    poly3.create([[1, 0, 1], [1, 1, 1], [0, 0, 1]]),
+    poly3.create([[1, 1, 1], [0, 1, 1], [0, 0, 1]]),
+    poly3.create([[0, 1, 1], [-1, 1, 1], [0, 0, 1]]),
+    poly3.create([[-1, 1, 1], [-1, 0, 1], [0, 0, 1]])
+  ]
+  t.not(result4, geometry4)
+  t.true(comparePolygonLists(result4, exp))
+})

package/src/operations/modifiers/mergePolygons.js

@@ -0,0 +1,208 @@
+const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
+const vec3 = require('../../maths/vec3')
+
+const poly3 = require('../../geometries/poly3')
+
+// create a set of edges from the given polygon, and link the edges as well
+const createEdges = (polygon) => {
+  const points = poly3.toPoints(polygon)
+  const edges = []
+  for (let i = 0; i < points.length; i++) {
+    const j = (i + 1) % points.length
+    const edge = {
+      v1: points[i],
+      v2: points[j]
+    }
+    edges.push(edge)
+  }
+  // link the edges together
+  for (let i = 0; i < edges.length; i++) {
+    const j = (i + 1) % points.length
+    edges[i].next = edges[j]
+    edges[j].prev = edges[i]
+  }
+  return edges
+}
+
+const insertEdge = (edges, edge) => {
+  const key = `${edge.v1}:${edge.v2}`
+  edges.set(key, edge)
+}
+
+const deleteEdge = (edges, edge) => {
+  const key = `${edge.v1}:${edge.v2}`
+  edges.delete(key)
+}
+
+const findOppositeEdge = (edges, edge) => {
+  const key = `${edge.v2}:${edge.v1}` // NOTE: OPPOSITE OF INSERT KEY
+  return edges.get(key)
+}
+
+// calculate the two adjoining angles between the opposing edges
+const calculateAnglesBetween = (current, opposite, normal) => {
+  let v0 = current.prev.v1
+  let v1 = current.prev.v2
+  let v2 = opposite.next.v2
+  const angle1 = calculateAngle(v0, v1, v2, normal)
+
+  v0 = opposite.prev.v1
+  v1 = opposite.prev.v2
+  v2 = current.next.v2
+  const angle2 = calculateAngle(v0, v1, v2, normal)
+
+  return [angle1, angle2]
+}
+
+const v1 = vec3.create()
+const v2 = vec3.create()
+
+const calculateAngle = (prevpoint, point, nextpoint, normal) => {
+  const d0 = vec3.subtract(v1, point, prevpoint)
+  const d1 = vec3.subtract(v2, nextpoint, point)
+  vec3.cross(d0, d0, d1)
+  return vec3.dot(d0, normal)
+}
+
+// create a polygon starting from the given edge (if possible)
+const createPolygonAnd = (edge) => {
+  let polygon
+  const points = []
+  while (edge.next) {
+    const next = edge.next
+
+    points.push(edge.v1)
+
+    edge.v1 = null
+    edge.v2 = null
+    edge.next = null
+    edge.prev = null
+
+    edge = next
+  }
+  if (points.length > 0) polygon = poly3.create(points)
+  return polygon
+}
+
+/*
+ * Merge COPLANAR polygons that share common edges.
+ * @param {poly3[]} sourcepolygons - list of polygons
+ * @returns {poly3[]} new set of polygons
+ */
+const mergeCoplanarPolygons = (sourcepolygons) => {
+  if (sourcepolygons.length < 2) return sourcepolygons
+
+  const normal = sourcepolygons[0].plane
+  const polygons = sourcepolygons.slice()
+  const edgeList = new Map()
+
+  while (polygons.length > 0) { // NOTE: the length of polygons WILL change
+    const polygon = polygons.shift()
+    const edges = createEdges(polygon)
+    for (let i = 0; i < edges.length; i++) {
+      const current = edges[i]
+      const opposite = findOppositeEdge(edgeList, current)
+      if (opposite) {
+        const angles = calculateAnglesBetween(current, opposite, normal)
+        if (angles[0] >= 0 && angles[1] >= 0) {
+          const edge1 = opposite.next
+          const edge2 = current.next
+          // adjust the edges, linking together opposing polygons
+          current.prev.next = opposite.next
+          current.next.prev = opposite.prev
+
+          opposite.prev.next = current.next
+          opposite.next.prev = current.prev
+
+          // remove the opposing edges
+          current.v1 = null
+          current.v2 = null
+          current.next = null
+          current.prev = null
+
+          deleteEdge(edgeList, opposite)
+
+          opposite.v1 = null
+          opposite.v2 = null
+          opposite.next = null
+          opposite.prev = null
+
+          const mergeEdges = (list, e1, e2) => {
+            const newedge = {
+              v1: e2.v1,
+              v2: e1.v2,
+              next: e1.next,
+              prev: e2.prev
+            }
+            // link in newedge
+            e2.prev.next = newedge
+            e1.next.prev = newedge
+            // remove old edges
+            deleteEdge(list, e1)
+            e1.v1 = null
+            e1.v2 = null
+            e1.next = null
+            e1.prev = null
+
+            deleteEdge(list, e2)
+            e2.v1 = null
+            e2.v2 = null
+            e2.next = null
+            e2.prev = null
+          }
+
+          if (angles[0] === 0.0) {
+            mergeEdges(edgeList, edge1, edge1.prev)
+          }
+          if (angles[1] === 0.0) {
+            mergeEdges(edgeList, edge2, edge2.prev)
+          }
+        }
+      } else {
+        if (current.next) insertEdge(edgeList, current)
+      }
+    }
+  }
+
+  // build a set of polygons from the remaining edges
+  const destpolygons = []
+  edgeList.forEach((edge) => {
+    const polygon = createPolygonAnd(edge)
+    if (polygon) destpolygons.push(polygon)
+  })
+
+  edgeList.clear()
+
+  return destpolygons
+}
+
+const coplanar = (plane1, plane2) => {
+  // expect the same distance from the origin, within tolerance
+  if (Math.abs(plane1[3] - plane2[3]) < 0.00000015) {
+    return aboutEqualNormals(plane1, plane2)
+  }
+  return false
+}
+
+const mergePolygons = (epsilon, polygons) => {
+  const polygonsPerPlane = [] // elements: [plane, [poly3...]]
+  polygons.forEach((polygon) => {
+    const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon)))
+    if (mapping) {
+      const polygons = mapping[1]
+      polygons.push(polygon)
+    } else {
+      polygonsPerPlane.push([poly3.plane(polygon), [polygon]])
+    }
+  })
+
+  let destpolygons = []
+  polygonsPerPlane.forEach((mapping) => {
+    const sourcepolygons = mapping[1]
+    const retesselayedpolygons = mergeCoplanarPolygons(sourcepolygons)
+    destpolygons = destpolygons.concat(retesselayedpolygons)
+  })
+  return destpolygons
+}
+
+module.exports = mergePolygons