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

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

@@ -17,7 +17,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of one object
   const result1 = subtract(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('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = subtract(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows.skip(() => geom3.validate(result2))
   t.is(measureArea(result2), 44.053756306589825)
   t.is(measureVolume(result2), 25.751611331979678)
@@ -88,7 +88,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = subtract(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]],
@@ -111,7 +111,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of two completely overlapping objects
   const result4 = subtract(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows(() => geom3.validate(result4))
   t.is(measureArea(result4), 0)
   t.is(measureVolume(result4), 0)

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/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/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]],

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))