@jscad/modeling 2.9.2 → 2.9.3

package/src/operations/modifiers/mergePolygons.js

@@ -1,3 +1,4 @@
+const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
 const vec3 = require('../../maths/vec3')
 
 const poly3 = require('../../geometries/poly3')
@@ -53,9 +54,12 @@ const calculateAnglesBetween = (current, opposite, normal) => {
   return [angle1, angle2]
 }
 
+const v1 = vec3.create()
+const v2 = vec3.create()
+
 const calculateAngle = (prevpoint, point, nextpoint, normal) => {
-  const d0 = vec3.subtract(vec3.create(), point, prevpoint)
-  const d1 = vec3.subtract(vec3.create(), nextpoint, point)
+  const d0 = vec3.subtract(v1, point, prevpoint)
+  const d1 = vec3.subtract(v2, nextpoint, point)
   vec3.cross(d0, d0, d1)
   return vec3.dot(d0, normal)
 }
@@ -76,7 +80,7 @@ const createPolygonAnd = (edge) => {
 
     edge = next
   }
-  if (points.length > 0) polygon = poly3.fromPoints(points)
+  if (points.length > 0) polygon = poly3.create(points)
   return polygon
 }
 
@@ -85,7 +89,7 @@ const createPolygonAnd = (edge) => {
  * @param {poly3[]} sourcepolygons - list of polygons
  * @returns {poly3[]} new set of polygons
  */
-const mergeCoplanarPolygons = (epsilon, sourcepolygons) => {
+const mergeCoplanarPolygons = (sourcepolygons) => {
   if (sourcepolygons.length < 2) return sourcepolygons
 
   const normal = sourcepolygons[0].plane
@@ -167,18 +171,11 @@ const mergeCoplanarPolygons = (epsilon, sourcepolygons) => {
     if (polygon) destpolygons.push(polygon)
   })
 
+  edgeList.clear()
+
   return destpolygons
 }
 
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparision
-// This EPS is derived from a serieas of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
-
-// Compare two normals (unit vectors) for equality.
-const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
-
 const coplanar = (plane1, plane2) => {
   // expect the same distance from the origin, within tolerance
   if (Math.abs(plane1[3] - plane2[3]) < 0.00000015) {
@@ -202,7 +199,7 @@ const mergePolygons = (epsilon, polygons) => {
   let destpolygons = []
   polygonsPerPlane.forEach((mapping) => {
     const sourcepolygons = mapping[1]
-    const retesselayedpolygons = mergeCoplanarPolygons(epsilon, sourcepolygons)
+    const retesselayedpolygons = mergeCoplanarPolygons(sourcepolygons)
     destpolygons = destpolygons.concat(retesselayedpolygons)
   })
   return destpolygons

package/src/operations/{booleans → modifiers}/reTesselateCoplanarPolygons.js

@@ -31,7 +31,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
   // convert all polygon vertices to 2D
   // Make a list of all encountered y coordinates
   // And build a map of all polygons that have a vertex at a certain y coordinate:
-  const ycoordinateBinningFactor = 1.0 / EPS * 10
+  const ycoordinateBinningFactor = 10 / EPS
   for (let polygonindex = 0; polygonindex < numpolygons; polygonindex++) {
     const poly3d = sourcepolygons[polygonindex]
     let vertices2d = []

package/src/operations/{booleans → modifiers}/reTesselateCoplanarPolygons.test.js

@@ -17,11 +17,11 @@ const rotatePoly3 = (angles, polygon) => {
 }
 
 test.only('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
-  const polyA = poly3.fromPoints([[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]])
-  const polyB = poly3.fromPoints([[5, -5, 0], [8, 0, 0], [5, 5, 0]])
-  const polyC = poly3.fromPoints([[-5, 5, 0], [-8, 0, 0], [-5, -5, 0]])
-  const polyD = poly3.fromPoints([[-5, 5, 0], [5, 5, 0], [0, 8, 0]])
-  const polyE = poly3.fromPoints([[5, -5, 0], [-5, -5, 0], [0, -8, 0]])
+  const polyA = poly3.create([[-5, -5, 0], [5, -5, 0], [5, 5, 0], [-5, 5, 0]])
+  const polyB = poly3.create([[5, -5, 0], [8, 0, 0], [5, 5, 0]])
+  const polyC = poly3.create([[-5, 5, 0], [-8, 0, 0], [-5, -5, 0]])
+  const polyD = poly3.create([[-5, 5, 0], [5, 5, 0], [0, 8, 0]])
+  const polyE = poly3.create([[5, -5, 0], [-5, -5, 0], [0, -8, 0]])
 
   // combine polygons in each direction
   let obs = reTesselateCoplanarPolygons([polyA, polyB])

package/src/operations/{booleans → modifiers}/retessellate.js

@@ -1,16 +1,9 @@
 const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
-const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
-
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
-// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
+const aboutEqualNormals = require('../../maths/utils/aboutEqualNormals')
 
-// Compare two normals (unit vectors) for equality.
-const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
+const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
 
 const coplanar = (plane1, plane2) => {
   // expect the same distance from the origin, within tolerance

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

@@ -7,49 +7,49 @@ const snapPolygons = require('./snapPolygons')
 test('snapPolygons: snap of polygons produces expected results', (t) => {
   const polygons = [
     // valid polygons
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]]), // OK
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]]), // OK
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10]]), // OK
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]]), // OK
     // invalid polygons
     poly3.create(),
-    poly3.fromPoints([[0, 0, 0]]),
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0]]),
+    poly3.create([[0, 0, 0]]),
+    poly3.create([[0, 0, 0], [0, 10, 0]]),
     // duplicated vertices
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-24.44446933333345, 19.346837333333426, 46.47508266666689],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]), // OK
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]),
-    poly3.fromPoints([
+    poly3.create([
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]),
     // duplicate vertices after snap
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-24.44446933333345, 19.346837333333426, 46.47508266666689],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]), // OK
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
-    poly3.fromPoints([
+    poly3.create([
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
     // inverted polygon
-    poly3.fromPoints([
+    poly3.create([
       [20.109133333333336, -4.894033333333335, -1.0001266666666668],
       [20.021120000000003, -5.1802133333333344, -1.0001266666666668],
       [20.020300000000002, -5.182946666666668, -1.0001266666666668],
@@ -61,7 +61,7 @@ test('snapPolygons: snap of polygons produces expected results', (t) => {
   const results = snapPolygons(0.0001, polygons)
   t.is(results.length, 5)
 
-  const exp3 = poly3.fromPoints([
+  const exp3 = poly3.create([
     [-24.4451, 19.3468, 46.4757],
     [-24.4445, 19.3468, 46.475100000000005],
     [-23.7054, 18.7986, 39.5645]

package/src/operations/modifiers/triangulatePolygons.js

@@ -10,15 +10,15 @@ const triangulatePolygon = (epsilon, polygon, triangles) => {
       polygon.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice))
       vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon)
       for (let i = 0; i < nv; i++) {
-        const poly = poly3.fromPoints([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
+        const poly = poly3.create([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
         if (polygon.color) poly.color = polygon.color
         triangles.push(poly)
       }
       return
     }
     // exactly 4 vertices, use simple triangulation
-    const poly0 = poly3.fromPoints([polygon.vertices[0], polygon.vertices[1], polygon.vertices[2]])
-    const poly1 = poly3.fromPoints([polygon.vertices[0], polygon.vertices[2], polygon.vertices[3]])
+    const poly0 = poly3.create([polygon.vertices[0], polygon.vertices[1], polygon.vertices[2]])
+    const poly1 = poly3.create([polygon.vertices[0], polygon.vertices[2], polygon.vertices[3]])
     if (polygon.color) {
       poly0.color = polygon.color
       poly1.color = polygon.color

package/src/operations/transforms/center.js

@@ -39,7 +39,7 @@ const center = (options, ...objects) => {
   const defaults = {
     axes: [true, true, true],
     relativeTo: [0, 0, 0]
-  // TODO : Add addition 'methods' of centering; midpoint, centeriod
+  // TODO: Add additional 'methods' of centering: midpoint, centroid
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 

package/src/primitives/cuboid.js

@@ -43,7 +43,7 @@ const cuboid = (options) => {
         ]
         return pos
       })
-      return poly3.fromPoints(points)
+      return poly3.create(points)
     })
   )
   return result

package/src/primitives/cylinderElliptic.js

@@ -90,7 +90,7 @@ const cylinderElliptic = (options) => {
   // adjust the points to center
   const fromPoints = (...points) => {
     const newpoints = points.map((point) => vec3.add(vec3.create(), point, center))
-    return poly3.fromPoints(newpoints)
+    return poly3.create(newpoints)
   }
 
   const polygons = []

package/src/primitives/ellipsoid.js

@@ -66,7 +66,7 @@ const ellipsoid = (options) => {
           point = vec3.subtract(vec3.create(), vec3.scale(p1, prevcylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
           points.push(vec3.add(point, point, center))
 
-          polygons.push(poly3.fromPoints(points))
+          polygons.push(poly3.create(points))
 
           points = []
           point = vec3.add(vec3.create(), vec3.scale(p1, prevcylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
@@ -81,7 +81,7 @@ const ellipsoid = (options) => {
           points.push(vec3.add(vec3.create(), center, point))
           points.reverse()
 
-          polygons.push(poly3.fromPoints(points))
+          polygons.push(poly3.create(points))
         }
         prevcospitch = cospitch
         prevsinpitch = sinpitch

package/src/primitives/polyhedron.js

@@ -60,7 +60,7 @@ const polyhedron = (options) => {
   }
 
   const polygons = faces.map((face, findex) => {
-    const polygon = poly3.fromPoints(face.map((pindex) => points[pindex]))
+    const polygon = poly3.create(face.map((pindex) => points[pindex]))
     if (colors && colors[findex]) polygon.color = colors[findex]
     return polygon
   })

package/src/primitives/roundedCuboid.js

@@ -57,10 +57,10 @@ const stitchCorners = (previousCorners, currentCorners) => {
     const previous = previousCorners[i]
     const current = currentCorners[i]
     for (let j = 0; j < (previous.length - 1); j++) {
-      polygons.push(poly3.fromPoints([previous[j], previous[j + 1], current[j]]))
+      polygons.push(poly3.create([previous[j], previous[j + 1], current[j]]))
 
       if (j < (current.length - 1)) {
-        polygons.push(poly3.fromPoints([current[j], previous[j + 1], current[j + 1]]))
+        polygons.push(poly3.create([current[j], previous[j + 1], current[j + 1]]))
       }
     }
   }
@@ -81,7 +81,7 @@ const stitchWalls = (previousCorners, currentCorners) => {
     const p1 = previous[0]
     const c1 = current[0]
 
-    polygons.push(poly3.fromPoints([p0, p1, c1, c0]))
+    polygons.push(poly3.create([p0, p1, c1, c0]))
   }
   return polygons
 }
@@ -104,7 +104,7 @@ const stitchSides = (bottomCorners, topCorners) => {
   const polygons = []
   for (let i = 0; i < topPoints.length; i++) {
     const j = (i + 1) % topPoints.length
-    polygons.push(poly3.fromPoints([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
+    polygons.push(poly3.create([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
   }
   return polygons
 }
@@ -168,10 +168,10 @@ const roundedCuboid = (options) => {
     if (slice === segments) {
       // add the top
       let points = cornersPos.map((corner) => corner[0])
-      polygons.push(poly3.fromPoints(points))
+      polygons.push(poly3.create(points))
       // add the bottom
       points = cornersNeg.map((corner) => corner[0])
-      polygons.push(poly3.fromPoints(points))
+      polygons.push(poly3.create(points))
     }
 
     prevCornersPos = cornersPos

package/src/primitives/roundedCylinder.js

@@ -66,7 +66,7 @@ const roundedCylinder = (options) => {
   const fromPoints = (points) => {
     // adjust the points to center
     const newpoints = points.map((point) => vec3.add(point, point, center))
-    return poly3.fromPoints(newpoints)
+    return poly3.create(newpoints)
   }
 
   const polygons = []

package/src/primitives/torus.test.js

@@ -10,24 +10,24 @@ test('torus (defaults)', (t) => {
   const obs = torus()
   const pts = geom3.toPoints(obs)
 
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 2048) // 32 * 32 * 2 (polys/segment) = 2048
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
-test('torus (Simple options)', (t) => {
+test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
   const pts = geom3.toPoints(obs)
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 64) // 4 * 8 * 2 (polys/segment) = 64
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5.5, -5.5, -0.5], [5.5, 5.5, 0.5]]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
@@ -48,6 +48,6 @@ test('torus (square by square)', (t) => {
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })

package/src/primitives/triangle.js

@@ -1,11 +1,10 @@
+const { NEPS } = require('../maths/constants')
 const vec2 = require('../maths/vec2')
 
 const geom2 = require('../geometries/geom2')
 
 const { isNumberArray } = require('./commonChecks')
 
-const NEPS = 1e-13
-
 // returns angle C
 const solveAngleFromSSS = (a, b, c) => Math.acos(((a * a) + (b * b) - (c * c)) / (2 * a * b))
 

package/src/utils/trigonometry.js

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

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

@@ -1,9 +0,0 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default eachPoint
-
-export interface EachPointOptions {}
-export type EachPointThunk = (value: Vec2, index: number, array: Array<Vec2>) => void
-
-declare function eachPoint(options: EachPointOptions, thunk: EachPointThunk, path: Path2): void

package/src/geometries/path2/eachPoint.js

@@ -1,17 +0,0 @@
-const toPoints = require('./toPoints')
-
-/**
- * Calls a function for each point in the path.
- * @param {Object} options - options
- * @param {Function} thunk - the function to call
- * @param {path2} path - the path to traverse
- * @alias module:modeling/geometries/path2.eachPoint
- *
- * @example
- * eachPoint({}, accumulate, path)
- */
-const eachPoint = (options, thunk, path) => {
-  toPoints(path).forEach(thunk)
-}
-
-module.exports = eachPoint

package/src/geometries/path2/eachPoint.test.js

@@ -1,11 +0,0 @@
-const test = require('ava')
-
-const vec2 = require('../../maths/vec2')
-
-const { eachPoint, fromPoints } = require('./index')
-
-test('eachPoint: Each point is emitted', (t) => {
-  const collector = []
-  eachPoint({}, (point) => collector.push(point), fromPoints({}, [[1, 1], [2, 2]]))
-  t.deepEqual(collector, [vec2.fromValues(1, 1), vec2.fromValues(2, 2)])
-})

package/src/operations/modifiers/edges.js

@@ -1,195 +0,0 @@
-const vec3 = require('../../maths/vec3')
-const line3 = require('../../maths/line3')
-
-const poly3 = require('../../geometries/poly3')
-
-/*
- * Add a unique edge to the given list of edges.
- * Each edge has a list of associated polygons.
- * Edges with two polygons are complete, while edges with one polygon are open, i.e hole or t-junction..
- */
-const addEdge = (edges, edge, polygon) => {
-  const ei = edges.findIndex((element) => {
-    if (element) {
-      if (vec3.equals(element[0], edge[0]) && vec3.equals(element[1], edge[1])) return true
-      if (vec3.equals(element[0], edge[1]) && vec3.equals(element[1], edge[0])) return true
-    }
-    return false
-  })
-  if (ei >= 0) {
-    edge = edges[ei]
-    edge.polygons.push(polygon)
-  } else {
-    edge.polygons = [polygon]
-    edges.push(edge)
-  }
-}
-
-/*
- * Remove the edge from the given list of edges.
- */
-const removeEdge = (edges, edge) => {
-  const ei = edges.findIndex((element) => {
-    if (element) {
-      if (vec3.equals(element[0], edge[0]) && vec3.equals(element[1], edge[1])) return true
-      if (vec3.equals(element[0], edge[1]) && vec3.equals(element[1], edge[0])) return true
-    }
-    return false
-  })
-  if (ei >= 0) {
-    edges[ei].polygons = []
-    edges[ei] = null
-  }
-}
-
-/*
- * Add all edges of the polygon to the given list of edges.
- */
-const addPolygon = (edges, polygon) => {
-  const vertices = polygon.vertices
-  const nv = vertices.length
-
-  let edge = [vertices[nv - 1], vertices[0]]
-  addEdge(edges, edge, polygon)
-
-  for (let i = 0; i < (nv - 1); i++) {
-    edge = [vertices[i], vertices[i + 1]]
-    addEdge(edges, edge, polygon)
-  }
-}
-
-/*
- * Remove all polygons associated with the old edge from the given list of edges.
- */
-const removePolygons = (edges, oldedge) => {
-  // console.log('removePolygons',oldedge)
-  const polygons = oldedge.polygons
-  polygons.forEach((polygon) => {
-    const vertices = polygon.vertices
-    const nv = vertices.length
-
-    let edge = [vertices[nv - 1], vertices[0]]
-    removeEdge(edges, edge)
-
-    for (let i = 0; i < (nv - 1); i++) {
-      edge = [vertices[i], vertices[i + 1]]
-      removeEdge(edges, edge)
-    }
-  })
-}
-
-/*
- * Split the polygon, ensuring one polygon includes the open edge.
- */
-const splitPolygon = (openedge, polygon, eps) => {
-  // console.log('splitPolygon',openedge,polygon)
-  const vertices = polygon.vertices
-  const i = vertices.findIndex((point) => almostEquals(eps, point, openedge[0]))
-  const polygon1 = poly3.fromPoints([vertices[(i + 0) % 3], vertices[(i + 1) % 3], openedge[1]])
-  const polygon2 = poly3.fromPoints([openedge[1], vertices[(i + 1) % 3], vertices[(i + 2) % 3]])
-  if (polygon.color) {
-    polygon1.color = polygon.color
-    polygon2.color = polygon.color
-  }
-  // console.log('polygon1',polygon1)
-  // console.log('polygon2',polygon2)
-  return [polygon1, polygon2]
-}
-
-/*
- * TBD This should be part of vec3.
- */
-const almostEquals = (eps, v1, v2) => (Math.abs(v1[0] - v2[0]) <= eps && Math.abs(v1[1] - v2[1]) <= eps && Math.abs(v1[2] - v2[2]) <= eps)
-
-const enclosedEdge = (openedge, edge, eps) => {
-  if (openedge.distance < edge.distance) {
-    // only look for opposing edges
-    if (vec3.equals(openedge[0], edge[1])) {
-      // only opposing open edges enclosed by the edge
-      const distanceE0O0 = vec3.squaredDistance(openedge[0], edge[0])
-      const distanceE0O1 = vec3.squaredDistance(openedge[1], edge[0])
-      const distanceE1O0 = vec3.squaredDistance(openedge[0], edge[1])
-      const distanceE1O1 = vec3.squaredDistance(openedge[1], edge[1])
-      if (distanceE0O0 <= edge.distance && distanceE0O1 < edge.distance && distanceE1O0 < edge.distance && distanceE1O1 < edge.distance) {
-        // only look for paralell open edges
-        const line3d = line3.fromPoints(edge[0], edge[1])
-        const closest0 = vec3.snap(vec3.create(), eps, line3.closestPoint(openedge[0], line3d))
-        const closest1 = vec3.snap(vec3.create(), eps, line3.closestPoint(openedge[1], line3d))
-        if (almostEquals(eps, closest0, openedge[0]) && almostEquals(eps, closest1, openedge[1])) {
-          return true
-        }
-      }
-    }
-  }
-  return false
-}
-
-/*
- * Split the edge if posssible from the list of open edges.
- * Return a list of new polygons, or null if not possible
- */
-const splitEdge = (openedges, edge, eps) => {
-  // console.log('splitEdge',edge)
-  for (let i = 0; i < openedges.length; i++) {
-    const openedge = openedges[i]
-    if (openedge) {
-      if (enclosedEdge(openedge, edge, eps)) {
-        // spit the polygon associated with the edge
-        const polygon = edge.polygons[0]
-        const newpolygons = splitPolygon(openedge, polygon, eps)
-        return newpolygons
-      }
-    }
-  }
-  return null
-}
-
-/*
- * Cull a list of open edges (see above) from the list of edges.
- */
-const cullOpenEdges = (edges) => {
-  const openedges = []
-  edges.forEach((edge) => {
-    const polygons = edge.polygons
-    if (polygons.length === 1) {
-      // console.log('open edge: ',edge[0],'<-->',edge[1])
-      edge.distance = vec3.squaredDistance(edge[0], edge[1])
-      openedges.push(edge)
-    }
-  })
-  // console.log('open edges:',openedges.length)
-  // console.log('**********OPEN*********')
-  // console.log(openedges)
-  // console.log('**********OPEN*********')
-  return openedges
-}
-
-/*
- * Convert the list of edges into a list of polygons.
- */
-const edgesToPolygons = (edges) => {
-  const polygons = []
-  edges.forEach((edge) => {
-    if (edge && edge.polygons) {
-      edge.polygons.forEach((polygon) => {
-        if (polygon.visited) return
-        polygon.visited = true
-        polygons.push(polygon)
-      })
-    }
-  })
-  return polygons
-}
-
-/*
- * Convert the given list of polygons to a list of edges.
- */
-const polygonsToEdges = (polygons) => {
-  const edges = []
-  polygons.forEach((polygon) => {
-    addPolygon(edges, polygon)
-  })
-  return edges
-}
-
-module.exports = { polygonsToEdges, edgesToPolygons, cullOpenEdges, splitEdge, removePolygons, addPolygon }

package/src/operations/modifiers/repairTjunctions.js

@@ -1,44 +0,0 @@
-const { polygonsToEdges, edgesToPolygons, cullOpenEdges, splitEdge, removePolygons, addPolygon } = require('./edges')
-
-/*
- */
-const repairTjunctions = (epsilon, polygons) => {
-  const edges = polygonsToEdges(polygons)
-  let openedges = cullOpenEdges(edges)
-  if (openedges.length === 0) return polygons
-
-  // split open edges until no longer possible
-  let splitting = true
-  while (splitting) {
-    let splitcount = 0
-    for (let i = 0; i < openedges.length; i++) {
-      const edge = openedges[i]
-      if (edge && edge.polygons && edge.polygons.length === 1) {
-        const newpolygons = splitEdge(openedges, edge, epsilon)
-        if (newpolygons) {
-          openedges[i] = null
-          addPolygon(openedges, newpolygons[0])
-          addPolygon(openedges, newpolygons[1])
-
-          // adjust the master list as well
-          removePolygons(edges, edge)
-          // add edges for each new polygon
-          addPolygon(edges, newpolygons[0])
-          addPolygon(edges, newpolygons[1])
-
-          splitcount++
-          break // start again
-        }
-      }
-    }
-    splitting = (splitcount > 0)
-  }
-  openedges = openedges.filter((edge) => (edge && edge.polygons && edge.polygons.length === 1))
-  if (openedges.length > 0) console.warn('Repair of all T-junctions failed:', openedges.length)
-
-  // rebuild the list of polygons from the edges
-  polygons = edgesToPolygons(edges)
-  return polygons
-}
-
-module.exports = repairTjunctions