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

package/src/geometries/path3/concat.test.js

@@ -0,0 +1,35 @@
+import test from 'ava'
+
+import { concat, equals, fromVertices } from './index.js'
+
+test('concat: no paths produces an empty open path', (t) => {
+  t.true(equals(concat(), fromVertices({ closed: false }, [])))
+})
+
+test('concat: empty paths produces an empty open path', (t) => {
+  t.true(equals(concat(fromVertices({}, []), fromVertices({}, [])), fromVertices({ closed: false }, [])))
+})
+
+test('concat: many open paths produces a open path', (t) => {
+  const p1 = fromVertices({ closed: false }, [[0, 0, 0]])
+  const p2 = fromVertices({ closed: false }, [[1, 1, 0]])
+  const p3 = fromVertices({ closed: false }, [[1, 1, 0], [3, 3, 0]])
+
+  const result = concat(p1, p2, p3)
+  t.true(equals(result, fromVertices({}, [[0, 0, 0], [1, 1, 0], [3, 3, 0]])))
+  t.is(p1.vertices.length, 1)
+  t.is(p2.vertices.length, 1)
+  t.is(p3.vertices.length, 2)
+})
+
+test('concat: an open path and a closed path produces a closed path', (t) => {
+  t.true(equals(concat(fromVertices({ closed: false }, [[0, 0, 0]]),
+    fromVertices({ closed: true }, [[1, 1, 0]])),
+  fromVertices({ closed: true }, [[0, 0, 0], [1, 1, 0]])))
+})
+
+test('concat: a closed path and an open path throws an error', (t) => {
+  const p1 = fromVertices({ closed: true }, [[0, 0, 0]])
+  const p2 = fromVertices({ closed: false }, [[1, 1, 0]])
+  t.throws(() => concat(p1, p2), { message: 'Cannot concatenate to a closed path; check the 1th path' })
+})

package/src/geometries/path3/create.d.ts

@@ -0,0 +1,4 @@
+import type { Path3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export function create(vertices?: Array<Vec3>): Path3

package/src/geometries/path3/create.js

@@ -0,0 +1,30 @@
+import * as mat4 from '../../maths/mat4/index.js'
+
+/**
+ * Represents a 3D geometry consisting of a list of ordered vertices.
+ *
+ * @typedef {Object} Path3
+ * @property {Array} vertices - list of ordered vertices
+ * @property {boolean} isClosed - true if the path is closed where start and end vertices are the same
+ * @property {Mat4} transforms - transforms to apply to the vertices, see transform()
+ *
+ * @example
+ * {
+ *   vertices: [[0,0,0], [4,0,0], [4,3,0]],
+ *   isClosed: true,
+ *   transforms: [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
+ */
+
+/**
+ * Create an empty, open path.
+ *
+ * @returns {Path3} a new path
+ * @function
+ * @alias module:modeling/geometries/path3.create
+ *
+ * @example
+ * let pathA = create()
+ * let pathB = create([[0,0,0], [4,0,0], [4,3,0]])
+ */
+export const create = (vertices = []) => ({ vertices: vertices, isClosed: false, transforms: mat4.create() })

package/src/geometries/path3/create.test.js

@@ -0,0 +1,8 @@
+import test from 'ava'
+
+import { create, equals, fromVertices } from './index.js'
+
+test('create: Creates an empty path', (t) => {
+  t.true(equals(create(), fromVertices({ closed: false }, [])))
+  t.true(equals(create([[0, 0, 0], [1, 1, 1]]), fromVertices({ closed: false }, [[0, 0, 0], [1, 1, 1]])))
+})

package/src/geometries/path3/equals.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function equals(a: Path3, b: Path3): boolean

package/src/geometries/path3/equals.js

@@ -0,0 +1,48 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { toVertices } from './toVertices.js'
+
+/**
+ * Determine if the given paths are equal.
+ *
+ * For closed paths, this includes equality by vertex order rotation.
+ *
+ * @param {Path3} a - the first path to compare
+ * @param {Path3} b - the second path to compare
+ * @returns {boolean}
+ * @function
+ * @alias module:modeling/geometries/path3.equals
+ */
+export const equals = (a, b) => {
+  if (a.isClosed !== b.isClosed) {
+    return false
+  }
+  if (a.vertices.length !== b.vertices.length) {
+    return false
+  }
+
+  const aVertices = toVertices(a)
+  const bVertices = toVertices(b)
+
+  // closed paths might be equal under graph rotation
+  // so try comparison by rotating across all vertices
+  const length = aVertices.length
+  let offset = 0
+  do {
+    let unequal = false
+    for (let i = 0; i < length; i++) {
+      if (!vec3.equals(aVertices[i], bVertices[(i + offset) % length])) {
+        unequal = true
+        break
+      }
+    }
+    if (unequal === false) {
+      return true
+    }
+    // unequal open paths should only be compared once, never rotated
+    if (!a.isClosed) {
+      return false
+    }
+  } while (++offset < length)
+  return false
+}

package/src/geometries/path3/equals.test.js

@@ -0,0 +1,38 @@
+import test from 'ava'
+
+import { equals, fromVertices } from './index.js'
+
+test('equals: two paths with different points are not equal', (t) => {
+  const p1 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0]])
+  const p2 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.false(equals(p1, p2))
+
+  const p3 = fromVertices({ closed: true }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [1, 0, 0]])
+  const p4 = fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.false(equals(p3, p4))
+})
+
+test('equals: two open paths with the same points are equal', (t) => {
+  const p1 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  const p2 = fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])
+  t.true(equals(p1, p2))
+})
+
+test('equals: two open paths with the same points rotated are unequal', (t) => {
+  t.false(equals(fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: false }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [0, 0, 0]])))
+})
+
+test('equals: two closed paths with the same points are equal', (t) => {
+  t.true(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])))
+
+  // rotated
+  t.true(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: true }, [[2, 0, 0], [2, 1, 0], [0, 1, 0], [0, 0, 0]])))
+})
+
+test('equals: closed path and open path with the same points are unequal', (t) => {
+  t.false(equals(fromVertices({ closed: true }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]]),
+    fromVertices({ closed: false }, [[0, 0, 0], [2, 0, 0], [2, 1, 0], [0, 1, 0]])))
+})

package/src/geometries/path3/fromVertices.d.ts

@@ -0,0 +1,8 @@
+import type { Path3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export interface FromVerticesOptions {
+  closed?: boolean
+}
+
+export function fromVertices(options: FromVerticesOptions, vertices: Array<Vec3>): Path3

package/src/geometries/path3/fromVertices.js

@@ -0,0 +1,45 @@
+import { EPS } from '../../maths/constants.js'
+
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { close } from './close.js'
+import { create } from './create.js'
+
+/**
+ * Create a new path from the given vertices.
+ *
+ * The vertices must be provided as an array of vertices,
+ * where each vertex is an array of three numbers.
+ *
+ * @param {Object} options - options for construction
+ * @param {boolean} [options.closed=false] - if the path should be open or closed
+ * @param {Array} vertices - array of vertices (3D) from which to create the path
+ * @returns {Path3} a new path
+ * @function
+ * @alias module:modeling/geometries/path3.fromVertices
+ *
+ * @example
+ * my newPath = fromVertices({closed: true}, [[10, 10, 10], [-10, 10, -10]])
+ */
+export const fromVertices = (options, vertices) => {
+  const defaults = { closed: false }
+  let { closed } = Object.assign({}, defaults, options)
+
+  let created = create()
+  // FIXME why clone vertices?
+  created.vertices = vertices.map((vertex) => vec3.clone(vertex))
+
+  // check if first and last vertices are equal
+  if (created.vertices.length > 1) {
+    const p0 = created.vertices[0]
+    const pn = created.vertices[created.vertices.length - 1]
+    // FIXME correct EPS
+    if (vec3.distance(p0, pn) < (EPS * EPS)) {
+      // and close automatically
+      closed = true
+    }
+  }
+  if (closed === true) created = close(created)
+
+  return created
+}

package/src/geometries/path3/fromVertices.test.js

@@ -0,0 +1,33 @@
+import test from 'ava'
+
+import { vec3 } from '../../maths/index.js'
+
+import { fromVertices, toVertices, toString } from './index.js'
+
+test('fromVertices: creating a path from no vertices produces an open, empty non-canonical path', (t) => {
+  const created = fromVertices({}, [])
+  t.false(created.isClosed)
+  t.deepEqual(toVertices(created), [])
+})
+
+test('fromVertices: creating a path from one point produces a open, non-canonical path', (t) => {
+  const created = fromVertices({}, [[1, 1, 0]])
+  toString(created)
+
+  t.false(created.isClosed)
+  t.deepEqual(toVertices(created), [vec3.fromValues(1, 1, 0)])
+})
+
+test('fromVertices: creating a closed path from one point produces a closed, non-canonical path', (t) => {
+  const created = fromVertices({ closed: true }, [[1, 1, 0]])
+  t.true(created.isClosed)
+  t.deepEqual(toVertices(created), [vec3.fromValues(1, 1, 0)])
+
+  toString(created)
+})
+
+test('fromVertices: creating a path from a closed set of vertices creates a closed, non-canonical path', (t) => {
+  const created = fromVertices({ closed: false }, [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 0, 0]])
+  t.true(created.isClosed)
+  t.is(3, created.vertices.length) // the last given point is dropped
+})

package/src/geometries/path3/index.d.ts

@@ -0,0 +1,13 @@
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromVertices, FromVerticesOptions } from './fromVertices.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toString } from './toString.js'
+export { toVertices } from './toVertices.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'
+
+export type { Path3 } from './type.d.ts'

package/src/geometries/path3/index.js

@@ -0,0 +1,21 @@
+/**
+ * Represents a 3D geometry consisting of a list of ordered vertices.
+ *
+ * @see {@link Path3} for data structure information.
+ * @module modeling/geometries/path3
+ *
+ * @example
+ * import { path3 } from '@jscad/modeling'
+ * let myShape = path3.fromVertices({ closed: true }, [[0,0,0], [4,0,0], [4,3,0]])
+ */
+export { close } from './close.js'
+export { concat } from './concat.js'
+export { create } from './create.js'
+export { equals } from './equals.js'
+export { fromVertices } from './fromVertices.js'
+export { isA } from './isA.js'
+export { reverse } from './reverse.js'
+export { toString } from './toString.js'
+export { toVertices } from './toVertices.js'
+export { transform } from './transform.js'
+export { validate } from './validate.js'

package/src/geometries/path3/isA.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function isA(object: any): object is Path3

package/src/geometries/path3/isA.js

@@ -0,0 +1,20 @@
+/**
+ * Determine if the given object is a path3 geometry.
+ *
+ * @param {Object} object - the object to interrogate
+ * @returns {boolean} true if the object matches a path3
+ * @function
+ * @alias module:modeling/geometries/path3.isA
+ */
+export const isA = (object) => {
+  if (object && typeof object === 'object') {
+    // see create for the required attributes and types
+    if ('vertices' in object && 'transforms' in object && 'isClosed' in object) {
+      // NOTE: transforms should be a TypedArray, which has a read-only length
+      if (Array.isArray(object.vertices) && 'length' in object.transforms) {
+        return true
+      }
+    }
+  }
+  return false
+}

package/src/geometries/path3/isA.test.js

@@ -0,0 +1,19 @@
+import test from 'ava'
+
+import { isA, create, fromVertices } from './index.js'
+
+test('isA: identifies created paths', (t) => {
+  const p1 = create()
+  const p2 = fromVertices({}, [[0, 0, 0]])
+  t.true(isA(p1))
+  t.true(isA(p2))
+})
+
+test('isA: identifies non paths', (t) => {
+  const p1 = null
+  const p2 = {}
+  const p3 = { vertices: 1, transforms: 1, isClosed: 1 }
+  t.false(isA(p1))
+  t.false(isA(p2))
+  t.false(isA(p3))
+})

package/src/geometries/path3/reverse.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function reverse(path: Path3): Path3

package/src/geometries/path3/reverse.js

@@ -0,0 +1,19 @@
+/**
+ * Reverses the path so that the vertices are in the opposite order.
+ *
+ * This swaps the left (interior) and right (exterior) edges.
+ *
+ * @param {Path3} geometry - the path to reverse
+ * @returns {Path3} a new path
+ * @function
+ * @alias module:modeling/geometries/path3.reverse
+ *
+ * @example
+ * let newPath = reverse(path)
+ */
+export const reverse = (geometry) => {
+  // NOTE: this only updates the order of the vertices
+  const cloned = Object.assign({}, geometry)
+  cloned.vertices = geometry.vertices.slice().reverse()
+  return cloned
+}

package/src/geometries/path3/reverse.test.js

@@ -0,0 +1,9 @@
+import test from 'ava'
+
+import { reverse, equals, fromVertices } from './index.js'
+
+test('reverse: The reverse of a path has reversed points', (t) => {
+  const vertices = [[0, 0], [1, 1, 0]]
+  t.false(equals(reverse(fromVertices({}, vertices)),
+    fromVertices({}, vertices)))
+})

package/src/geometries/path3/toString.d.ts

@@ -0,0 +1,3 @@
+import type { Path3 } from './type.d.ts'
+
+export function toString(geometry: Path3): string

package/src/geometries/path3/toString.js

@@ -0,0 +1,24 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { toVertices } from './toVertices.js'
+
+/**
+ * Create a string representing the contents of the given path.
+ *
+ * @param {path} geometry - the path
+ * @returns {string} a representative string
+ * @function
+ * @alias module:modeling/geometries/path3.toString
+ *
+ * @example
+ * console.out(toString(path))
+ */
+export const toString = (geometry) => {
+  const vertices = toVertices(geometry)
+  let result = 'path (' + vertices.length + ' vertices, ' + geometry.isClosed + '):\n[\n'
+  vertices.forEach((vertex) => {
+    result += '  ' + vec3.toString(vertex) + ',\n'
+  })
+  result += ']\n'
+  return result
+}

package/src/geometries/path3/toVertices.d.ts

@@ -0,0 +1,4 @@
+import type { Path3 } from './type.d.ts'
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+
+export function toVertices(geometry: Path3): Array<Vec3>

package/src/geometries/path3/toVertices.js

@@ -0,0 +1,16 @@
+import { applyTransforms } from './applyTransforms.js'
+
+/**
+ * Produces an array of vertices from the given geometry.
+ *
+ * The returned array should not be modified as the data is shared with the geometry.
+ *
+ * @param {Path3} geometry - the geometry
+ * @returns {Array} an array of vertices
+ * @function
+ * @alias module:modeling/geometries/path3.toVertices
+ *
+ * @example
+ * let sharedVertices = toVertices(path)
+ */
+export const toVertices = (geometry) => applyTransforms(geometry).vertices

package/src/geometries/path3/toVertices.test.js

@@ -0,0 +1,13 @@
+import test from 'ava'
+
+import { vec3 } from '../../maths/index.js'
+
+import { toVertices, fromVertices } from './index.js'
+
+test('toVertices: An empty path produces an empty point array', (t) => {
+  t.deepEqual(toVertices(fromVertices({}, [])), [])
+})
+
+test('toVertices: An non-empty open path produces a matching point array', (t) => {
+  t.deepEqual(toVertices(fromVertices({}, [[1, 1, 0]])), [vec3.fromValues(1, 1, 0)])
+})

package/src/geometries/path3/transform.d.ts

@@ -0,0 +1,4 @@
+import type { Path3 } from './type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+
+export function transform(matrix: Mat4, geometry: Path3): Path3

package/src/geometries/path3/transform.js

@@ -0,0 +1,21 @@
+import * as mat4 from '../../maths/mat4/index.js'
+
+/**
+ * Transform the given geometry using the given matrix.
+ *
+ * This is a lazy transform of the vertices, as this function only adjusts the transforms.
+ * The transforms are applied when accessing the vertices via toVertices().
+ *
+ * @param {Mat4} matrix - the matrix to transform with
+ * @param {Path3} geometry - the geometry to transform
+ * @returns {Path3} a new path
+ * @function
+ * @alias module:modeling/geometries/path3.transform
+ *
+ * @example
+ * let newPath = transform(fromZRotation(TAU / 8), path)
+ */
+export const transform = (matrix, geometry) => {
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
+}

package/src/geometries/path3/transform.test.js

@@ -0,0 +1,50 @@
+import test from 'ava'
+
+import { mat4 } from '../../maths/index.js'
+
+import { transform, fromVertices, toVertices } from './index.js'
+
+import { comparePoints, compareVectors } from '../../../test/helpers/index.js'
+
+test('transform: adjusts the transforms of path', (t) => {
+  const vertices = [[0, 0, 0], [1, 0, 0], [0, 1, 0]]
+  const rotation = 90 * 0.017453292519943295
+  const rotate90 = mat4.fromZRotation(mat4.create(), rotation)
+
+  // continue with typical user scenario, several iterations of transforms and access
+
+  // expect lazy transform, i.e. only the transforms change
+  const expected = {
+    vertices: [[0, 0, 0], [1, 0, 0], [0, 1, 0]],
+    isClosed: false,
+    transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  const geometry = fromVertices({}, vertices)
+  let another = transform(rotate90, geometry)
+  t.not(geometry, another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect lazy transform, i.e. only the transforms change
+  expected.transforms = [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
+  another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect application of the transforms to the vertices
+  expected.vertices = [[5, 10, 15], [5, 11, 15], [4, 10, 15]]
+  expected.transforms = mat4.create()
+  toVertices(another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+
+  // expect lazy transform, i.e. only the transforms change
+  expected.transforms = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5, 10, 15, 1]
+  another = transform(mat4.fromTranslation(mat4.create(), [5, 10, 15]), another)
+  t.true(comparePoints(another.vertices, expected.vertices))
+  t.false(another.isClosed)
+  t.true(compareVectors(another.transforms, expected.transforms))
+})

package/src/geometries/path3/type.d.ts

@@ -0,0 +1,10 @@
+import type { Vec3 } from '../../maths/vec3/type.d.ts'
+import type { Mat4 } from '../../maths/mat4/type.d.ts'
+import type { Color } from '../types.d.ts'
+
+export interface Path3 {
+  vertices: Array<Vec3>
+  isClosed: boolean
+  transforms: Mat4
+  color?: Color
+}

package/src/geometries/path3/validate.d.ts

@@ -0,0 +1 @@
+export function validate(object: any): void

package/src/geometries/path3/validate.js

@@ -0,0 +1,41 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { isA } from './isA.js'
+
+/**
+ * Determine if the given object is a valid path3.
+ * Checks for valid vertices, and duplicate vertices.
+ *
+ * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ *
+ * @param {Object} object - the object to interrogate
+ * @throws {Error} error if the geometry is not valid
+ * @function
+ * @alias module:modeling/geometries/path3.validate
+ */
+export const validate = (object) => {
+  if (!isA(object)) {
+    throw new Error('invalid path3 structure')
+  }
+
+  // check for duplicate vertices
+  if (object.vertices.length > 1) {
+    for (let i = 0; i < object.vertices.length; i++) {
+      if (vec3.equals(object.vertices[i], object.vertices[(i + 1) % object.vertices.length])) {
+        throw new Error(`path3 has duplicate vertex ${object.vertices[i]}`)
+      }
+    }
+  }
+
+  // check for infinity, nan
+  object.vertices.forEach((vertex) => {
+    if (!vertex.every(Number.isFinite)) {
+      throw new Error(`path3 invalid non-finite vertex ${vertex}`)
+    }
+  })
+
+  // check transforms
+  if (!object.transforms.every(Number.isFinite)) {
+    throw new Error(`path3 invalid transforms ${object.transforms}`)
+  }
+}

package/src/geometries/poly2/create.js

@@ -15,9 +15,4 @@
  * @example
  * let polygon = create([[0,0], [4,0], [4,3]])
  */
-export const create = (points) => {
-  if (points === undefined || points.length < 3) {
-    points = [] // empty contents
-  }
-  return { points }
-}
+export const create = (points = []) => ({ points })

package/src/geometries/poly3/create.js

@@ -16,9 +16,4 @@
  * @example
  * const polygon = create([[1, 0], [0, 1], [0, 0]])
  */
-export const create = (vertices) => {
-  if (vertices === undefined || vertices.length < 3) {
-    vertices = [] // empty contents
-  }
-  return { vertices }
-}
+export const create = (vertices = []) => ({ vertices })

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

@@ -17,7 +17,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of one object
   const result1 = intersect(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('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = intersect(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows(() => geom3.validate(result2))
   t.is(measureArea(result2), 0)
   t.is(measureVolume(result2), 0)
@@ -88,7 +88,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = intersect(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
 
   // the order changes based on the best plane chosen in Node.js
   exp = [
@@ -108,7 +108,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of two completely overlapping objects
   const result4 = intersect(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows.skip(() => geom3.validate(result4))
   t.is(measureArea(result4), 44.053756306589825)
   t.is(measureVolume(result4), 25.751611331979678)