@jscad/modeling 2.9.0 → 2.9.3

package/src/operations/hulls/hullPoints2.js

@@ -1,108 +1,59 @@
 const vec2 = require('../../maths/vec2')
 
-const angleBetweenPoints = (p0, p1) => Math.atan2((p1[1] - p0[1]), (p1[0] - p0[0]))
-
-const compareIndex = (index1, index2) => {
-  if (index1.angle < index2.angle) {
-    return -1
-  } else if (index1.angle > index2.angle) {
-    return 1
-  } else {
-    if (index1.distance < index2.distance) {
-      return -1
-    } else if (index1.distance > index2.distance) {
-      return 1
-    }
-  }
-  return 0
-}
-
-// Ported from https://github.com/bkiers/GrahamScan
-const compute = (points) => {
-  if (points.length < 3) {
-    return points
-  }
-
-  // Find the lowest point
-  let min = 0
-  points.forEach((point, i) => {
-    const minpoint = points[min]
-    if (point[1] === minpoint[1]) {
-      if (point[0] < minpoint[0]) {
-        min = i
-      }
-    } else if (point[1] < minpoint[1]) {
-      min = i
+/*
+ * Create a convex hull of the given set of points, where each point is an array of [x,y].
+ * Uses https://en.wikipedia.org/wiki/Graham_scan
+ * @param {Array} uniquePoints - list of UNIQUE points from which to create a hull
+ * @returns {Array} a list of points that form the hull
+ */
+const hullPoints2 = (uniquePoints) => {
+  // find min point
+  let min = vec2.fromValues(Infinity, Infinity)
+  uniquePoints.forEach((point) => {
+    if (point[1] < min[1] || (point[1] === min[1] && point[0] < min[0])) {
+      min = point
     }
   })
 
-  // Calculate angles and distances from the lowest point
-  const al = []
-  let angle = 0.0
-  let dist = 0.0
-  for (let i = 0; i < points.length; i++) {
-    if (i === min) {
-      continue
-    }
-    angle = angleBetweenPoints(points[min], points[i])
-    if (angle < 0) {
-      angle += Math.PI
-    }
-    dist = vec2.squaredDistance(points[min], points[i])
-    al.push({ index: i, angle: angle, distance: dist })
-  }
-
-  al.sort((a, b) => compareIndex(a, b))
-
-  // Wind around the points CCW, removing interior points
-  const stack = new Array(points.length + 1)
-  let j = 2
-  for (let i = 0; i < points.length; i++) {
-    if (i === min) {
-      continue
-    }
-    stack[j] = al[j - 2].index
-    j++
-  }
-  stack[0] = stack[points.length]
-  stack[1] = min
+  // gather information for sorting by polar coordinates (point, angle, distSq)
+  const points = []
+  uniquePoints.forEach((point) => {
+    // use faster fakeAtan2 instead of Math.atan2
+    const angle = fakeAtan2(point[1] - min[1], point[0] - min[0])
+    const distSq = vec2.squaredDistance(point, min)
+    points.push({ point, angle, distSq })
+  })
 
-  // clockwise < 0, colinear = 0, counter clockwise > 0
-  const ccw = (i1, i2, i3) => (points[i2][0] - points[i1][0]) * (points[i3][1] - points[i1][1]) - (points[i2][1] - points[i1][1]) * (points[i3][0] - points[i1][0])
+  // sort by polar coordinates
+  points.sort((pt1, pt2) => pt1.angle < pt2.angle ? -1 : pt1.angle > pt2.angle ? 1 :
+    pt1.distSq < pt2.distSq ? -1 : pt1.distSq > pt2.distSq ? 1 : 0)
 
-  let tmp
-  let M = 2
-  for (let i = 3; i <= points.length; i++) {
-    while (ccw(stack[M - 1], stack[M], stack[i]) < Number.EPSILON) {
-      M--
+  const stack = [] // start with empty stack
+  points.forEach((point) => {
+    let cnt = stack.length
+    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point.point) <= Number.EPSILON) {
+      stack.pop() // get rid of colinear and interior (clockwise) points
+      cnt = stack.length
     }
-    M++
-    tmp = stack[i]
-    stack[i] = stack[M]
-    stack[M] = tmp
-  }
+    stack.push(point.point)
+  })
 
-  // Return the indices to the points
-  const indices = new Array(M)
-  for (let i = 0; i < M; i++) {
-    indices[i] = stack[i + 1]
-  }
-  return indices
+  return stack
 }
 
-/*
- * Create a convex hull of the given set of points,  where each point is an array of [x,y].
- * @param {Array} uniquepoints - list of UNIQUE points from which to create a hull
- * @returns {Array} a list of points that form the hull
- */
-const hullPoints2 = (uniquepoints) => {
-  const indices = compute(uniquepoints)
+// returns: < 0 clockwise, 0 colinear, > 0 counter-clockwise
+const ccw = (v1, v2, v3) => (v2[0] - v1[0]) * (v3[1] - v1[1]) - (v2[1] - v1[1]) * (v3[0] - v1[0])
 
-  let hullpoints = []
-  if (Array.isArray(indices)) {
-    hullpoints = indices.map((index) => uniquepoints[index])
+// Returned "angle" is really 1/tan (inverse of slope) made negative to increase with angle.
+// This function is strictly for sorting in this algorithm.
+const fakeAtan2 = (y, x) => {
+  // The "if" is a special case for when the minimum vector found in loop above is present.
+  // We need to ensure that it sorts as the minimum point. Otherwise, this becomes NaN.
+  if (y === 0 && x === 0) {
+    return -Infinity
+  } else {
+    return -x / y
   }
-  return hullpoints
 }
 
 module.exports = hullPoints2

package/src/operations/hulls/toUniquePoints.js

@@ -0,0 +1,34 @@
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/*
+ * Return the unique vertices of a geometry
+ */
+const toUniquePoints = (geometries) => {
+  const found = new Set()
+  const uniquePoints = []
+
+  const addPoint = (point) => {
+    const key = point.toString()
+    if (!found.has(key)) {
+      uniquePoints.push(point)
+      found.add(key)
+    }
+  }
+
+  geometries.forEach((geometry) => {
+    if (geom2.isA(geometry)) {
+      geom2.toPoints(geometry).forEach(addPoint)
+    } else if (geom3.isA(geometry)) {
+      // points are grouped by polygon
+      geom3.toPoints(geometry).forEach((points) => points.forEach(addPoint))
+    } else if (path2.isA(geometry)) {
+      path2.toPoints(geometry).forEach(addPoint)
+    }
+  })
+
+  return uniquePoints
+}
+
+module.exports = toUniquePoints

package/src/operations/modifiers/generalize.js

@@ -11,8 +11,6 @@ const mergePolygons = require('./mergePolygons')
 const insertTjunctions = require('./insertTjunctions')
 const triangulatePolygons = require('./triangulatePolygons')
 
-const repairTjunctions = require('./repairTjunctions')
-
 /*
  */
 const generalizePath2 = (options, geometry) => geometry
@@ -27,10 +25,9 @@ const generalizeGeom3 = (options, geometry) => {
   const defaults = {
     snap: false,
     simplify: false,
-    triangulate: false,
-    repair: false
+    triangulate: false
   }
-  const { snap, simplify, triangulate, repair } = Object.assign({}, defaults, options)
+  const { snap, simplify, triangulate } = Object.assign({}, defaults, options)
 
   const epsilon = measureEpsilon(geometry)
   let polygons = geom3.toPolygons(geometry)
@@ -52,13 +49,6 @@ const generalizeGeom3 = (options, geometry) => {
     polygons = triangulatePolygons(epsilon, polygons)
   }
 
-  // repair the polygons (possibly triangles) if requested
-  if (repair) {
-    // fix T junctions
-    polygons = repairTjunctions(epsilon, polygons)
-    // TODO fill holes
-  }
-
   // FIXME replace with geom3.cloneShallow() when available
   const clone = Object.assign({}, geometry)
   clone.polygons = polygons
@@ -72,7 +62,6 @@ const generalizeGeom3 = (options, geometry) => {
  * @param {Boolean} [options.snap=false] the geometries should be snapped to epsilons
  * @param {Boolean} [options.simplify=false] the geometries should be simplified
  * @param {Boolean} [options.triangulate=false] the geometries should be triangulated
- * @param {Boolean} [options.repair=false] the geometries should be repaired
  * @param {...Object} geometries - the geometries to generalize
  * @return {Object|Array} the modified geometry, or a list of modified geometries
  * @alias module:modeling/modifiers.generalize

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

@@ -28,6 +28,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // apply snap only
@@ -47,6 +48,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707910908071407, -0.7854138713607164, 3.1415821816142815], [1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
       [1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // apply triangulate only
@@ -78,6 +80,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   const geometry2 = result // save the triangles for another test
@@ -99,37 +102,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
-  t.true(comparePolygonsAsPoints(pts, exp))
-
-  // apply repairs only (triangles)
-  result = generalize({ repair: true }, geometry2)
-  pts = geom3.toPoints(result)
-  exp = [
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
-      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
-      [-1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
-    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
-      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
-    [[1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
-      [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, -3.141592653589793],
-      [1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
-      [-1.5707963267948966, -0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793],
-      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, 0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
-      [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, 0.7853981633974483, -3.141592653589793],
-      [1.5707963267948966, 0.7853981633974483, -3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [1.5707963267948966, 0.7853981633974483, -3.141592653589793],
-      [1.5707963267948966, -0.7853981633974483, -3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
-      [1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
-    [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
-      [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
-  ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -190,5 +163,6 @@ test('generalize: generalize of a geom3 with T junctions produces an expected ge
     [[0, 1, 1], [-1, 1, 1], [0, 0, 1]],
     [[-1, 1, 1], [-1, 0, 1], [0, 0, 1]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/modifiers/insertTjunctions.js

@@ -259,7 +259,7 @@ const insertTjunctions = (polygons) => {
                     // split the side by inserting the vertex:
                     const newvertices = polygon.vertices.slice(0)
                     newvertices.splice(insertionvertextagindex, 0, endvertex)
-                    const newpolygon = poly3.fromPoints(newvertices)
+                    const newpolygon = poly3.create(newvertices)
 
                     newpolygons[polygonindex] = newpolygon
 

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

@@ -56,33 +56,33 @@ test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
 
   const result3 = insertTjunctions(geom3.toPolygons(geometry3))
   let exp = [
-    poly3.fromPoints([[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]]),
-    poly3.fromPoints([[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]]),
-    poly3.fromPoints([[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]]),
-    poly3.fromPoints([[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]]),
-    poly3.fromPoints([[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]]),
-    poly3.fromPoints([[0, 0, 1], [-1, -1, 1], [1, -1, 1], [1, 1, 1]]),
-    poly3.fromPoints([[1, 1, 1], [-1, 1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[-1, 1, 1], [-1, -1, 1], [0, 0, 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([[-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.fromPoints([[-1, -1, -1], [-1, -1, 1], [-1, 0, 1], [-1, 1, 1], [-1, 1, -1]]),
-    poly3.fromPoints([[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, 0, 1], [1, -1, 1]]),
-    poly3.fromPoints([[-1, -1, -1], [1, -1, -1], [1, -1, 1], [0, -1, 1], [-1, -1, 1]]),
-    poly3.fromPoints([[-1, 1, -1], [-1, 1, 1], [0, 1, 1], [1, 1, 1], [1, 1, -1]]),
-    poly3.fromPoints([[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]]),
-    poly3.fromPoints([[-1, -1, 1], [0, -1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[-1, 0, 1], [-1, -1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[0, -1, 1], [1, -1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[1, -1, 1], [1, 0, 1], [0, 0, 1]]),
-    poly3.fromPoints([[1, 0, 1], [1, 1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[1, 1, 1], [0, 1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[0, 1, 1], [-1, 1, 1], [0, 0, 1]]),
-    poly3.fromPoints([[-1, 1, 1], [-1, 0, 1], [0, 0, 1]])
+    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

@@ -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/align.test.js

@@ -1,6 +1,7 @@
 const test = require('ava')
 
 const { comparePoints } = require('../../../test/helpers')
+const { geom3 } = require('../../geometries')
 const { measureBoundingBox, measureAggregateBoundingBox } = require('../../measurements')
 const { cube } = require('../../primitives')
 
@@ -11,6 +12,7 @@ test('align: single object returns geometry unchanged if all axes are none', (t)
   const aligned = align({ modes: ['none', 'none', 'none'] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[8, 8, 8], [12, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -19,6 +21,7 @@ test('align: single objects returns geometry aligned, different modes on each ax
   const aligned = align({ modes: ['center', 'min', 'max'] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[-2, 0, -4], [2, 4, 0]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -27,6 +30,7 @@ test('align: unfilled modes and relativeTo arrays return results with expected v
   const aligned = align({ modes: ['center'], relativeTo: [0] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[-2, 8, 8], [2, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -38,6 +42,8 @@ test('align: multiple objects grouped returns geometry aligned, different modes
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [6, -10, 0], grouped: true }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[1.5, -10, -9], [10.5, -1, 0]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -49,6 +55,8 @@ test('align: multiple objects ungrouped returns geometry aligned, different mode
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[28, 30, 26], [32, 34, 30]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -60,6 +68,8 @@ test('align: multiple objects grouped, relativeTo is nulls, returns geometry unc
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: true }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[3, 3, 3], [12, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -71,6 +81,8 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[5.5, 3, 8], [9.5, 7, 12]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 

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)