@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/geometries/slice/calculatePlane.js

@@ -0,0 +1,65 @@
+import * as plane from '../../maths/plane/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
+
+/**
+ * Calculate the plane of the given slice.
+ * NOTE: The slice (and all vertices) are assumed to be planar from the beginning.
+ * @param {Slice} slice - the slice
+ * @returns {Plane} the plane of the slice
+ * @alias module:modeling/geometries/slice.calculatePlane
+ *
+ * @example
+ * let myPlane = calculatePlane(slice)
+ */
+export const calculatePlane = (slice) => {
+  if (slice.contours.length < 1) {
+    throw new Error('slices must have at least one contour to calculate a plane')
+  }
+
+  // find the middle of the slice, which will lie on the plane by definition
+  const middle = vec3.create()
+  let n = 0 // number of vertices
+  slice.contours.forEach((contour) => {
+    contour.forEach((vertex) => {
+      vec3.add(middle, middle, vertex)
+      n++
+    })
+  })
+  vec3.scale(middle, middle, 1 / n)
+
+  // find the farthest edge from the middle, which will be on an outside edge
+  let farthestContour = []
+  let farthestBefore
+  let farthestVertex
+  let distance = 0
+  slice.contours.forEach((contour) => {
+    let prev = contour[contour.length - 1]
+    contour.forEach((vertex) => {
+      // make sure that the farthest edge is not a self-edge
+      if (!vec3.equals(prev, vertex)) {
+        const d = vec3.squaredDistance(middle, vertex)
+        if (d > distance) {
+          farthestContour = contour
+          farthestBefore = prev
+          farthestVertex = vertex
+          distance = d
+        }
+      }
+      prev = vertex
+    })
+  })
+
+  // find the after vertex
+  let farthestAfter
+  let prev = farthestContour[farthestContour.length - 1]
+  for (let i = 0; i < farthestContour.length; i++) {
+    const vertex = farthestContour[i]
+    if (!vec3.equals(prev, vertex) && vec3.equals(prev, farthestVertex)) {
+      farthestAfter = vertex
+      break
+    }
+    prev = vertex
+  }
+
+  return plane.fromPoints(plane.create(), farthestBefore, farthestVertex, farthestAfter)
+}

package/src/geometries/slice/calculatePlane.test.js

@@ -0,0 +1,43 @@
+import test from 'ava'
+
+import { TAU } from '../../maths/constants.js'
+import { mat4 } from '../../maths/index.js'
+
+import { calculatePlane, create, fromVertices, transform } from './index.js'
+
+import { compareVectors } from '../../../test/helpers/index.js'
+
+test('slice: calculatePlane() returns correct plans for various slices', (t) => {
+  // do not do this... it's an error
+  // const slice1 = create()
+  // const plane1 = calculatePlane(slice1)
+
+  const slice2 = fromVertices([[0, 0], [1, 0], [1, 1]])
+  const plane2 = calculatePlane(slice2)
+  t.true(compareVectors(plane2, [0, 0, 1, 0]))
+
+  const slice3 = transform(mat4.fromXRotation(mat4.create(), TAU / 4), slice2)
+  const plane3 = calculatePlane(slice3)
+  t.true(compareVectors(plane3, [0, -1, 0, 0]))
+
+  const slice4 = transform(mat4.fromZRotation(mat4.create(), TAU / 4), slice3)
+  const plane4 = calculatePlane(slice4)
+  t.true(compareVectors(plane4, [1, 0, 0, 0]))
+
+  // Issue #749
+  const slice5 = fromVertices([[-4, 0, 2], [4, 0, 2], [4, 5, 2], [6, 5, 2], [4, 7, 2], [-4, 7, 2], [-6, 5, 2], [-4, 5, 2]])
+  const plane5 = calculatePlane(slice5)
+  t.true(compareVectors(plane5, [0, 0, 1, 2]))
+
+  const slice6 = fromVertices([[4, 0, 0], [-4, 0, 0], [-4, 5, 0], [-6, 5, 0], [-4, 7, 0], [4, 7, 0], [6, 5, 0], [4, 5, 0]])
+  const plane6 = calculatePlane(slice6)
+  t.true(compareVectors(plane6, [0, 0, -1, 0]))
+
+  // from extrude tests
+  const slice7 = create([
+    [[-10, 10, 0], [-10, -10, 0], [10, -10, 0], [10, 10, 0]],
+    [[-5, -5, 0], [-5, 5, 0], [5, 5, 0], [5, -5, 0]]
+  ])
+  const plane7 = calculatePlane(slice7)
+  t.true(compareVectors(plane7, [0, 0, 1, 0]))
+})

package/src/geometries/slice/clone.d.ts

@@ -0,0 +1,3 @@
+import type { Slice } from './type.d.ts'
+
+export function clone(slice: Slice): Slice

package/src/geometries/slice/clone.js

@@ -0,0 +1,9 @@
+
+/**
+ * Create a deep clone of the given slice.
+ *
+ * @param {Slice} slice - slice to clone
+ * @returns {Slice} a new slice
+ * @alias module:modeling/geometries/slice.clone
+ */
+export const clone = (slice) => Object.assign({}, slice)

package/src/geometries/slice/clone.test.js

@@ -0,0 +1,14 @@
+import test from 'ava'
+
+import { create, clone, fromVertices, toVertices } from './index.js'
+
+test('slice: clone() should return a new slice with same values', (t) => {
+  const org1 = create()
+  const ret1 = clone(org1)
+  t.not(ret1, org1)
+
+  const org2 = fromVertices([[1, 1], [-1, 1], [-1, -1], [1, -1]])
+  const ret2 = clone(org2)
+  t.not(ret2, org2)
+  t.deepEqual(toVertices(ret2), toVertices(org2))
+})

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

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

package/src/geometries/slice/create.js

@@ -0,0 +1,18 @@
+/**
+ * Represents a 3D geometry consisting of a list of contours,
+ * where each contour consists of a list of planar vertices.
+ * @property {Array} contours - list of contours, each contour containing a list of 3D vertices
+ * @example
+ * {"contours": [[[0,0,1], [4,0,1], [4,3,1]]]}
+ */
+
+/**
+ * Creates a new slice from the given contours.
+ *
+ * @param {Array} [contours] - a list of contours, where each contour contains a list of vertices (3D)
+ * @returns {Slice} a new slice
+ * @alias module:modeling/geometries/slice.create
+ * @example
+ * const slice = create([ [[0,0,1], [4,0,1], [4,3,1]] ])
+ */
+export const create = (contours = []) => ({ contours })

package/src/{operations/extrusions → geometries}/slice/create.test.js

@@ -1,9 +1,9 @@
-const test = require('ava')
+import test from 'ava'
 
-const { create } = require('./index')
+import { create } from './index.js'
 
 test('slice: create() should return a slice with initial values', (t) => {
   const obs = create()
-  const exp = { edges: [] }
+  const exp = { contours: [] }
   t.deepEqual(obs, exp)
 })

package/src/{operations/extrusions → geometries/slice}/earcut/assignHoles.js

@@ -1,13 +1,13 @@
-const { area } = require('../../../maths/utils')
-const { toOutlines } = require('../../../geometries/geom2')
-const { arePointsInside } = require('../../../geometries/poly2')
+import { area } from '../../../maths/utils/area.js'
+import { toOutlines } from '../../geom2/index.js'
+import * as poly2 from '../../poly2/index.js'
 
 /*
  * Constructs a polygon hierarchy of solids and holes.
  * The hierarchy is represented as a forest of trees. All trees shall be depth at most 2.
  * If a solid exists inside the hole of another solid, it will be split out as its own root.
  *
- * @param {geom2} geometry
+ * @param {Geom2} geometry
  * @returns {Array} an array of polygons with associated holes
  * @alias module:modeling/geometries/geom2.toTree
  *
@@ -19,7 +19,7 @@ const { arePointsInside } = require('../../../geometries/poly2')
  *   "holes": [[[-1.5,1.5],[1.5,1.5],[1.5,-1.5],[-1.5,-1.5]]]
  * }]
  */
-const assignHoles = (geometry) => {
+export const assignHoles = (geometry) => {
   const outlines = toOutlines(geometry)
   const solids = [] // solid indices
   const holes = [] // hole indices
@@ -41,7 +41,7 @@ const assignHoles = (geometry) => {
     holes.forEach((h, j) => {
       const hole = outlines[h]
       // check if a point of hole j is inside solid i
-      if (arePointsInside([hole[0]], { vertices: solid })) {
+      if (poly2.arePointsInside([hole[0]], poly2.create(solid))) {
         children[i].push(h)
         if (!parents[j]) parents[j] = []
         parents[j].push(i)
@@ -87,5 +87,3 @@ const minIndex = (list, score) => {
   })
   return bestIndex
 }
-
-module.exports = assignHoles

package/src/geometries/slice/earcut/assignHoles.test.js

@@ -0,0 +1,75 @@
+import test from 'ava'
+
+import { subtract, union } from '../../../operations/booleans/index.js'
+import { square } from '../../../primitives/index.js'
+
+import { assignHoles } from './assignHoles.js'
+
+test('slice: assignHoles() should return a polygon hierarchy', (t) => {
+  const exp1 = [{
+    solid: [
+      [-3, -3],
+      [3, -3],
+      [3, 3],
+      [-3, 3]
+    ],
+    holes: [[
+      [-2, 2],
+      [2, 2],
+      [2, -2],
+      [-2, -2]
+    ]]
+  }]
+  const geometry = subtract(
+    square({ size: 6 }),
+    square({ size: 4 })
+  )
+  const obs1 = assignHoles(geometry)
+  t.deepEqual(obs1, exp1)
+})
+
+test('slice: assignHoles() should handle nested holes', (t) => {
+  const geometry = union(
+    subtract(
+      square({ size: 6 }),
+      square({ size: 4 })
+    ),
+    subtract(
+      square({ size: 10 }),
+      square({ size: 8 })
+    )
+  )
+  const obs1 = assignHoles(geometry)
+
+  const exp1 = [
+    {
+      solid: [
+        [-5, -5],
+        [5, -5],
+        [5, 5],
+        [-5, 5]
+      ],
+      holes: [[
+        [-4, 4],
+        [4, 4],
+        [4, -4],
+        [-4, -4]
+      ]]
+    },
+    {
+      solid: [
+        [-3, -3],
+        [3, -3],
+        [3, 3],
+        [-3, 3]
+      ],
+      holes: [[
+        [-2, 2],
+        [2, 2],
+        [2, -2],
+        [-2, -2]
+      ]]
+    }
+  ]
+  t.deepEqual(obs1, exp1)
+})

package/src/{operations/extrusions → geometries/slice}/earcut/eliminateHoles.js

@@ -1,5 +1,5 @@
-const { filterPoints, linkedPolygon, locallyInside, splitPolygon } = require('./linkedPolygon')
-const { area, pointInTriangle } = require('./triangle')
+import { filterPoints, linkedPolygon, locallyInside, splitPolygon } from './linkedPolygon.js'
+import { area, pointInTriangle } from './triangle.js'
 
 /*
  * link every hole into the outer loop, producing a single-ring polygon without holes
@@ -7,7 +7,7 @@ const { area, pointInTriangle } = require('./triangle')
  * Original source from https://github.com/mapbox/earcut
  * Copyright (c) 2016 Mapbox
  */
-const eliminateHoles = (data, holeIndices, outerNode, dim) => {
+export const eliminateHoles = (data, holeIndices, outerNode, dim) => {
   const queue = []
 
   for (let i = 0, len = holeIndices.length; i < len; i++) {
@@ -127,5 +127,3 @@ const getLeftmost = (start) => {
 
   return leftmost
 }
-
-module.exports = eliminateHoles

package/src/{operations/extrusions → geometries/slice}/earcut/index.js

@@ -1,7 +1,8 @@
-const eliminateHoles = require('./eliminateHoles')
-const { removeNode, sortLinked } = require('./linkedList')
-const { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, splitPolygon } = require('./linkedPolygon')
-const { area, pointInTriangle } = require('./triangle')
+import { eliminateHoles } from './eliminateHoles.js'
+import { removeNode } from './linkedList.js'
+import { linkedListSort } from './linkedListSort.js'
+import { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, splitPolygon } from './linkedPolygon.js'
+import { area, pointInTriangle } from './triangle.js'
 
 /*
  * An implementation of the earcut polygon triangulation algorithm.
@@ -13,7 +14,7 @@ const { area, pointInTriangle } = require('./triangle')
  * @param {holeIndices} An array of hole indices if any.
  * @param {dim} The number of coordinates per vertex in the input array.
  */
-const triangulate = (data, holeIndices, dim = 2) => {
+export const triangulate = (data, holeIndices, dim = 2) => {
   const hasHoles = holeIndices && holeIndices.length
   const outerLen = hasHoles ? holeIndices[0] * dim : data.length
   let outerNode = linkedPolygon(data, 0, outerLen, dim, true)
@@ -225,7 +226,7 @@ const indexCurve = (start, minX, minY, invSize) => {
   p.prevZ.nextZ = null
   p.prevZ = null
 
-  sortLinked(p, (p) => p.z)
+  linkedListSort(p, (p) => p.z)
 }
 
 /*
@@ -248,5 +249,3 @@ const zOrder = (x, y, minX, minY, invSize) => {
 
   return x | (y << 1)
 }
-
-module.exports = triangulate

package/src/{operations/extrusions → geometries/slice}/earcut/linkedList.js

@@ -1,6 +1,5 @@
-const sortLinked = require('./linkedListSort')
 
-class Node {
+export class Node {
   constructor (i, x, y) {
     // vertex index in coordinates array
     this.i = i
@@ -28,7 +27,7 @@ class Node {
 /*
  * create a node and optionally link it with previous one (in a circular doubly linked list)
  */
-const insertNode = (i, x, y, last) => {
+export const insertNode = (i, x, y, last) => {
   const p = new Node(i, x, y)
 
   if (!last) {
@@ -47,12 +46,10 @@ const insertNode = (i, x, y, last) => {
 /*
  * remove a node and join prev with next nodes
  */
-const removeNode = (p) => {
+export const removeNode = (p) => {
   p.next.prev = p.prev
   p.prev.next = p.next
 
   if (p.prevZ) p.prevZ.nextZ = p.nextZ
   if (p.nextZ) p.nextZ.prevZ = p.prevZ
 }
-
-module.exports = { Node, insertNode, removeNode, sortLinked }

package/src/{operations/extrusions → geometries/slice}/earcut/linkedListSort.js

@@ -1,7 +1,6 @@
-
 // Simon Tatham's linked list merge sort algorithm
 // https://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
-const sortLinked = (list, fn) => {
+export const linkedListSort = (list, fn) => {
   let i, p, q, e, numMerges
   let inSize = 1
 
@@ -50,5 +49,3 @@ const sortLinked = (list, fn) => {
 
   return list
 }
-
-module.exports = sortLinked

package/src/{operations/extrusions → geometries/slice}/earcut/linkedPolygon.js

@@ -1,10 +1,10 @@
-const { Node, insertNode, removeNode } = require('./linkedList')
-const { area } = require('./triangle')
+import { Node, insertNode, removeNode } from './linkedList.js'
+import { area } from './triangle.js'
 
 /*
  * create a circular doubly linked list from polygon points in the specified winding order
  */
-const linkedPolygon = (data, start, end, dim, clockwise) => {
+export const linkedPolygon = (data, start, end, dim, clockwise) => {
   let last
 
   if (clockwise === (signedArea(data, start, end, dim) > 0)) {
@@ -28,7 +28,7 @@ const linkedPolygon = (data, start, end, dim, clockwise) => {
 /*
  * eliminate colinear or duplicate points
  */
-const filterPoints = (start, end) => {
+export const filterPoints = (start, end) => {
   if (!start) return start
   if (!end) end = start
 
@@ -53,7 +53,7 @@ const filterPoints = (start, end) => {
 /*
  * go through all polygon nodes and cure small local self-intersections
  */
-const cureLocalIntersections = (start, triangles, dim) => {
+export const cureLocalIntersections = (start, triangles, dim) => {
   let p = start
   do {
     const a = p.prev
@@ -94,7 +94,7 @@ const intersectsPolygon = (a, b) => {
 /*
  * check if a polygon diagonal is locally inside the polygon
  */
-const locallyInside = (a, b) => area(a.prev, a, a.next) < 0
+export const locallyInside = (a, b) => area(a.prev, a, a.next) < 0
   ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0
   : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0
 
@@ -119,7 +119,7 @@ const middleInside = (a, b) => {
  * link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two
  * if one belongs to the outer ring and another to a hole, it merges it into a single ring
  */
-const splitPolygon = (a, b) => {
+export const splitPolygon = (a, b) => {
   const a2 = new Node(a.i, a.x, a.y)
   const b2 = new Node(b.i, b.x, b.y)
   const an = a.next
@@ -143,7 +143,7 @@ const splitPolygon = (a, b) => {
 /*
  * check if a diagonal between two polygon nodes is valid (lies in polygon interior)
  */
-const isValidDiagonal = (a, b) => a.next.i !== b.i &&
+export const isValidDiagonal = (a, b) => a.next.i !== b.i &&
     a.prev.i !== b.i &&
     !intersectsPolygon(a, b) && // doesn't intersect other edges
     (
@@ -193,5 +193,3 @@ const signedArea = (data, start, end, dim) => {
  * check if two points are equal
  */
 const equals = (p1, p2) => p1.x === p2.x && p1.y === p2.y
-
-module.exports = { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, locallyInside, splitPolygon }

package/src/{operations/extrusions → geometries/slice}/earcut/polygonHierarchy.js

@@ -1,23 +1,25 @@
-const geom2 = require('../../../geometries/geom2')
-const plane = require('../../../maths/plane')
-const vec2 = require('../../../maths/vec2')
-const vec3 = require('../../../maths/vec3')
-const calculatePlane = require('../slice/calculatePlane')
-const assignHoles = require('./assignHoles')
+import * as vec2 from '../../../maths/vec2/index.js'
+import * as vec3 from '../../../maths/vec3/index.js'
+
+import * as geom2 from '../../geom2/index.js'
+
+import { calculatePlane } from '../calculatePlane.js'
+
+import { assignHoles } from './assignHoles.js'
 
 /*
  * Constructs a polygon hierarchy which associates holes with their outer solids.
  * This class maps a 3D polygon onto a 2D space using an orthonormal basis.
  * It tracks the mapping so that points can be reversed back to 3D losslessly.
  */
-class PolygonHierarchy {
+export class PolygonHierarchy {
   constructor (slice) {
     this.plane = calculatePlane(slice)
 
     // create an orthonormal basis
     // choose an arbitrary right hand vector, making sure it is somewhat orthogonal to the plane normal
-    const rightvector = vec3.orthogonal(vec3.create(), this.plane)
-    const perp = vec3.cross(vec3.create(), this.plane, rightvector)
+    const rightVector = vec3.orthogonal(vec3.create(), this.plane)
+    const perp = vec3.cross(vec3.create(), this.plane, rightVector)
     this.v = vec3.normalize(perp, perp)
     this.u = vec3.cross(vec3.create(), this.v, this.plane)
 
@@ -25,7 +27,7 @@ class PolygonHierarchy {
     this.basisMap = new Map()
 
     // project slice onto 2D plane
-    const projected = slice.edges.map((e) => e.map((v) => this.to2D(v)))
+    const projected = slice.contours.map((part) => part.map((v) => this.to2D(v)))
 
     // compute polygon hierarchies, assign holes to solids
     const geometry = geom2.create(projected)
@@ -54,11 +56,9 @@ class PolygonHierarchy {
       const v1 = vec3.scale(vec3.create(), this.u, vector2[0])
       const v2 = vec3.scale(vec3.create(), this.v, vector2[1])
 
-      const planeOrigin = vec3.scale(vec3.create(), plane, plane[3])
+      const planeOrigin = vec3.scale(vec3.create(), this.plane, this.plane[3])
       const v3 = vec3.add(v1, v1, planeOrigin)
       return vec3.add(v2, v2, v3)
     }
   }
 }
-
-module.exports = PolygonHierarchy

package/src/{operations/extrusions → geometries/slice}/earcut/triangle.js

@@ -1,8 +1,7 @@
-
 /*
  * check if a point lies within a convex triangle
  */
-const pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (
+export const pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (
   (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
       (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
       (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
@@ -11,6 +10,4 @@ const pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (
 /*
  * signed area of a triangle
  */
-const area = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
-
-module.exports = { area, pointInTriangle }
+export const area = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)

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

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

package/src/geometries/slice/equals.js

@@ -0,0 +1,27 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+/**
+ * Determine if the given slices have the same contours.
+ * @param {Slice} a - the first slice to compare
+ * @param {Slice} b - the second slice to compare
+ * @returns {Boolean} true if the slices are equal
+ * @alias module:modeling/geometries/slice.equals
+ */
+export const equals = (a, b) => {
+  if (a.contours.length !== b.contours.length) {
+    return false
+  }
+
+  const len = a.contours.length
+  for (let i = 0; i < len; i++) {
+    const aVertex = a.contours[i]
+    for (let j = 0; j < len; j++) {
+      const bVertex = b.contours[j]
+      if (!vec3.equals(aVertex, bVertex)) {
+        return false
+      }
+    }
+  }
+
+  return true
+}

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

@@ -0,0 +1,17 @@
+import test from 'ava'
+
+import { equals, fromVertices } from './index.js'
+
+test('slice: equals() should return proper value', (t) => {
+  const sliceA = fromVertices([[0, 0], [1, 0], [1, 1]])
+  const sliceB = fromVertices([[0, 1], [1, 0], [1, 1]])
+  const sliceC = fromVertices([[0, 0], [1, 0], [1, 1], [0, 0]])
+
+  t.true(equals(sliceA, sliceA))
+
+  t.false(equals(sliceA, sliceB))
+  t.false(equals(sliceB, sliceA))
+
+  t.false(equals(sliceA, sliceC))
+  t.false(equals(sliceC, sliceA))
+})

package/src/geometries/slice/fromGeom2.d.ts

@@ -0,0 +1,5 @@
+import type { Geom2 } from '../geom2/type.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+export function fromGeom2(geometry: Geom2): Slice

package/src/geometries/slice/fromGeom2.js

@@ -0,0 +1,17 @@
+import * as vec3 from '../../maths/vec3/index.js'
+import { toOutlines } from '../geom2/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a slice from a geom2.
+ *
+ * @param {object} geometry - the 2D geometry to create a slice from
+ * @returns {Slice} a new slice
+ * @alias module:modeling/geometries/slice.fromGeom2
+ */
+export const fromGeom2 = (geometry) => {
+  // Convert from 2D points to 3D vertices
+  const contours = toOutlines(geometry).map((outline) => outline.map((point) => vec3.fromVec2(vec3.create(), point)))
+  return create(contours)
+}

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

@@ -0,0 +1,7 @@
+import type { Vec2, Vec3 } from '../../maths/types.d.ts'
+
+import type { Slice } from './type.d.ts'
+
+type Vertex = Vec2 | Vec3
+
+export function fromVertices(points: Array<Vertex>): Slice

package/src/geometries/slice/fromVertices.js

@@ -0,0 +1,34 @@
+import * as vec3 from '../../maths/vec3/index.js'
+
+import { create } from './create.js'
+
+/**
+ * Create a slice from the given vertices.
+ *
+ * @param {Array} vertices - list of vertices, where each vertex is either 2D or 3D
+ * @returns {Slice} a new slice
+ * @alias module:modeling/geometries/slice.fromVertices
+ *
+ * @example
+ * const vertices = [
+ *   [0,  0, 3],
+ *   [0, 10, 3],
+ *   [0, 10, 6]
+ * ]
+ * const slice = fromVertices(vertices)
+ */
+export const fromVertices = (vertices) => {
+  if (!Array.isArray(vertices)) throw new Error('the given vertices must be an array')
+  if (vertices.length < 3) throw new Error('the given vertices must contain THREE or more vertices')
+
+  // Convert from 2D points to 3D vertices if needed
+  const cloned = vertices.map((vertex) => {
+    if (vertex.length === 3) {
+      return vertex
+    } else {
+      return vec3.fromVec2(vec3.create(), vertex)
+    }
+  })
+  // create a slice with one contour containing all vertices
+  return create([cloned])
+}