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

package/src/geometries/geom3/isConvex.js

@@ -0,0 +1,65 @@
+import { EPS } from '../../maths/constants.js'
+import { dot } from '../../maths/vec3/dot.js'
+import { plane } from '../poly3/plane.js'
+
+import { isA } from './isA.js'
+import { toPolygons } from './toPolygons.js'
+
+/**
+ * Test if a 3D geometry is convex.
+ *
+ * A polyhedron is convex if every vertex lies on or behind every face plane
+ * (i.e., on the interior side of the plane).
+ *
+ * @param {geom3} geometry - the geometry to test
+ * @returns {boolean} true if the geometry is convex
+ * @alias module:modeling/geom3.isConvex
+ *
+ * @example
+ * const cube = cuboid()
+ * console.log(geom3.isConvex(cube)) // true
+ */
+export const isConvex = (geometry) => {
+  if (!isA(geometry)) {
+    throw new Error('isConvex requires a geom3 geometry')
+  }
+
+  const polygons = toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return true // Empty geometry is trivially convex
+  }
+
+  // Collect all unique vertices
+  const vertices = []
+  const found = new Set()
+  for (let i = 0; i < polygons.length; i++) {
+    const verts = polygons[i].vertices
+    for (let j = 0; j < verts.length; j++) {
+      const v = verts[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        vertices.push(v)
+      }
+    }
+  }
+
+  // For each face plane, check that all vertices are on or behind it
+  for (let i = 0; i < polygons.length; i++) {
+    const p = plane(polygons[i])
+
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      // Distance from point to plane: dot(normal, point) - w
+      const distance = dot(p, v) - p[3]
+
+      // If any vertex is in front of any face (positive distance), not convex
+      if (distance > EPS) {
+        return false
+      }
+    }
+  }
+
+  return true
+}

package/src/geometries/geom3/isConvex.test.js

@@ -0,0 +1,44 @@
+import test from 'ava'
+
+import { geom3, cylinderElliptic, sphere, cuboid, subtract } from '../../index.js'
+
+test('isConvex: throws for non-geom3 input', (t) => {
+  t.throws(() => geom3.isConvex('invalid'), { message: /requires a geom3/ })
+  t.throws(() => geom3.isConvex(null), { message: /requires a geom3/ })
+})
+
+test('isConvex: empty geometry is convex', (t) => {
+  const empty = geom3.create()
+  t.true(geom3.isConvex(empty))
+})
+
+test('isConvex: cuboid is convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  t.true(geom3.isConvex(cube))
+})
+
+test('isConvex: sphere is convex', (t) => {
+  const sph = sphere({ radius: 5, segments: 16 })
+  t.true(geom3.isConvex(sph))
+})
+
+test('isConvex: cylinder is convex', (t) => {
+  const cyl = cylinderElliptic({ height: 10, startRadius: [3, 3], endRadius: [3, 3], segments: 16 })
+  t.true(geom3.isConvex(cyl))
+})
+
+test('isConvex: cube with hole is not convex', (t) => {
+  const cube = cuboid({ size: [10, 10, 10] })
+  const hole = cuboid({ size: [4, 4, 20] }) // Hole through the cube
+
+  const withHole = subtract(cube, hole)
+  t.false(geom3.isConvex(withHole))
+})
+
+test('isConvex: L-shaped solid is not convex', (t) => {
+  const big = cuboid({ size: [10, 10, 10], center: [0, 0, 0] })
+  const corner = cuboid({ size: [6, 6, 12], center: [3, 3, 0] })
+
+  const lShape = subtract(big, corner)
+  t.false(geom3.isConvex(lShape))
+})

package/src/geometries/geom3/toPolygons.js

@@ -2,12 +2,14 @@ import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Produces an array of polygons from the given geometry, after applying transforms.
+ *
  * The returned array should not be modified as the polygons are shared with the geometry.
+ *
  * @param {Geom3} geometry - the geometry
  * @returns {Array} an array of polygons
- * @alias module:modeling/geometries/geom3.toPolygons
+ * @alias module:modeling/geom3.toPolygons
  *
  * @example
- * let sharedPolygons = toPolygons(geometry)
+ * let sharedPolygons = geom3.toPolygons(geometry)
  */
 export const toPolygons = (geometry) => applyTransforms(geometry).polygons

package/src/geometries/geom3/toString.js

@@ -4,12 +4,13 @@ import { toPolygons } from './toPolygons.js'
 
 /**
  * Create a string representing the contents of the given geometry.
+ *
  * @param {Geom3} geometry - the geometry
  * @returns {string} a representative string
- * @alias module:modeling/geometries/geom3.toString
+ * @alias module:modeling/geom3.toString
  *
  * @example
- * console.out(toString(geometry))
+ * console.out(geom3.toString(geometry))
  */
 export const toString = (geometry) => {
   const polygons = toPolygons(geometry)

package/src/geometries/geom3/toVertices.js

@@ -3,12 +3,16 @@ import * as poly3 from '../poly3/index.js'
 import { toPolygons } from './toPolygons.js'
 
 /**
- * Return the given geometry as a list of points, after applying transforms.
+ * Return the given geometry as a list of vertices, after applying transforms.
+ *
+ * The returned array should not be modified as the vertices are shared with the geometry.
  *
- * The returned array should not be modified as the points are shared with the geometry.
  * @param {Geom3} geometry - the geometry
- * @return {Array} list of points, where each sub-array represents a polygon
- * @alias module:modeling/geometries/geom3.toVertices
+ * @return {Array} list of vertices, where each sub-array represents a polygon
+ * @alias module:modeling/geom3.toVertices
+ *
+ * @example
+ * let sharedVertices = geom3.toVertices(geometry)
  */
 export const toVertices = (geometry) => {
   const polygons = toPolygons(geometry)

package/src/geometries/geom3/transform.js

@@ -2,15 +2,18 @@ import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
+ *
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.
+ *
  * See applyTransforms() for the actual application of the transforms to the polygons.
+ *
  * @param {Mat4} matrix - the matrix to transform with
  * @param {Geom3} geometry - the geometry to transform
  * @returns {Geom3} a new geometry
- * @alias module:modeling/geometries/geom3.transform
+ * @alias module:modeling/geom3.transform
  *
  * @example
- * let newGeometry = transform(fromXRotation(TAU / 4), geometry)
+ * let newGeometry = geom3.transform(fromXRotation(TAU / 4), geometry)
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)

package/src/geometries/geom3/validate.js

@@ -4,13 +4,17 @@ import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid 3D geometry.
+ *
  * Checks for valid data structure, convex polygon faces, and manifold edges.
  *
- * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ * **NOTE: 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
- * @alias module:modeling/geometries/geom3.validate
+ * @alias module:modeling/geom3.validate
+ *
+ * @example
+ * if (geom3.validate(geometry)) { ... }
  */
 export const validate = (object) => {
   if (!isA(object)) {

package/src/geometries/index.js

@@ -1,15 +1,17 @@
 /**
  * Geometries are objects that represent the contents of primitives or the results of operations.
+ *
  * Note: Geometries are considered immutable, so never change the contents directly.
  *
- * @see {@link geom2} - 2D geometry consisting of 2D outlines
- * @see {@link geom3} - 3D geometry consisting of polygons
- * @see {@link path2} - 2D geometry consisting of ordered points
- * @see {@link poly2} - 2D polygon consisting of ordered points
- * @see {@link poly3} - 3D polygon consisting of ordered vertices
- * @see {@link slice} - 3D geometry consisting of 3D contours
+ * @see [Geom2]{@link module:modeling/geom2} - 2D geometry consisting of 2D outlines
+ * @see [Geom3]{@link module:modeling/geom3} - 3D geometry consisting of polygons
+ * @see [Path2]{@link module:modeling/path2} - 2D geometry consisting of ordered 2D points
+ * @see [Path3]{@link module:modeling/path3} - 3D geometry consisting of ordered 3D vertices
+ * @see [Poly2]{@link module:modeling/poly2} - 2D polygon consisting of 2D points
+ * @see [Poly3]{@link module:modeling/poly3} - 3D polygon consisting of 3D vertices
+ * @see [Slice]{@link module:modeling/slice} - 3D geometry consisting of 3D contours
+ * @alias module:modeling.geometry
  *
- * @module modeling/geometries
  * @example
  * import { geom2, geom3, path2, poly2, poly3, slice } from '@jscad/modeling'
  */

package/src/geometries/path2/appendArc.js

@@ -6,8 +6,10 @@ import { toPoints } from './toPoints.js'
 
 /**
  * Append a series of points to the given geometry that represent an arc.
+ *
  * This implementation follows the SVG specifications.
  * @see http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
+ *
  * @param {object} options - options for construction
  * @param {Vec2} options.endpoint - end point of arc (REQUIRED)
  * @param {Vec2} [options.radius=[0,0]] - radius of arc (X and Y)
@@ -17,12 +19,12 @@ import { toPoints } from './toPoints.js'
  * @param {number} [options.segments=16] - number of segments per full rotation
  * @param {Path2} geometry - the path of which to append the arc
  * @returns {Path2} a new path with the appended points
- * @alias module:modeling/geometries/path2.appendArc
+ * @alias module:modeling/path2.appendArc
  *
  * @example
- * let myShape = fromPoints({}, [[27.5,-22.96875]]);
- * myShape = appendPoints([[27.5,-3.28125]], myShape);
- * myShape = appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
+ * let myShape = path2.fromPoints({}, [[27.5,-22.96875]]);
+ * myShape = path2.appendPoints([[27.5,-3.28125]], myShape);
+ * myShape = path2.appendArc({endpoint: [12.5, -22.96875], radius: [15, -19.6875]}, myShape);
  */
 export const appendArc = (options, geometry) => {
   const defaults = {
@@ -120,7 +122,7 @@ export const appendArc = (options, geometry) => {
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numSteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
+    let numSteps = Math.floor(segments * (Math.abs(deltatheta) / TAU))
     if (numSteps < 1) numSteps = 1
     for (let step = 1; step < numSteps; step++) {
       const theta = theta1 + step / numSteps * deltatheta

package/src/geometries/path2/appendArc.test.js

@@ -23,12 +23,12 @@ test('appendArc: appending to a path produces a new path', (t) => {
   const p2 = fromPoints({}, [[27, -22], [27, -3]])
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20] }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
 
   // test segments
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], segments: 64 }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 19)
+  t.is(pts.length, 17)
 
   // test clockwise
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], clockwise: true }, p2)
@@ -36,19 +36,17 @@ test('appendArc: appending to a path produces a new path', (t) => {
   let exp = [
     [27, -22],
     [27, -3],
-    [26.086451657912605, -8.941047736250177],
-    [23.87938869625451, -14.243872270248309],
-    [20.58174906029909, -18.420882475791835],
-    [16.49674848226545, -21.0880050920699],
-    [11.999999999999998, -22]
+    [24.7485593841743, -12.579008396887021],
+    [19.29019838402471, -19.492932330409836],
+    [12, -22]
   ]
-  t.is(pts.length, 7)
+  t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 
   // test large
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], large: true }, p2)
   pts = toPoints(obs)
-  t.is(pts.length, 16)
+  t.is(pts.length, 14)
 
   // test xaxisRotation
   obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisRotation: TAU / 4 }, p2)
@@ -56,14 +54,12 @@ test('appendArc: appending to a path produces a new path', (t) => {
   exp = [
     [27, -22],
     [27, -3],
-    [21.830323320631795, -4.401628923214028],
-    [17.364704977487236, -6.805886946199115],
+    [19.486852090983938, -5.488140907400943],
     [13.940501387124588, -10.031143708098092],
-    [11.816394990371812, -13.833746263211978],
-    [11.15285201325494, -17.926425912558045],
-    [12, -22.000000000000004]
+    [11.296247566821858, -15.862906638006239],
+    [12, -22]
   ]
-  t.is(pts.length, 8)
+  t.is(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
   // test small arc between far points

package/src/geometries/path2/appendBezier.js

@@ -7,22 +7,24 @@ import { toPoints } from './toPoints.js'
 
 /**
  * Append a series of points to the given geometry that represent a Bézier curve.
+ *
  * The Bézier curve starts at the last point in the given geometry, and ends at the last control point.
  * The other control points are intermediate control points to transition the curve from start to end points.
  * The first control point may be null to ensure a smooth transition occurs. In this case,
  * the second to last point of the given geometry is mirrored into the control points of the Bézier curve.
  * In other words, the trailing gradient of the geometry matches the new gradient of the curve.
+ *
  * @param {object} options - options for construction
  * @param {Array} options.controlPoints - list of control points (2D) for the Bézier curve
  * @param {number} [options.segments=16] - number of segments per 360 rotation
  * @param {Path2} geometry - the path of which to append points
  * @returns {Path2} a new path with the appended points
- * @alias module:modeling/geometries/path2.appendBezier
+ * @alias module:modeling/path2.appendBezier
  *
  * @example
- * let myShape = fromPoints({}, [[10,-20]])
- * myShape = appendBezier({controlPoints: [[10,-10],[25,-10],[25,-20]]}, myShape);
- * myShape = appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, myShape)
+ * let myShape = path2.fromPoints({}, [[10,-20]])
+ * myShape = path2.appendBezier({controlPoints: [[10,-10],[25,-10],[25,-20]]}, myShape);
+ * myShape = path2.appendBezier({controlPoints: [null, [25,-30],[40,-30],[40,-20]]}, myShape)
  */
 export const appendBezier = (options, geometry) => {
   const defaults = {

package/src/geometries/path2/appendPoints.js

@@ -3,11 +3,13 @@ import { create } from './create.js'
 
 /**
  * Append the given list of points to the end of the given geometry.
+ *
  * @param {Array} points - the points (2D) to append to the given path
  * @param {Path2} geometry - the given path
  * @returns {Path2} a new path with the appended points
- * @alias module:modeling/geometries/path2.appendPoints
+ * @alias module:modeling/path2.appendPoints
+ *
  * @example
- * let newPath = appendPoints([[3, 4], [4, 5]], oldPath)
+ * let newPath = path2.appendPoints([[3, 4], [4, 5]], oldPath)
  */
 export const appendPoints = (points, geometry) => concat(geometry, create(points))

package/src/geometries/path2/applyTransforms.js

@@ -3,9 +3,12 @@ import * as vec2 from '../../maths/vec2/index.js'
 
 /*
  * Apply the transforms of the given geometry.
+ *
  * NOTE: This function must be called BEFORE exposing any data. See toPoints.
+ *
  * @param {path} geometry - the geometry to transform
  * @returns {path} the given geometry
+ *
  * @example
  * geometry = applyTransforms(geometry)
  */

package/src/geometries/path2/clone.js

@@ -1,7 +1,11 @@
 /**
  * Performs a shallow clone of the give geometry.
+ *
  * @param {Path2} geometry - the geometry to clone
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.clone
+ * @alias module:modeling/path2.clone
+ *
+ * @example
+ * let newPath = path2.clone(oldPath)
  */
 export const clone = (geometry) => Object.assign({}, geometry)

package/src/geometries/path2/close.js

@@ -6,9 +6,13 @@ import { clone } from './clone.js'
 
 /**
  * Close the given geometry.
+ *
  * @param {Path2} geometry - the path to close
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.close
+ * @alias module:modeling/path2.close
+ *
+ * @example
+ * let newPath = path2.close(oldPath)
  */
 export const close = (geometry) => {
   if (geometry.isClosed) return geometry

package/src/geometries/path2/concat.js

@@ -10,12 +10,13 @@ import { toPoints } from './toPoints.js'
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
  * A concatenation of a path to a closed path is an error.
+ *
  * @param {...Path2} paths - the paths to concatenate
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.concat
+ * @alias module:modeling/path2.concat
  *
  * @example
- * let newPath = concat(fromPoints({}, [[1, 2]]), fromPoints({}, [[3, 4]]))
+ * let newPath = path2.concat(path2.fromPoints({}, [[1, 2]]), path2.fromPoints({}, [[3, 4]]))
  */
 export const concat = (...paths) => {
   // Only the last path can be closed, producing a closed path.

package/src/geometries/path2/create.js

@@ -1,24 +1,13 @@
 import * as mat4 from '../../maths/mat4/index.js'
 
-/**
- * Represents a 2D geometry consisting of a list of ordered points.
- * @property {Array} points - list of ordered points
- * @property {boolean} isClosed - true if the path is closed where start and end points are the same
- * @property {Mat4} transforms - transforms to apply to the points, see transform()
- * @example
- * {
- *   "points": [[0,0], [4,0], [4,3]],
- *   "isClosed": true,
- *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
- * }
- */
-
 /**
  * Create an empty, open path.
+ *
+ * @param {Array} [points] - a list of points of which to create the path
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.create
+ * @alias module:modeling/path2.create
  *
  * @example
- * let newPath = create()
+ * let newPath = path2.create()
  */
 export const create = (points = []) => ({ points: points, isClosed: false, transforms: mat4.create() })

package/src/geometries/path2/equals.js

@@ -3,13 +3,18 @@ import * as vec2 from '../../maths/vec2/index.js'
 import { toPoints } from './toPoints.js'
 
 /**
-  * Determine if the given paths are equal.
-  * For closed paths, this includes equality under point order rotation.
-  * @param {Path2} a - the first path to compare
-  * @param {Path2} b - the second path to compare
-  * @returns {Boolean}
-  * @alias module:modeling/geometries/path2.equals
-  */
+ * Determine if the given paths are equal.
+ *
+ * For closed paths, this includes equality under point order rotation.
+ *
+ * @param {Path2} a - the first path to compare
+ * @param {Path2} b - the second path to compare
+ * @returns {Boolean}
+ * @alias module:modeling/path2.equals
+ *
+ * @example
+ * if (path2.equals(pathA, pathB)) { ... }
+ */
 export const equals = (a, b) => {
   if (a.isClosed !== b.isClosed) {
     return false

package/src/geometries/path2/fromPoints.js

@@ -7,16 +7,18 @@ import { create } from './create.js'
 
 /**
  * Create a new path from the given points.
+ *
  * The points must be provided an array of points,
  * where each point is an array of two numbers.
+ *
  * @param {object} options - options for construction
  * @param {boolean} [options.closed=false] - if the path should be open or closed
  * @param {Array} points - array of points (2D) from which to create the path
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.fromPoints
+ * @alias module:modeling/path2.fromPoints
  *
- * @example:
- * my newPath = fromPoints({closed: true}, [[10, 10], [-10, 10]])
+ * @example
+ * my newPath = path2.fromPoints({closed: true}, [[10, 10], [-10, 10]])
  */
 export const fromPoints = (options, points) => {
   const defaults = { closed: false }

package/src/geometries/path2/index.js

@@ -1,11 +1,28 @@
 /**
  * Represents a 2D geometry consisting of a list of ordered points.
- * @see {@link path2} for data structure information.
- * @module modeling/geometries/path2
+ *
+ * @see {@link Path2} for data structure information.
+ * @module modeling/path2
+ *
+ * @example
+ * import { path2 } from '@jscad/modeling'
+ * let myShape = path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]])
+ */
+
+/**
+ * @typedef Path2
+ * @type {Object}
+ * @property {Array} points - list of ordered points
+ * @property {boolean} isClosed - true if the path is closed where start and end points are the same
+ * @property {Mat4} transforms - transforms to apply to the points, see transform()
  *
  * @example
- * import { geometries } from '@jscad/modeling'
- * let myShape = geometries.path2.fromPoints({ closed: true }, [[0,0], [4,0], [4,3]])
+ * // data structure
+ * {
+ *   "points": [[0,0], [4,0], [4,3]],
+ *   "isClosed": true,
+ *   "transforms": [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],
+ * }
  */
 export { appendArc } from './appendArc.js'
 export { appendBezier } from './appendBezier.js'

package/src/geometries/path2/isA.js

@@ -1,8 +1,12 @@
 /**
  * Determine if the given object is a path2 geometry.
+ *
  * @param {object} object - the object to interrogate
  * @returns {Boolean} true if the object matches a path2
- * @alias module:modeling/geometries/path2.isA
+ * @alias module:modeling/path2.isA
+ *
+ * @example
+ * if (path2.isA(geometry)) { ... }
  */
 export const isA = (object) => {
   if (object && typeof object === 'object') {

package/src/geometries/path2/reverse.js

@@ -2,13 +2,15 @@ import { clone } from './clone.js'
 
 /**
  * Reverses the path so that the points are in the opposite order.
+ *
  * This swaps the left (interior) and right (exterior) edges.
+ *
  * @param {Path2} geometry - the path to reverse
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.reverse
+ * @alias module:modeling/path2.reverse
  *
  * @example
- * let newPath = reverse(myPath)
+ * let newPath = path2.reverse(oldPath)
  */
 export const reverse = (geometry) => {
   // NOTE: this only updates the order of the points

package/src/geometries/path2/toPoints.js

@@ -2,12 +2,14 @@ import { applyTransforms } from './applyTransforms.js'
 
 /**
  * Produces an array of points from the given geometry.
- * The returned array should not be modified as the data is shared with the geometry.
+ *
+ * NOTE: The returned array should not be modified as the data is shared with the geometry.
+ *
  * @param {Path2} geometry - the geometry
  * @returns {Array} an array of points
- * @alias module:modeling/geometries/path2.toPoints
+ * @alias module:modeling/path2.toPoints
  *
  * @example
- * let sharedPoints = toPoints(geometry)
+ * let sharedPoints = path2.toPoints(geometry)
  */
 export const toPoints = (geometry) => applyTransforms(geometry).points

package/src/geometries/path2/toString.js

@@ -4,12 +4,13 @@ import { toPoints } from './toPoints.js'
 
 /**
  * Create a string representing the contents of the given path.
+ *
  * @param {Path2} geometry - the path
  * @returns {string} a representative string
- * @alias module:modeling/geometries/path2.toString
+ * @alias module:modeling/path2.toString
  *
  * @example
- * console.out(toString(path))
+ * console.out(path2.toString(path))
  */
 export const toString = (geometry) => {
   const points = toPoints(geometry)

package/src/geometries/path2/transform.js

@@ -2,15 +2,17 @@ import * as mat4 from '../../maths/mat4/index.js'
 
 /**
  * Transform the given geometry using the given matrix.
+ *
  * This is a lazy transform of the points, as this function only adjusts the transforms.
  * The transforms are applied when accessing the points via toPoints().
+ *
  * @param {Mat4} matrix - the matrix to transform with
  * @param {Path2} geometry - the geometry to transform
  * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.transform
+ * @alias module:modeling/path2.transform
  *
  * @example
- * let newPath = transform(fromZRotation(TAU / 8), path)
+ * let newPath = path2.transform(mat4.fromZRotation(TAU / 8), path)
  */
 export const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)