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

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

package/src/primitives/cylinderElliptic.test.js

@@ -12,7 +12,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('cylinderElliptic (defaults)', (t) => {
   const obs = cylinderElliptic()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
@@ -23,7 +23,7 @@ test('cylinderElliptic (defaults)', (t) => {
 test('cylinderElliptic (options)', (t) => {
   // test height
   let obs = cylinderElliptic({ height: 10, segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, -5], [0.8660254037844387, 0.49999999999999994, -5], [1, 0, -5]],
     [[0.8660254037844387, 0.49999999999999994, -5], [0.8660254037844387, 0.49999999999999994, 5],
@@ -83,7 +83,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startRadius and endRadius
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], segments: 12 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [1, 0, -1]],
     [[1, 0, -1], [0.8660254037844387, 0.9999999999999999, -1], [2, 0, 1]],
@@ -143,7 +143,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startAngle and endAngle
   obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: TAU / 4, endAngle: TAU * 0.75, segments: 12 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 22.17105015072561)
@@ -152,7 +152,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test startAngle and endAngle
   obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + TAU })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.78908426669986)
@@ -161,7 +161,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test segments
   obs = cylinderElliptic({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 17.902724085175244)
@@ -170,7 +170,7 @@ test('cylinderElliptic (options)', (t) => {
 
   // test center
   obs = cylinderElliptic({ center: [-5, -5, -5], height: 3, segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-5, -5, -6.5], [-4.292893218813452, -4.292893218813452, -6.5], [-4, -5, -6.5]],
     [[-4.292893218813452, -4.292893218813452, -6.5], [-4.292893218813452, -4.292893218813452, -3.5],
@@ -215,7 +215,7 @@ test('cylinderElliptic (options)', (t) => {
 
 test('cylinderElliptic (cone)', (t) => {
   const obs = cylinderElliptic({ endRadius: [0, 0] })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 10.128239395900382)
@@ -225,7 +225,7 @@ test('cylinderElliptic (cone)', (t) => {
 
 test('cylinderElliptic (squished)', (t) => {
   const obs = cylinderElliptic({ startRadius: [1, 0], endRadius: [0, 1], segments: 4 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 8.47213595499958)

package/src/primitives/ellipsoid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('ellipsoid (defaults)', (t) => {
   const obs = ellipsoid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 12.465694088650583)
@@ -21,7 +21,7 @@ test('ellipsoid (defaults)', (t) => {
 test('ellipsoid (options)', (t) => {
   // test radius
   let obs = ellipsoid({ radius: [3, 5, 7], segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[3, 0, 0], [2.598076211353316, -2.4999999999999996, 0],
       [2.25, -2.1650635094610964, -3.4999999999999996], [2.598076211353316, 0, -3.4999999999999996]],
@@ -152,14 +152,14 @@ test('ellipsoid (options)', (t) => {
 
   // test segments
   obs = ellipsoid({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 11.013439076647456)
   t.is(measureVolume(obs), 3.2189514164974597)
   t.is(pts.length, 32)
 
   obs = ellipsoid({ center: [-3, 5, 7], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2, 5, 7], [-2.2928932188134525, 4.292893218813452, 7],
       [-2.5, 4.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452]],
@@ -220,7 +220,7 @@ test('ellipsoid (options)', (t) => {
 
 test('ellipsoid (zero radius)', (t) => {
   const obs = ellipsoid({ radius: [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/geodesicSphere.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('geodesicSphere (defaults)', (t) => {
   const obs = geodesicSphere()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 20)
 })
@@ -18,7 +18,7 @@ test('geodesicSphere (defaults)', (t) => {
 test('geodesicSphere (options)', (t) => {
   // test radius
   let obs = geodesicSphere({ radius: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   const exp = [
     [[4.253254557317035, 0, 2.628654726407001], [2.628654726407001, -4.253254557317035, 0], [4.253254557317035, 0, -2.628654726407001]],
     [[4.253254557317035, 0, -2.628654726407001], [2.628654726407001, 4.253254557317035, 0], [4.253254557317035, 0, 2.628654726407001]],
@@ -50,7 +50,7 @@ test('geodesicSphere (options)', (t) => {
 
   // test frequency
   obs = geodesicSphere({ radius: 5, frequency: 18 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 303.76605423529395)
@@ -60,7 +60,7 @@ test('geodesicSphere (options)', (t) => {
 
 test('geodesicSphere (zero radius)', (t) => {
   const obs = geodesicSphere({ 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)

package/src/primitives/polyhedron.test.js

@@ -14,7 +14,7 @@ test('polyhedron (points and faces)', (t) => {
   let faces = [[0, 1, 2, 3], [5, 6, 7, 4], [0, 5, 4, 1], [3, 2, 7, 6], [0, 3, 6, 5], [1, 4, 7, 2]]
   const colors = [[0, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0.5, 0.5, 0.5, 1], [1, 1, 1, 1]]
   let obs = polyhedron({ points, faces, colors })
-  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]],
@@ -33,7 +33,7 @@ test('polyhedron (points and faces)', (t) => {
   points = [[10, 10, 0], [10, -10, 0], [-10, -10, 0], [-10, 10, 0], [0, 0, 10]]
   faces = [[0, 1, 4], [1, 2, 4], [2, 3, 4], [3, 0, 4], [1, 0, 3], [2, 1, 3]]
   obs = polyhedron({ points: points, faces: faces, orientation: 'inward' })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0, 0, 10], [10, -10, 0], [10, 10, 0]],
     [[0, 0, 10], [-10, -10, 0], [10, -10, 0]],

package/src/primitives/roundedCuboid.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCuboid (defaults)', (t) => {
   const obs = roundedCuboid()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 21.87859958298585)
@@ -20,7 +20,7 @@ test('roundedCuboid (defaults)', (t) => {
 
 test('roundedCuboid (zero size)', (t) => {
   const obs = roundedCuboid({ 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)
@@ -29,7 +29,7 @@ test('roundedCuboid (zero size)', (t) => {
 
 test('roundedCuboid (zero radius)', (t) => {
   const obs = roundedCuboid({ roundRadius: 0 })
-  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)
@@ -39,7 +39,7 @@ test('roundedCuboid (zero radius)', (t) => {
 test('roundedCuboid (options)', (t) => {
   // test segments
   let obs = roundedCuboid({ segments: 8 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = []
 
   t.notThrows(() => geom3.validate(obs))
@@ -49,7 +49,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test center
   obs = roundedCuboid({ center: [4, 5, 6], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
   ]
 
@@ -60,7 +60,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test size
   obs = roundedCuboid({ size: [8, 10, 12], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4, 4.8, -5.8], [3.9414213562373095, 4.941421356237309, -5.8],
       [3.9414213562373095, 4.941421356237309, 5.8], [4, 4.8, 5.8]],
@@ -163,7 +163,7 @@ test('roundedCuboid (options)', (t) => {
 
   // test roundRadius
   obs = roundedCuboid({ size: [8, 10, 12], roundRadius: 2, segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4, 3, -4], [3.414213562373095, 4.414213562373095, -4],
       [3.414213562373095, 4.414213562373095, 4], [4, 3, 4]],