@jscad/modeling 3.0.1-alpha.0 → 3.0.3-alpha.0

package/src/operations/booleans/trees/splitPolygonByPlane.js

@@ -7,23 +7,27 @@ import * as poly3 from '../../../geometries/poly3/index.js'
 
 import { splitLineSegmentByPlane } from './splitLineSegmentByPlane.js'
 
-// Returns object:
-// .type:
-//   0: coplanar-front
-//   1: coplanar-back
-//   2: front
-//   3: back
-//   4: spanning
-// In case the polygon is spanning, returns:
-// .front: a Polygon3 of the front part
-// .back: a Polygon3 of the back part
-export const splitPolygonByPlane = (splane, polygon) => {
-  const result = {
-    type: null,
-    front: null,
-    back: null
-  }
-  // cache in local lets (speedup):
+/*
+ * Split the given polygon by the given plane.
+ *
+ * @@param (Object} result - object of which to update with the result
+ * @param {Plane} splane - plane to split across
+ * @param {Poly3} ploygon - polygon of which to split
+ * @returns none
+ *
+ * The result is updated in place to improve performance (no allocation)
+ *   result.type:
+ *     0: coplanar-front
+ *     1: coplanar-back
+ *     2: front
+ *     3: back
+ *     4: spanning
+ *
+ * In case the polygon is spanning (4)
+ *   result.front contains null or a ploygon (front part)
+ *   result.back contains null or a polygon (back part)
+ */
+export const splitPolygonByPlane = (result, splane, polygon) => {
   const vertices = polygon.vertices
   const numVertices = vertices.length
   const pplane = poly3.plane(polygon)
@@ -41,17 +45,20 @@ export const splitPolygonByPlane = (splane, polygon) => {
       if (t > EPS) hasFront = true
       if (t < MINEPS) hasBack = true
     }
+
     if ((!hasFront) && (!hasBack)) {
       // all points coplanar
       const t = vec3.dot(splane, pplane)
       result.type = (t >= 0) ? 0 : 1
     } else if (!hasBack) {
+      // points only front of the plane
       result.type = 2
     } else if (!hasFront) {
+      // points only back of the plane
       result.type = 3
     } else {
-      // spanning
-      result.type = 4
+      // points span the plane
+      // split the line segments by the plane
       const frontVertices = []
       const backVertices = []
       let isback = vertexIsBack[0]
@@ -61,14 +68,10 @@ export const splitPolygonByPlane = (splane, polygon) => {
         if (nextVertexIndex >= numVertices) nextVertexIndex = 0
         const nextIsBack = vertexIsBack[nextVertexIndex]
         if (isback === nextIsBack) {
-          // line segment is on one side of the plane:
-          if (isback) {
-            backVertices.push(vertex)
-          } else {
-            frontVertices.push(vertex)
-          }
+          // line segment is on one side of the plane
+          isback ? backVertices.push(vertex) : frontVertices.push(vertex)
         } else {
-          // line segment intersects plane:
+          // line segment spans the plane
           const nextPoint = vertices[nextVertexIndex]
           const intersectionPoint = splitLineSegmentByPlane(splane, vertex, nextPoint)
           if (isback) {
@@ -82,8 +85,9 @@ export const splitPolygonByPlane = (splane, polygon) => {
           }
         }
         isback = nextIsBack
-      } // for vertexIndex
-      // remove duplicate vertices:
+      }
+
+      // remove duplicate vertices
       const EPS_SQUARED = EPS * EPS
       if (backVertices.length >= 3) {
         let prevVertex = backVertices[backVertices.length - 1]
@@ -107,12 +111,13 @@ export const splitPolygonByPlane = (splane, polygon) => {
           prevVertex = vertex
         }
       }
-      if (frontVertices.length >= 3) {
-        result.front = poly3.fromVerticesAndPlane(frontVertices, pplane)
-      }
-      if (backVertices.length >= 3) {
-        result.back = poly3.fromVerticesAndPlane(backVertices, pplane)
-      }
+
+      // assemble the result
+      result.type = 4
+
+      result.front = frontVertices.length >= 3 ? poly3.fromVerticesAndPlane(frontVertices, pplane) : null
+
+      result.back = backVertices.length >= 3 ? poly3.fromVerticesAndPlane(backVertices, pplane) : null
     }
   }
   return result

package/src/operations/booleans/unionGeom3.test.js

@@ -17,7 +17,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
 
   // union of one object
   const result1 = union(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = union(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows.skip(() => geom3.validate(result2))
   t.is(measureArea(result2), 140.05375630658983)
   t.is(measureVolume(result2), 89.75161133197969)
@@ -88,7 +88,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = union(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
   exp = [
     [[12, 8, 8], [12, 12, 8], [12, 12, 12], [12, 8, 12]],
     [[8, 12, 8], [8, 12, 12], [12, 12, 12], [12, 12, 8]],
@@ -117,7 +117,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
 
   // union of two completely overlapping objects
   const result4 = union(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   exp = [
     [[-9, -9, -9], [-9, -9, 9], [-9, 9, 9], [-9, 9, -9]],
     [[9, -9, -9], [9, 9, -9], [9, 9, 9], [9, -9, 9]],
@@ -138,7 +138,7 @@ test('union of geom3 with rounding issues #137', (t) => {
   const geometry2 = center({ relativeTo: [0, 0, -4.400001] }, cuboid({ size: [44, 26, 1.8] })) // introduce precision error
 
   const result = union(geometry1, geometry2)
-  const pts = geom3.toPoints(result)
+  const pts = geom3.toVertices(result)
   t.notThrows(() => geom3.validate(result))
   t.is(measureArea(result), 3240.00014)
   t.is(measureVolume(result), 7779.201144000001)

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

@@ -17,7 +17,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   const geometry2 = square({ size: 20 })
 
   let geometry3 = extrudeFromSlices({ }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   const exp = [
     [[-10, -10, 0], [10, -10, 0], [10, -10, 1]],
     [[-10, -10, 0], [10, -10, 1], [-10, -10, 1]],
@@ -39,7 +39,7 @@ test('extrudeFromSlices (defaults)', (t) => {
 
   const poly2 = poly3.create([[-10, -10, 0], [10, -10, 0], [10, 10, 0], [-10, 10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
 
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 880)
@@ -75,7 +75,7 @@ test('extrudeFromSlices (torus)', (t) => {
       }
     }, hex
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7070.694617452831)
   t.is(measureVolume(geometry3), 29393.876913398108)
@@ -96,7 +96,7 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
       }
     }, base
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   // expected to throw because capEnd is false (non-closed geometry)
   t.throws(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 53.70100297794013)
@@ -117,7 +117,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
       }
     }, base
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 1965.8643589631802)
   t.is(measureVolume(geometry3), 5260.067107417433)
@@ -130,7 +130,7 @@ test('extrudeFromSlices (holes)', (t) => {
     [[-5, -5], [-5, 5], [5, 5], [5, -5]]
   ])
   const geometry3 = extrudeFromSlices({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-10, 10, 0], [-10, -10, 0], [-10, -10, 1]],
     [[-10, 10, 0], [-10, -10, 1], [-10, 10, 1]],

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

@@ -18,7 +18,7 @@ test('extrudeLinear (defaults)', (t) => {
   const geometry2 = square({ size: 10 })
 
   const geometry3 = extrudeLinear({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-5, -5, 0], [5, -5, 0], [5, -5, 1]],
     [[-5, -5, 0], [5, -5, 1], [-5, -5, 1]],
@@ -55,7 +55,7 @@ test('extrudeLinear (no twist)', (t) => {
   const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [[-5, -5, 0], [5, -5, 0], [5, -5, 15]],
     [[-5, -5, 0], [5, -5, 15], [-5, -5, 15]],
@@ -77,7 +77,7 @@ test('extrudeLinear (no twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: -15 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [[-5, 5, 0], [5, 5, 0], [5, 5, -15]],
     [[-5, 5, 0], [5, 5, -15], [-5, 5, -15]],
@@ -103,7 +103,7 @@ test('extrudeLinear (twist)', (t) => {
   const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15, twistAngle: -TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [[-5, -5, 0], [5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15]],
     [[-5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15], [-7.0710678118654755, -4.440892098500626e-16, 15]],
@@ -133,7 +133,7 @@ test('extrudeLinear (twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 4, twistSteps: 3 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [[-5, -5, 0], [5, -5, 0], [6.830127018922193, -1.830127018922194, 5]],
     [[-5, -5, 0], [6.830127018922193, -1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5]],
@@ -168,7 +168,7 @@ test('extrudeLinear (twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 1091.9932843446968)
   t.is(measureVolume(geometry3), 1444.9967160503095)
@@ -181,7 +181,7 @@ test('extrudeLinear (holes)', (t) => {
     [[-2, -2], [-2, 2], [2, 2], [2, -2]]
   ])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-5, 5, 0], [-5, -5, 0], [-5, -5, 15]],
     [[-5, 5, 0], [-5, -5, 15], [-5, 5, 15]],
@@ -227,7 +227,7 @@ test('extrudeLinear (path2)', (t) => {
   const geometry2 = path2.fromPoints({ closed: true }, [[6, 10], [0, 0], [12, 0]])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   t.notThrows(() => geom3.validate(geometry3))
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[6, 10, 0], [0, 0, 0], [0, 0, 15]],
     [[6, 10, 0], [0, 0, 15], [6, 10, 15]],

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

@@ -18,7 +18,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
   const geometry2 = geom2.create([[[10, 8], [10, -8], [26, -8], [26, 8]]])
 
   const geometry3 = extrudeRotate({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7033.914479497244)
   t.is(measureVolume(geometry3), 27648.000000000007)
@@ -36,7 +36,7 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
 
   // test angle
   let geometry3 = extrudeRotate({ segments: 4, angle: TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   const exp = [
     [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
@@ -58,14 +58,14 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 4525.850393739846)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 4525.8503937398455)
   t.is(measureVolume(geometry3), 13730.527057424617)
@@ -77,7 +77,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
 
   // test startAngle
   let geometry3 = extrudeRotate({ segments: 5, startAngle: TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [7.0710678118654755, 7.071067811865475, 8],
     [18.38477631085024, 18.384776310850235, 8],
@@ -90,7 +90,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
   t.true(comparePoints(pts[6], exp))
 
   geometry3 = extrudeRotate({ segments: 5, startAngle: -TAU / 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [7.0710678118654755, -7.071067811865475, 8],
     [18.38477631085024, -18.384776310850235, 8],
@@ -108,14 +108,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
 
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 5562.34804770761)
   t.is(measureVolume(geometry3), 18432)
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7230.965353920782)
   t.is(measureVolume(geometry3), 28906.430888871357)
@@ -124,7 +124,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test overlapping edges
   geometry2 = geom2.create([[[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 84.28200374166053)
   t.is(measureVolume(geometry3), 33.94112549695427)
@@ -133,7 +133,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.create([[[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 17692.315375839215)
   t.is(measureVolume(geometry3), 147078.2104868019)
@@ -145,7 +145,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   let geometry = geom2.create([[[-1, 8], [-1, -8], [7, -8], [7, 8]]])
 
   let obs = extrudeRotate({ segments: 4, angle: TAU / 4 }, geometry)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
     [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
@@ -166,7 +166,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   geometry = geom2.create([[[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]]])
 
   obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
     [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],

package/src/operations/extrusions/extrudeWalls.js

@@ -25,10 +25,11 @@ const repartitionEdges = (newLength, edges) => {
   }
 
   const divisor = vec3.fromValues(multiple, multiple, multiple)
+  const increment = vec3.create()
 
   const newEdges = []
   edges.forEach((edge) => {
-    const increment = vec3.subtract(vec3.create(), edge[1], edge[0])
+    vec3.subtract(increment, edge[1], edge[0])
     vec3.divide(increment, increment, divisor)
 
     // repartition the edge
@@ -48,6 +49,7 @@ const EPSAREA = (EPS * EPS / 2) * Math.sin(Math.PI / 3)
  * Extrude (build) walls between the given slices.
  * Each wall consists of two triangles, which may be invalid if slices are overlapping.
  */
+// FIXME this function should take an eps parameter
 export const extrudeWalls = (slice0, slice1) => {
   let edges0 = slice.toEdges(slice0)
   let edges1 = slice.toEdges(slice1)

package/src/operations/hulls/hull.test.js

@@ -218,7 +218,7 @@ test('hull (single, geom3)', (t) => {
   let geometry = geom3.create()
 
   let obs = hull(geometry)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 0)
@@ -226,7 +226,7 @@ test('hull (single, geom3)', (t) => {
   geometry = sphere({ radius: 2, segments: 8 })
 
   obs = hull(geometry)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 44.05375630658983)
@@ -238,7 +238,7 @@ test('hull (multiple, geom3)', (t) => {
   const geometry1 = cuboid({ size: [2, 2, 2] })
 
   let obs = hull(geometry1, geometry1) // same
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
     [[-1, 1, -1], [1, 1, -1], [1, -1, -1], [-1, -1, -1]],
@@ -257,7 +257,7 @@ test('hull (multiple, geom3)', (t) => {
   const geometry2 = center({ relativeTo: [5, 5, 5] }, cuboid({ size: [3, 3, 3] }))
 
   obs = hull(geometry1, geometry2)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[1, -1, -1], [6.5, 3.5, 3.5], [6.5, 3.5, 6.5], [1, -1, 1]],
     [[-1, -1, 1], [-1, -1, -1], [1, -1, -1], [1, -1, 1]],
@@ -286,7 +286,7 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const geometry3 = center({ relativeTo: [-3, -3, -3] }, ellipsoid({ radius: [3, 3, 3], segments: 12 }))
 
   const obs = hull(geometry1, geometry2, geometry3)
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 282.26819685563686)

package/src/operations/hulls/hullChain.test.js

@@ -61,7 +61,7 @@ test('hullChain (three, geom2)', (t) => {
 })
 
 test('hullChain (three, geom3)', (t) => {
-  const geometry1 = geom3.fromPoints(
+  const geometry1 = geom3.fromVertices(
     [[[-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]],
@@ -69,7 +69,7 @@ test('hullChain (three, geom3)', (t) => {
       [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
       [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]]
   )
-  const geometry2 = geom3.fromPoints(
+  const geometry2 = geom3.fromVertices(
     [[[3.5, 3.5, 3.5], [3.5, 3.5, 6.5], [3.5, 6.5, 6.5], [3.5, 6.5, 3.5]],
       [[6.5, 3.5, 3.5], [6.5, 6.5, 3.5], [6.5, 6.5, 6.5], [6.5, 3.5, 6.5]],
       [[3.5, 3.5, 3.5], [6.5, 3.5, 3.5], [6.5, 3.5, 6.5], [3.5, 3.5, 6.5]],
@@ -77,7 +77,7 @@ test('hullChain (three, geom3)', (t) => {
       [[3.5, 3.5, 3.5], [3.5, 6.5, 3.5], [6.5, 6.5, 3.5], [6.5, 3.5, 3.5]],
       [[3.5, 3.5, 6.5], [6.5, 3.5, 6.5], [6.5, 6.5, 6.5], [3.5, 6.5, 6.5]]]
   )
-  const geometry3 = geom3.fromPoints(
+  const geometry3 = geom3.fromVertices(
     [[[-4.5, 1.5, -4.5], [-4.5, 1.5, -1.5], [-4.5, 4.5, -1.5], [-4.5, 4.5, -4.5]],
       [[-1.5, 1.5, -4.5], [-1.5, 4.5, -4.5], [-1.5, 4.5, -1.5], [-1.5, 1.5, -1.5]],
       [[-4.5, 1.5, -4.5], [-1.5, 1.5, -4.5], [-1.5, 1.5, -1.5], [-4.5, 1.5, -1.5]],
@@ -88,7 +88,7 @@ test('hullChain (three, geom3)', (t) => {
 
   // open
   let obs = hullChain(geometry1, geometry2, geometry3)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 266.1454764345133)
@@ -97,7 +97,7 @@ test('hullChain (three, geom3)', (t) => {
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 272.2887171436021)

package/src/operations/hulls/hullPoints2.js

@@ -17,28 +17,32 @@ export const hullPoints2 = (uniquePoints) => {
     }
   })
 
-  // 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 })
-  })
+  // calculations relative to min point
+  const squaredDistance = (point) => vec2.squaredDistance(point, min)
+  const polarAngle = (point) => (point[0] === min[0] && point[1] === min[1]) ? -Infinity : -(point[0] - min[0]) / (point[1] - min[1])
 
-  // sort by polar coordinates
-  points.sort((pt1, pt2) => pt1.angle !== pt2.angle
-    ? pt1.angle - pt2.angle
-    : pt1.distSq - pt2.distSq)
+  // points are sorted by polar angle in clockwise order
+  const sorted = uniquePoints
+  sorted.sort((pt1, pt2) => {
+    const pa1 = polarAngle(pt1)
+    const pa2 = polarAngle(pt2)
+    if (pa1 === pa2) {
+      // sort by the relative distances to min point
+      return squaredDistance(pt1) - squaredDistance(pt2)
+    }
+    // sort by polar angles to min point
+    return pa1 - pa2
+  })
 
   const stack = [] // start with empty stack
-  points.forEach((point) => {
+  sorted.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
+    while (cnt > 1 && ccw(stack[cnt - 2], stack[cnt - 1], point) <= Number.EPSILON) {
+      // get rid of colinear and interior (clockwise) points
+      stack.pop()
       cnt = stack.length
     }
-    stack.push(point.point)
+    stack.push(point)
   })
 
   return stack
@@ -46,15 +50,3 @@ export const hullPoints2 = (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])
-
-// 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
-  }
-}

package/src/operations/hulls/toUniquePoints.js

@@ -21,8 +21,8 @@ export const toUniquePoints = (geometries) => {
     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))
+      // vertices are grouped by polygon
+      geom3.toVertices(geometry).forEach((vertices) => vertices.forEach(addPoint))
     } else if (path2.isA(geometry)) {
       path2.toPoints(geometry).forEach(addPoint)
     }

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

@@ -15,7 +15,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply no modifications
   let result = generalize({}, geometry1)
-  let pts = geom3.toPoints(result)
+  let pts = geom3.toVertices(result)
   let 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]],
@@ -35,7 +35,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply snap only
   result = generalize({ snap: true }, geometry1)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(result)
   exp = [
     [[-1.5707910908071407, -0.7854138713607164, -3.1415821816142815], [-1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
       [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, -3.1415821816142815]],
@@ -55,7 +55,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply triangulate only
   result = generalize({ triangulate: true }, geometry1)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(result)
   exp = [
     [[-1.5707963267948966, -0.7853981633974483, -3.141592653589793], [-1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]],
@@ -89,7 +89,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 
   // apply simplify only (triangles => quads)
   result = generalize({ simplify: true }, geometry2)
-  pts = geom3.toPoints(result)
+  pts = geom3.toVertices(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]],
@@ -109,7 +109,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
 })
 
 test('generalize: generalize of a geom3 with T junctions produces an expected geom3', (t) => {
-  const geometry1 = geom3.fromPoints(
+  const geometry1 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -132,7 +132,7 @@ test('generalize: generalize of a geom3 with T junctions produces an expected ge
   )
 
   const result = generalize({ snap: true, triangulate: true }, geometry1)
-  const pts = geom3.toPoints(result)
+  const pts = geom3.toVertices(result)
   const exp = [
     [[-1, 0, 0.2], [-1, -1, -1], [-1, -1, 1]],
     [[-1, 0, 0.2], [-1, -1, 1], [-1, 0, 1]],

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

@@ -11,7 +11,7 @@ import { insertTjunctions } from './insertTjunctions.js'
 test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [2, 2, 2] })
-  const geometry3 = geom3.fromPoints(
+  const geometry3 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
@@ -24,7 +24,7 @@ test('insertTjunctions: insertTjunctions produces expected polygons', (t) => {
       [[-1, 1, 1], [-1, -1, 1], [0, 0, 1]]
     ]
   )
-  const geometry4 = geom3.fromPoints(
+  const geometry4 = geom3.fromVertices(
     [
       [[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],