@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/operations/modifiers/insertTjunctions.js

@@ -1,84 +1,85 @@
-const constants = require('../../maths/constants')
-const vec3 = require('../../maths/vec3')
-const poly3 = require('../../geometries/poly3')
+import { EPS } from '../../maths/constants.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+import * as poly3 from '../../geometries/poly3/index.js'
 
 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)) {
+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)
+    deleteSide(sideMap, vertextag2sidestart, vertextag2sideend, vertex1, vertex0, null)
     return null
   }
   // add the side to the mappings
-  const newsideobj = {
+  const newSideObj = {
     vertex0: vertex0,
     vertex1: vertex1,
-    polygonindex: polygonindex
+    polygonIndex
   }
-  if (!(sidemap.has(newsidetag))) {
-    sidemap.set(newsidetag, [newsideobj])
+  if (!(sideMap.has(newSideTag))) {
+    sideMap.set(newSideTag, [newSideObj])
   } else {
-    sidemap.get(newsidetag).push(newsideobj)
+    sideMap.get(newSideTag).push(newSideObj)
   }
-  if (vertextag2sidestart.has(starttag)) {
-    vertextag2sidestart.get(starttag).push(newsidetag)
+  if (vertextag2sidestart.has(startTag)) {
+    vertextag2sidestart.get(startTag).push(newSideTag)
   } else {
-    vertextag2sidestart.set(starttag, [newsidetag])
+    vertextag2sidestart.set(startTag, [newSideTag])
   }
-  if (vertextag2sideend.has(endtag)) {
-    vertextag2sideend.get(endtag).push(newsidetag)
+  if (vertextag2sideend.has(endTag)) {
+    vertextag2sideend.get(endTag).push(newSideTag)
   } else {
-    vertextag2sideend.set(endtag, [newsidetag])
+    vertextag2sideend.set(endTag, [newSideTag])
   }
-  return 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')
+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
+  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)
+  sideObjs.splice(idx, 1)
+  if (sideObjs.length === 0) {
+    sidemap.delete(sideTag)
   }
 
   // adjust start and end lists
-  idx = vertextag2sidestart.get(starttag).indexOf(sidetag)
+  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)
+  vertextag2sidestart.get(startTag).splice(idx, 1)
+  if (vertextag2sidestart.get(startTag).length === 0) {
+    vertextag2sidestart.delete(startTag)
   }
 
-  idx = vertextag2sideend.get(endtag).indexOf(sidetag)
+  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)
+  vertextag2sideend.get(endTag).splice(idx, 1)
+  if (vertextag2sideend.get(endTag).length === 0) {
+    vertextag2sideend.delete(endTag)
   }
 }
 
@@ -97,76 +98,76 @@ const deleteSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, ve
 
   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 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
+ * 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) => {
+export 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) {
+  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
+      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 nextVertex = polygon.vertices[nextVertexIndex]
+        const nextVertexTag = getTag(nextVertex)
 
-        const sidetag = `${vertextag}/${nextvertextag}`
-        const reversesidetag = `${nextvertextag}/${vertextag}`
-        if (sidemap.has(reversesidetag)) {
+        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)
+          const ar = sideMap.get(reverseSideTag)
           ar.splice(-1, 1)
           if (ar.length === 0) {
-            sidemap.delete(reversesidetag)
+            sideMap.delete(reverseSideTag)
           }
         } else {
           const sideobj = {
             vertex0: vertex,
-            vertex1: nextvertex,
-            polygonindex: polygonindex
+            vertex1: nextVertex,
+            polygonIndex
           }
-          if (!(sidemap.has(sidetag))) {
-            sidemap.set(sidetag, [sideobj])
+          if (!(sideMap.has(sideTag))) {
+            sideMap.set(sideTag, [sideobj])
           } else {
-            sidemap.get(sidetag).push(sideobj)
+            sideMap.get(sideTag).push(sideobj)
           }
         }
-        vertex = nextvertex
-        vertextag = nextvertextag
+        vertex = nextVertex
+        vertexTag = nextVertexTag
       }
     } else {
       console.warn('warning: invalid polygon found during insertTjunctions')
     }
   }
 
-  if (sidemap.size > 0) {
+  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) {
+    for (const [sidetag, sideObjs] of sideMap) {
       sidesToCheck.set(sidetag, true)
-      sideobjs.forEach((sideobj) => {
-        const starttag = getTag(sideobj.vertex0)
-        const endtag = getTag(sideobj.vertex1)
+      sideObjs.forEach((sideObj) => {
+        const starttag = getTag(sideObj.vertex0)
+        const endtag = getTag(sideObj.vertex1)
         if (vertextag2sidestart.has(starttag)) {
           vertextag2sidestart.get(starttag).push(sidetag)
         } else {
@@ -180,115 +181,113 @@ const insertTjunctions = (polygons) => {
       })
     }
 
-    // STEP 3 : if sidemap is not empty
-    const newpolygons = polygons.slice(0) // make a copy in order to replace polygons inline
+    // 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
+      if (sideMap.size === 0) break
 
-      for (const sidetag of sidemap.keys()) {
-        sidesToCheck.set(sidetag, true)
+      for (const sideTag of sideMap.keys()) {
+        sidesToCheck.set(sideTag, true)
       }
 
-      let donesomething = false
+      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)
+        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)
+              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
+            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)
+                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
+                  const closestVertex = vec3.scale(vec3.create(), direction, t)
+                  vec3.add(closestVertex, closestVertex, startPos)
+                  const distanceSquared = vec3.squaredDistance(closestVertex, endPos)
+                  if (distanceSquared < (EPS * 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
+                      if (getTag(polygon.vertices[i]) === insertionVertexTag) {
+                        insertionVertexTagIndex = i
                         break
                       }
                     }
-                    if (assert && insertionvertextagindex < 0) throw new Error('assert failed')
+                    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)
+                    const newVertices = polygon.vertices.slice(0)
+                    newVertices.splice(insertionVertexTagIndex, 0, endVertex)
+                    const newPolygon = poly3.create(newVertices)
 
-                    newpolygons[polygonindex] = newpolygon
+                    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
+                    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(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(endingSideStartVertexTag === endVertexTag)
+            } // for matchingSideIndex
+          } // for directionIndex
+        } // if(sideTagToCheck in sideMap)
+        if (doneWithSide) {
+          sidesToCheck.delete(sideTagToCheck)
         }
       }
-      if (!donesomething) break
+      if (!doneSomething) break
     }
-    polygons = newpolygons
+    polygons = newPolygons
   }
-  sidemap.clear()
+  sideMap.clear()
 
   return polygons
 }
-
-module.exports = insertTjunctions

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

@@ -1,12 +1,12 @@
-const test = require('ava')
+import test from 'ava'
 
-const { comparePolygonLists } = require('../../../test/helpers')
+import { comparePolygonLists } from '../../../test/helpers/index.js'
 
-const { geom3, poly3 } = require('../../geometries')
+import { geom3, poly3 } from '../../geometries/index.js'
 
-const { cuboid } = require('../../primitives')
+import { cuboid } from '../../primitives/index.js'
 
-const insertTjunctions = require('./insertTjunctions')
+import { insertTjunctions } from './insertTjunctions.js'
 
 test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
   const geometry1 = geom3.create()

package/src/operations/modifiers/mergePolygons.js

@@ -1,23 +1,24 @@
-const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
-const vec3 = require('../../maths/vec3')
+import { aboutEqualNormals } from '../../maths/utils/aboutEqualNormals.js'
 
-const poly3 = require('../../geometries/poly3')
+import * as vec3 from '../../maths/vec3/index.js'
+
+import * as poly3 from '../../geometries/poly3/index.js'
 
 // create a set of edges from the given polygon, and link the edges as well
 const createEdges = (polygon) => {
-  const points = poly3.toPoints(polygon)
+  const vertices = poly3.toVertices(polygon)
   const edges = []
-  for (let i = 0; i < points.length; i++) {
-    const j = (i + 1) % points.length
+  for (let i = 0; i < vertices.length; i++) {
+    const j = (i + 1) % vertices.length
     const edge = {
-      v1: points[i],
-      v2: points[j]
+      v1: vertices[i],
+      v2: vertices[j]
     }
     edges.push(edge)
   }
   // link the edges together
   for (let i = 0; i < edges.length; i++) {
-    const j = (i + 1) % points.length
+    const j = (i + 1) % vertices.length
     edges[i].next = edges[j]
     edges[j].prev = edges[i]
   }
@@ -57,9 +58,9 @@ const calculateAnglesBetween = (current, opposite, normal) => {
 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)
+const calculateAngle = (prevVertex, midVertex, nextVertex, normal) => {
+  const d0 = vec3.subtract(v1, midVertex, prevVertex)
+  const d1 = vec3.subtract(v2, nextVertex, midVertex)
   vec3.cross(d0, d0, d1)
   return vec3.dot(d0, normal)
 }
@@ -67,11 +68,11 @@ const calculateAngle = (prevpoint, point, nextpoint, normal) => {
 // create a polygon starting from the given edge (if possible)
 const createPolygonAnd = (edge) => {
   let polygon
-  const points = []
+  const vertices = []
   while (edge.next) {
     const next = edge.next
 
-    points.push(edge.v1)
+    vertices.push(edge.v1)
 
     edge.v1 = null
     edge.v2 = null
@@ -80,20 +81,20 @@ const createPolygonAnd = (edge) => {
 
     edge = next
   }
-  if (points.length > 0) polygon = poly3.create(points)
+  if (vertices.length > 0) polygon = poly3.create(vertices)
   return polygon
 }
 
 /*
  * Merge COPLANAR polygons that share common edges.
- * @param {poly3[]} sourcepolygons - list of polygons
- * @returns {poly3[]} new set of polygons
+ * @param {Poly3[]} sourcePolygons - list of polygons
+ * @returns {Poly3[]} new set of polygons
  */
-const mergeCoplanarPolygons = (sourcepolygons) => {
-  if (sourcepolygons.length < 2) return sourcepolygons
+export const mergeCoplanarPolygons = (sourcePolygons) => {
+  if (sourcePolygons.length < 2) return sourcePolygons
 
-  const normal = sourcepolygons[0].plane
-  const polygons = sourcepolygons.slice()
+  const normal = sourcePolygons[0].plane
+  const polygons = sourcePolygons.slice()
   const edgeList = new Map()
 
   while (polygons.length > 0) { // NOTE: the length of polygons WILL change
@@ -128,15 +129,15 @@ const mergeCoplanarPolygons = (sourcepolygons) => {
           opposite.prev = null
 
           const mergeEdges = (list, e1, e2) => {
-            const newedge = {
+            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
+            // link in newEdge
+            e2.prev.next = newEdge
+            e1.next.prev = newEdge
             // remove old edges
             deleteEdge(list, e1)
             e1.v1 = null
@@ -165,15 +166,15 @@ const mergeCoplanarPolygons = (sourcepolygons) => {
   }
 
   // build a set of polygons from the remaining edges
-  const destpolygons = []
+  const destPolygons = []
   edgeList.forEach((edge) => {
     const polygon = createPolygonAnd(edge)
-    if (polygon) destpolygons.push(polygon)
+    if (polygon) destPolygons.push(polygon)
   })
 
   edgeList.clear()
 
-  return destpolygons
+  return destPolygons
 }
 
 const coplanar = (plane1, plane2) => {
@@ -184,7 +185,7 @@ const coplanar = (plane1, plane2) => {
   return false
 }
 
-const mergePolygons = (epsilon, polygons) => {
+export const mergePolygons = (epsilon, polygons) => {
   const polygonsPerPlane = [] // elements: [plane, [poly3...]]
   polygons.forEach((polygon) => {
     const mapping = polygonsPerPlane.find((element) => coplanar(element[0], poly3.plane(polygon)))
@@ -196,13 +197,11 @@ const mergePolygons = (epsilon, polygons) => {
     }
   })
 
-  let destpolygons = []
+  let destPolygons = []
   polygonsPerPlane.forEach((mapping) => {
-    const sourcepolygons = mapping[1]
-    const retesselayedpolygons = mergeCoplanarPolygons(sourcepolygons)
-    destpolygons = destpolygons.concat(retesselayedpolygons)
+    const sourcePolygons = mapping[1]
+    const retesselatedPolygons = mergeCoplanarPolygons(sourcePolygons)
+    destPolygons = destPolygons.concat(retesselatedPolygons)
   })
-  return destpolygons
+  return destPolygons
 }
-
-module.exports = mergePolygons