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

package/src/operations/modifiers/mergePolygons.js

@@ -67,7 +67,6 @@ const calculateAngle = (prevVertex, midVertex, nextVertex, normal) => {
 
 // create a polygon starting from the given edge (if possible)
 const createPolygonAnd = (edge) => {
-  let polygon
   const vertices = []
   while (edge.next) {
     const next = edge.next
@@ -81,8 +80,8 @@ const createPolygonAnd = (edge) => {
 
     edge = next
   }
-  if (vertices.length > 0) polygon = poly3.create(vertices)
-  return polygon
+  if (vertices.length > 0) return poly3.create(vertices)
+  return null
 }
 
 /*

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -31,7 +31,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
   // 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 yCoordinateBins = new Map()
-  const yCoordinateBinningFactor = 10 / EPS
+  const yCoordinateBinningFactor = 10 / EPS // FIXME
   for (let polygonIndex = 0; polygonIndex < numPolygons; polygonIndex++) {
     const poly3d = sourcePolygons[polygonIndex]
     let vertices2d = []
@@ -68,7 +68,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         }
         let polygonIndexes = yCoordinateToPolygonIndexes.get(y)
         if (!polygonIndexes) {
-          polygonIndexes = {} // PERF
+          polygonIndexes = []
           yCoordinateToPolygonIndexes.set(y, polygonIndexes)
         }
         polygonIndexes[polygonIndex] = true
@@ -242,7 +242,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
         const prevOutPolygon = newOutPolygonRow[newOutPolygonRow.length - 1]
         const d1 = vec2.distance(outPolygon.topLeft, prevOutPolygon.topRight)
         const d2 = vec2.distance(outPolygon.bottomLeft, prevOutPolygon.bottomRight)
-        if ((d1 < EPS) && (d2 < EPS)) {
+        if ((d1 < EPS) && (d2 < EPS)) { // FIXME
           // we can join this polygon with the one to the left:
           outPolygon.topLeft = prevOutPolygon.topLeft
           outPolygon.leftLine = prevOutPolygon.leftLine
@@ -263,8 +263,8 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
             // We have a match if the sidelines are equal or if the top coordinates
             // are on the sidelines of the previous polygon
             const prevPolygon = prevOutPolygonRow[ii]
-            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) {
-              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) {
+            if (vec2.distance(prevPolygon.bottomLeft, thisPolygon.topLeft) < EPS) { // FIXME
+              if (vec2.distance(prevPolygon.bottomRight, thisPolygon.topRight) < EPS) { // FIXME
                 // Yes, the top of this polygon matches the bottom of the previous:
                 matchedIndexes.add(ii)
                 // Now check if the joined polygon would remain convex:
@@ -300,7 +300,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           // Finish the polygon with the last point(s):
           const prevPolygon = prevOutPolygonRow[ii]
           prevPolygon.outPolygon.rightPoints.push(prevPolygon.bottomRight)
-          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) {
+          if (vec2.distance(prevPolygon.bottomRight, prevPolygon.bottomLeft) > EPS) { // FIXME
             // polygon ends with a horizontal line:
             prevPolygon.outPolygon.leftPoints.push(prevPolygon.bottomLeft)
           }
@@ -324,7 +324,7 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           rightPoints: []
         }
         thisPolygon.outPolygon.leftPoints.push(thisPolygon.topLeft)
-        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) {
+        if (vec2.distance(thisPolygon.topLeft, thisPolygon.topRight) > EPS) { // FIXME
           // we have a horizontal line at the top:
           thisPolygon.outPolygon.rightPoints.push(thisPolygon.topRight)
         }

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

@@ -82,15 +82,15 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
     [[10.0, -5.0, -5.0], [10.0, 5.0, -5.0], [10.0, 5.0, 5.0], [10.0, -5.0, 5.0]] // end
   ]
 
-  const obj1 = geom3.fromPoints(box1)
-  const obj2 = geom3.fromPoints(box1.concat(box2)) // combined geometry
-  const obj3 = geom3.fromPoints(box3)
-  const obj4 = geom3.fromPoints(box4)
-  const obj5 = geom3.fromPoints(box5)
+  const obj1 = geom3.fromVertices(box1)
+  const obj2 = geom3.fromVertices(box1.concat(box2)) // combined geometry
+  const obj3 = geom3.fromVertices(box3)
+  const obj4 = geom3.fromVertices(box4)
+  const obj5 = geom3.fromVertices(box5)
 
   // one solid geometry
   const ret1 = retessellate(obj1)
-  const pts1 = geom3.toPoints(ret1)
+  const pts1 = geom3.toVertices(ret1)
   const exp1 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
@@ -103,7 +103,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two non-overlapping geometries
   const ret2 = retessellate(obj2)
-  const pts2 = geom3.toPoints(ret2)
+  const pts2 = geom3.toVertices(ret2)
   const exp2 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
@@ -122,7 +122,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two touching geometries (faces)
   const ret3 = retessellate(obj3)
-  const pts3 = geom3.toPoints(ret3)
+  const pts3 = geom3.toVertices(ret3)
   const exp3 = [
     [[-5, 5, 15], [-5, 5, -5], [-5, -5, -5], [-5, -5, 15]],
     [[5, -5, 15], [5, -5, -5], [5, 5, -5], [5, 5, 15]],
@@ -135,7 +135,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // two overlapping geometries
   const ret4 = retessellate(obj4)
-  const pts4 = geom3.toPoints(ret4)
+  const pts4 = geom3.toVertices(ret4)
   const exp4 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[-5, -5, -5], [5, -5, -5], [5, -5, 5], [-5, -5, 5]],
@@ -160,7 +160,7 @@ test('geom3: retessellate() should create proper geometry from solid geometries'
 
   // coplanar polygons
   const ret5 = retessellate(obj5)
-  const pts5 = geom3.toPoints(ret5)
+  const pts5 = geom3.toVertices(ret5)
   const exp5 = [
     [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
     [[10, -5, -5], [10, -5, 5], [-5, -5, 5], [-5, -5, -5]],

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

@@ -117,11 +117,11 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const results = snap(geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 4)
 
-  let pts = geom3.toPoints(results[0])
+  let pts = geom3.toVertices(results[0])
   let exp = []
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[1])
+  pts = geom3.toVertices(results[1])
   exp = [
     [[-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5]],
     [[0.5, -0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [0.5, -0.5, 0.5]],
@@ -132,7 +132,7 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   ]
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[2])
+  pts = geom3.toVertices(results[2])
   exp = [
     [[-0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [-0.6666666666666667, -0.6666666666666667, 0.6666666666666667],
       [-0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, -0.6666666666666667]],
@@ -149,7 +149,7 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   ]
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  pts = geom3.toPoints(results[3])
+  pts = geom3.toVertices(results[3])
   exp = [
     [[-1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [-1570.7963267948967, -1570.7963267948967, 1570.7963267948967],
       [-1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, -1570.7963267948967]],

package/src/operations/offsets/offsetGeom3.test.js

@@ -19,7 +19,7 @@ test('offset: offset empty geom3', (t) => {
   t.is(measureArea(result), 0)
   t.is(measureVolume(result), 0)
   t.is(geom3.toPolygons(result).length, 0)
-  t.is(geom3.toPoints(result).length, 0)
+  t.is(geom3.toVertices(result).length, 0)
 })
 
 test('offset: offset geom3 preserves color', (t) => {
@@ -37,10 +37,10 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
     [[-5, -5, -5], [-5, 15, -5], [15, 15, -5], [15, -5, -5]],
     [[-5, -5, 15], [15, -5, 15], [15, 15, 15], [-5, 15, 15]]
   ]
-  const geometry = geom3.fromPoints(polygonsAsPoints)
+  const geometry = geom3.fromVertices(polygonsAsPoints)
 
   const obs = offset({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   const exp0 = [
     [-7, -5, -5],
     [-7, -5, 15],
@@ -62,7 +62,7 @@ test('offset: offset of a geom3 produces expected changes to polygons', (t) => {
 
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = offset({ delta: 5 }, geometry2)
-  const pts2 = geom3.toPoints(obs2)
+  const pts2 = geom3.toVertices(obs2)
   t.notThrows.skip(() => geom3.validate(obs2))
   t.is(measureArea(obs), 3178.8059464475555)
   t.is(measureVolume(obs), 13504.574121271067)

package/src/operations/transforms/center.test.js

@@ -53,11 +53,11 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // center about X
   let centered = center({ axes: [true, false, false] }, geometry)
-  let pts = geom3.toPoints(centered)
+  let pts = geom3.toVertices(centered)
   let exp = [
     [[-5, -7, -12], [-5, -7, 18], [-5, 13, 18], [-5, 13, -12]],
     [[5, -7, -12], [5, 13, -12], [5, 13, 18], [5, -7, 18]],
@@ -71,14 +71,14 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerX(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Y
   centered = center({ axes: [false, true, false] }, geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   exp = [
     [[-2, -10, -12], [-2, -10, 18], [-2, 10, 18], [-2, 10, -12]],
     [[8, -10, -12], [8, 10, -12], [8, 10, 18], [8, -10, 18]],
@@ -92,14 +92,14 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerY(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Z
   centered = center({ axes: [false, false, true] }, geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   exp = [
     [[-2, -7, -15], [-2, -7, 15], [-2, 13, 15], [-2, 13, -15]],
     [[8, -7, -15], [8, 13, -15], [8, 13, 15], [8, -7, 15]],
@@ -113,7 +113,7 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerZ(geometry)
-  pts = geom3.toPoints(centered)
+  pts = geom3.toVertices(centered)
   t.notThrows(() => geom3.validate(centered))
   t.is(measureVolume(centered), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/transforms/mirror.test.js

@@ -77,11 +77,11 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // mirror about X
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
-  let obs = geom3.toPoints(mirrored)
+  let obs = geom3.toVertices(mirrored)
   let exp = [
     [[2, 13, -12], [2, 13, 18], [2, -7, 18], [2, -7, -12]],
     [[-8, -7, 18], [-8, 13, 18], [-8, 13, -12], [-8, -7, -12]],
@@ -96,14 +96,14 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.deepEqual(obs, exp)
 
   mirrored = mirrorX(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   exp = [
     [[-2, -13, -12], [-2, -13, 18], [-2, 7, 18], [-2, 7, -12]],
     [[8, 7, 18], [8, -13, 18], [8, -13, -12], [8, 7, -12]],
@@ -117,14 +117,14 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorY(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Z
   mirrored = mirror({ normal: [0, 0, 1] }, geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   exp = [
     [[-2, 13, 12], [-2, 13, -18], [-2, -7, -18], [-2, -7, 12]],
     [[8, -7, -18], [8, 13, -18], [8, 13, 12], [8, -7, 12]],
@@ -138,7 +138,7 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorZ(geometry)
-  obs = geom3.toPoints(mirrored)
+  obs = geom3.toVertices(mirrored)
   t.notThrows(() => geom3.validate(mirrored))
   t.is(measureVolume(mirrored), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/rotate.test.js

@@ -60,11 +60,11 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // rotate about X
   let rotated = rotate([TAU / 4], geometry)
-  let obs = geom3.toPoints(rotated)
+  let obs = geom3.toVertices(rotated)
   let exp = [
     [[-2, 12, -7.000000000000001], [-2, -18, -6.999999999999999],
       [-2, -18, 13.000000000000002], [-2, 12, 13]],
@@ -84,14 +84,14 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateX(TAU / 4, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
   rotated = rotate([0, -TAU / 4], geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   exp = [
     [[12, -7, -2.000000000000001], [-18, -7, -1.999999999999999],
       [-18, 13, -1.999999999999999], [12, 13, -2.000000000000001]],
@@ -111,14 +111,14 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateY(-TAU / 4, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Z
   rotated = rotate([0, 0, TAU / 2], geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   exp = [
     [[2.000000000000001, 7, -12], [2.000000000000001, 7, 18],
       [1.9999999999999984, -13, 18], [1.9999999999999984, -13, -12]],
@@ -138,7 +138,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateZ(TAU / 2, geometry)
-  obs = geom3.toPoints(rotated)
+  obs = geom3.toVertices(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.is(measureVolume(rotated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/scale.test.js

@@ -77,11 +77,11 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // scale X
   let scaled = scale([3], geometry)
-  let obs = geom3.toPoints(scaled)
+  let obs = geom3.toVertices(scaled)
   let exp = [
     [[-6, -7, -12], [-6, -7, 18], [-6, 13, 18], [-6, 13, -12]],
     [[24, -7, -12], [24, 13, -12], [24, 13, 18], [24, -7, 18]],
@@ -95,14 +95,14 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleX(3, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 3 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 0.5], geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   exp = [
     [[-2, -3.5, -12], [-2, -3.5, 18], [-2, 6.5, 18], [-2, 6.5, -12]],
     [[8, -3.5, -12], [8, 6.5, -12], [8, 6.5, 18], [8, -3.5, 18]],
@@ -116,14 +116,14 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleY(0.5, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 0.5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Z
   scaled = scale([1, 1, 5], geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   exp = [
     [[-2, -7, -60], [-2, -7, 90], [-2, 13, 90], [-2, 13, -60]],
     [[8, -7, -60], [8, 13, -60], [8, 13, 90], [8, -7, 90]],
@@ -137,7 +137,7 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleZ(5, geometry)
-  obs = geom3.toPoints(scaled)
+  obs = geom3.toVertices(scaled)
   t.notThrows(() => geom3.validate(scaled))
   t.is(measureVolume(scaled), 5 * measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/operations/transforms/transform.test.js

@@ -40,9 +40,9 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  let geometry = geom3.fromPoints(points)
+  let geometry = geom3.fromVertices(points)
   geometry = transform(matrix, geometry)
-  const obs = geom3.toPoints(geometry)
+  const obs = geom3.toVertices(geometry)
   const exp = [
     [[-5, -10, -15], [-5, -10, 15], [-5, 10, 15], [-5, 10, -15]],
     [[5, -10, -15], [5, 10, -15], [5, 10, 15], [5, -10, 15]],

package/src/operations/transforms/translate.test.js

@@ -77,11 +77,11 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
     [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
   ]
-  const geometry = geom3.fromPoints(points)
+  const geometry = geom3.fromVertices(points)
 
   // translate X
   let translated = translate([3], geometry)
-  let obs = geom3.toPoints(translated)
+  let obs = geom3.toVertices(translated)
   let exp = [
     [[1, -7, -12], [1, -7, 18], [1, 13, 18], [1, 13, -12]],
     [[11, -7, -12], [11, 13, -12], [11, 13, 18], [11, -7, 18]],
@@ -95,14 +95,14 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateX(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translated Y
   translated = translate([0, 3], geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   exp = [
     [[-2, -4, -12], [-2, -4, 18], [-2, 16, 18], [-2, 16, -12]],
     [[8, -4, -12], [8, 16, -12], [8, 16, 18], [8, -4, 18]],
@@ -116,14 +116,14 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateY(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translate Z
   translated = translate([0, 0, 3], geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   exp = [
     [[-2, -7, -9], [-2, -7, 21], [-2, 13, 21], [-2, 13, -9]],
     [[8, -7, -9], [8, 13, -9], [8, 13, 21], [8, -7, 21]],
@@ -137,7 +137,7 @@ test('translate: translating of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateZ(3, geometry)
-  obs = geom3.toPoints(translated)
+  obs = geom3.toVertices(translated)
   t.notThrows(() => geom3.validate(translated))
   t.is(measureVolume(translated), measureVolume(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))

package/src/primitives/cube.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cube (defaults)', (t) => {
   const obs = cube()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 24)
   t.is(measureVolume(obs), 7.999999999999999)
@@ -20,7 +20,7 @@ test('cube (defaults)', (t) => {
 test('cube (options)', (t) => {
   // test center
   let obs = cube({ size: 7, center: [6.5, 6.5, 6.5] })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[3, 3, 3], [3, 3, 10], [3, 10, 10], [3, 10, 3]],
     [[10, 3, 3], [10, 10, 3], [10, 10, 10], [10, 3, 10]],
@@ -38,7 +38,7 @@ test('cube (options)', (t) => {
 
   // test size
   obs = cube({ size: 7 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-3.5, -3.5, -3.5], [-3.5, -3.5, 3.5], [-3.5, 3.5, 3.5], [-3.5, 3.5, -3.5]],
     [[3.5, -3.5, -3.5], [3.5, 3.5, -3.5], [3.5, 3.5, 3.5], [3.5, -3.5, 3.5]],
@@ -57,7 +57,7 @@ test('cube (options)', (t) => {
 
 test('cube (zero size)', (t) => {
   const obs = cube({ size: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/cuboid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cuboid (defaults)', (t) => {
   const obs = cuboid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   const 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]],
@@ -29,7 +29,7 @@ test('cuboid (defaults)', (t) => {
 test('cuboid (options)', (t) => {
   // test center
   let obs = cuboid({ size: [6, 6, 6], center: [3, 5, 7] })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 2, 4], [0, 2, 10], [0, 8, 10], [0, 8, 4]],
     [[6, 2, 4], [6, 8, 4], [6, 8, 10], [6, 2, 10]],
@@ -47,7 +47,7 @@ test('cuboid (options)', (t) => {
 
   // test size
   obs = cuboid({ size: [4.5, 1.5, 7] })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2.25, -0.75, -3.5], [-2.25, -0.75, 3.5], [-2.25, 0.75, 3.5], [-2.25, 0.75, -3.5]],
     [[2.25, -0.75, -3.5], [2.25, 0.75, -3.5], [2.25, 0.75, 3.5], [2.25, -0.75, 3.5]],
@@ -66,7 +66,7 @@ test('cuboid (options)', (t) => {
 
 test('cuboid (zero size)', (t) => {
   const obs = cuboid({ size: [1, 1, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/cylinder.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinder (defaults)', (t) => {
   const obs = cylinder()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
@@ -20,7 +20,7 @@ test('cylinder (defaults)', (t) => {
 
 test('cylinder (zero height)', (t) => {
   const obs = cylinder({ height: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -29,7 +29,7 @@ test('cylinder (zero height)', (t) => {
 
 test('cylinder (zero radius)', (t) => {
   const obs = cylinder({ radius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -38,7 +38,7 @@ test('cylinder (zero radius)', (t) => {
 
 test('cylinder (options)', (t) => {
   let obs = cylinder({ height: 10, radius: 4, segments: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, -5], [1.2360679774997898, 3.804226065180614, -5], [4, 0, -5]],
     [[1.2360679774997898, 3.804226065180614, -5], [1.2360679774997898, 3.804226065180614, 5],
@@ -70,7 +70,7 @@ test('cylinder (options)', (t) => {
 
   // test center
   obs = cylinder({ center: [-5, -5, -5], segments: 5 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-5, -5, -6], [-4.6909830056250525, -4.048943483704846, -6], [-4, -5, -6]],
     [[-4.6909830056250525, -4.048943483704846, -6], [-4.6909830056250525, -4.048943483704846, -4],