@jbroll/jscad-modeling 2.12.7

package/src/connectors/transform.js

@@ -0,0 +1,28 @@
+const vec3 = require('../maths/vec3')
+
+const fromPointAxisNormal = require('./fromPointAxisNormal')
+
+/**
+ * Transform the give connector using the given matrix.
+ * @param {mat4} matrix - a transform matrix
+ * @param {connector} connector - the connector to transform
+ * @returns {connector} a new connector
+ * @alias module:modeling/connectors.transform
+ */
+const transform = (matrix, connector) => {
+  // OPTIMIZE
+  const newpoint = vec3.transform(vec3.create(), connector.point, matrix)
+  const newaxis = vec3.subtract(
+    vec3.create(),
+    vec3.transform(vec3.create(), vec3.add(vec3.create(), connector.point, connector.axis), matrix),
+    newpoint
+  )
+  const newnormal = vec3.subtract(
+    vec3.create(),
+    vec3.transform(vec3.create(), vec3.add(vec3.create(), connector.point, connector.normal), matrix),
+    newpoint
+  )
+  return fromPointAxisNormal(newpoint, newaxis, newnormal)
+}
+
+module.exports = transform

package/src/connectors/transform.test.js

@@ -0,0 +1,106 @@
+const test = require('ava')
+
+const { transform, create, fromPointAxisNormal } = require('./index')
+
+const { compareVectors } = require('../../test/helpers/')
+
+test('connector: transform() should return a connector with correct values', (t) => {
+  const connector1 = create()
+  const connector2 = fromPointAxisNormal([1, 0, 0], [0, 1, 0], [0, 0, 1])
+  const connector3 = fromPointAxisNormal([-3, -3, -3], [3, 3, 3], [3, -3, 3])
+
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  let obs1 = transform(identityMatrix, connector1)
+  t.true(compareVectors(obs1.point, [0, 0, 0]))
+  t.true(compareVectors(obs1.axis, [0, 0, 1]))
+  t.true(compareVectors(obs1.normal, [1, 0, 0]))
+
+  obs1 = transform(identityMatrix, connector2)
+  t.true(compareVectors(obs1.point, [1, 0, 0]))
+  t.true(compareVectors(obs1.axis, [0, 1, 0]))
+  t.true(compareVectors(obs1.normal, [0, 0, 1]))
+
+  obs1 = transform(identityMatrix, connector3)
+  t.true(compareVectors(obs1.point, [-3, -3, -3]))
+  t.true(compareVectors(obs1.axis, [0.5773502691896258, 0.5773502691896258, 0.5773502691896258]))
+  t.true(compareVectors(obs1.normal, [0.5773502691896258, -0.5773502691896258, 0.5773502691896258]))
+
+  const x = 1
+  const y = 5
+  const z = 7
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  let obs2 = transform(translationMatrix, connector1)
+  t.true(compareVectors(obs2.point, [1, 5, 7]))
+  t.true(compareVectors(obs2.axis, [0, 0, 1]))
+  t.true(compareVectors(obs2.normal, [1, 0, 0]))
+
+  obs2 = transform(translationMatrix, connector2)
+  t.true(compareVectors(obs2.point, [2, 5, 7]))
+  t.true(compareVectors(obs2.axis, [0, 1, 0]))
+  t.true(compareVectors(obs2.normal, [0, 0, 1]))
+
+  obs2 = transform(translationMatrix, connector3)
+  t.true(compareVectors(obs2.point, [-2, 2, 4]))
+  t.true(compareVectors(obs2.axis, [0.5773502691896256, 0.5773502691896256, 0.5773502691896261]))
+  t.true(compareVectors(obs2.normal, [0.5773502691896256, -0.5773502691896256, 0.5773502691896261]))
+
+  const w = 1
+  const h = 3
+  const d = 5
+  const scaleMatrix = [
+    w, 0, 0, 0,
+    0, h, 0, 0,
+    0, 0, d, 0,
+    0, 0, 0, 1
+  ]
+
+  let obs3 = transform(scaleMatrix, connector1)
+  t.true(compareVectors(obs3.point, [0, 0, 0]))
+  t.true(compareVectors(obs3.axis, [0, 0, 1]))
+  t.true(compareVectors(obs3.normal, [1, 0, 0]))
+
+  obs3 = transform(scaleMatrix, connector2)
+  t.true(compareVectors(obs3.point, [1, 0, 0]))
+  t.true(compareVectors(obs3.axis, [0, 1, 0]))
+  t.true(compareVectors(obs3.normal, [0, 0, 1]))
+
+  obs3 = transform(scaleMatrix, connector3)
+  t.true(compareVectors(obs3.point, [-3, -9, -15]))
+  t.true(compareVectors(obs3.axis, [0.1690308509457033, 0.5070925528371097, 0.8451542547285166]))
+  t.true(compareVectors(obs3.normal, [0.1690308509457033, -0.5070925528371097, 0.8451542547285166]))
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), Math.sin(r), 0, 0,
+    -Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  let obs4 = transform(rotateZMatrix, connector1)
+  t.true(compareVectors(obs4.point, [0, 0, 0]))
+  t.true(compareVectors(obs4.axis, [0, 0, 1]))
+  t.true(compareVectors(obs4.normal, [6.123234262925839e-17, 1, 0]))
+
+  obs4 = transform(rotateZMatrix, connector2)
+  t.true(compareVectors(obs4.point, [0, 1, 0]))
+  t.true(compareVectors(obs4.axis, [-1, 0, 0]))
+  t.true(compareVectors(obs4.normal, [0, 0, 1]))
+
+  obs4 = transform(rotateZMatrix, connector3)
+  t.true(compareVectors(obs4.point, [3, -3, -3]))
+  t.true(compareVectors(obs4.axis, [-0.5773502691896258, 0.5773502691896258, 0.5773502691896258]))
+  t.true(compareVectors(obs4.normal, [0.5773502691896258, 0.5773502691896258, 0.5773502691896258]))
+})

package/src/connectors/transformationBetween.js

@@ -0,0 +1,68 @@
+const mat4 = require('../maths/mat4')
+const plane = require('../maths/plane')
+const vec2 = require('../maths/vec2')
+const vec3 = require('../maths/vec3')
+
+const OrthoNormalBasis = require('../maths/OrthoNormalBasis')
+
+const transform = require('./transform')
+
+/**
+ * Get the transformation matrix that connects the given connectors.
+ * @param {Object} options
+ * @param {Boolean} [options.mirror=false] - the 'axis' vectors should point in the same direction
+ *  true: the 'axis' vectors should point in opposite direction
+ * @param {Number} [options.normalRotation=0] - the angle (RADIANS) of rotation between the 'normal' vectors
+ * @param {connector} from - connector from which to connect
+ * @param {connector} to - connector to which to connected
+ * @returns {mat4} - the matrix that transforms (connects) one connector to another
+ * @alias module:modeling/connectors.transformationBetween
+ */
+const transformationBetween = (options, from, to) => {
+  const defaults = {
+    mirror: false,
+    normalRotation: 0
+  }
+  // mirror = !!mirror
+  const { mirror, normalRotation } = Object.assign({}, defaults, options)
+
+  // shift to the 0,0 origin
+  const matrix = mat4.fromTranslation(mat4.create(), vec3.negate(vec3.create(), from.point))
+
+  // align the axis
+  const axesplane = plane.fromPointsRandom(plane.create(), vec3.create(), from.axis, to.axis)
+  const axesbasis = new OrthoNormalBasis(axesplane)
+
+  let angle1 = vec2.angleRadians(axesbasis.to2D(from.axis))
+  let angle2 = vec2.angleRadians(axesbasis.to2D(to.axis))
+
+  let rotation = angle2 - angle1
+  if (mirror) rotation += Math.PI // 180 degrees
+
+  // TODO: understand and explain this
+  mat4.multiply(matrix, matrix, axesbasis.getProjectionMatrix())
+  mat4.multiply(matrix, matrix, mat4.fromZRotation(mat4.create(), rotation))
+  mat4.multiply(matrix, matrix, axesbasis.getInverseProjectionMatrix())
+  const usAxesAligned = transform(matrix, from)
+  // Now we have done the transformation for aligning the axes.
+
+  // align the normals
+  const normalsplane = plane.fromNormalAndPoint(plane.create(), to.axis, vec3.create())
+  const normalsbasis = new OrthoNormalBasis(normalsplane)
+
+  angle1 = vec2.angleRadians(normalsbasis.to2D(usAxesAligned.normal))
+  angle2 = vec2.angleRadians(normalsbasis.to2D(to.normal))
+
+  rotation = angle2 - angle1 + normalRotation
+
+  mat4.multiply(matrix, matrix, normalsbasis.getProjectionMatrix())
+  mat4.multiply(matrix, matrix, mat4.fromZRotation(mat4.create(), rotation))
+  mat4.multiply(matrix, matrix, normalsbasis.getInverseProjectionMatrix())
+
+  // translate to the destination point
+  mat4.multiply(matrix, matrix, mat4.fromTranslation(mat4.create(), to.point))
+
+  return matrix
+}
+
+module.exports = transformationBetween

package/src/connectors/transformationBetween.test.js

@@ -0,0 +1,40 @@
+const test = require('ava')
+
+const { transformationBetween, create, fromPointAxisNormal } = require('./index')
+
+const { compareVectors } = require('../../test/helpers')
+
+test('connector: transformationBetween() should return correct transform matrices', (t) => {
+  const connector1 = create()
+  const connector2 = create()
+  const connector3 = fromPointAxisNormal([0, 0, 0], [0, 0, 1], [0, 1, 0]) // Y axis as normal
+
+  let obs = transformationBetween({}, connector1, connector2)
+  let exp = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  t.true(compareVectors(obs, exp))
+
+  obs = transformationBetween({}, connector1, connector3)
+  exp = [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  t.true(compareVectors(obs, exp))
+
+  // connectors as taken from V1 cube
+  const facecenter0 = fromPointAxisNormal([3, 0, 0], [1, 0, 0], [0, 0, 1])
+  const facecenter1 = fromPointAxisNormal([-3, 0, 0], [-1, 0, 0], [0, 0, 1])
+  const facecenter2 = fromPointAxisNormal([0, 3, 0], [0, 1, 0], [0, 0, 1])
+  // const facecenter3 = fromPointAxisNormal([0, -3, 0], [0, -1, 0], [0, 0, 1])
+  // const facecenter4 = fromPointAxisNormal([0, 0, 3], [0, 0, 1], [1, 0, 0])
+  const facecenter5 = fromPointAxisNormal([0, 0, -3], [0, 0, -1], [1, 0, 0])
+
+  obs = transformationBetween({}, facecenter0, facecenter1) // opposing faces
+  exp = [-1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, -3.6739405577555036e-16, 0, 1]
+  t.true(compareVectors(obs, exp))
+
+  obs = transformationBetween({}, facecenter2, facecenter5) // adjacent faces
+  exp = [0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, 0, 3, -3, 0, 1]
+  t.true(compareVectors(obs, exp))
+
+  // test mirror option
+  obs = transformationBetween({ mirror: true }, facecenter0, facecenter1) // opposing faces
+  exp = [1, -2.4492937051703357e-16, 0, 0, 2.4492937051703357e-16, 1, 0, 0, 0, 0, 1, 0, -6, 7.347881115511007e-16, 0, 1]
+  t.true(compareVectors(obs, exp))
+})

package/src/curves/bezier/arcLengthToT.d.ts

@@ -0,0 +1,10 @@
+import Bezier from './type'
+
+export default arcLengthToT
+
+export interface ArcLengthToTOptions {
+  distance?: Number
+  segments?: Number
+}
+
+declare function arcLengthToT(options: ArcLengthToTOptions, bezier: Bezier): number

package/src/curves/bezier/arcLengthToT.js

@@ -0,0 +1,63 @@
+const lengths = require('./lengths')
+
+/**
+ * Convert a given arc length along a bezier curve to a t value.
+ * Useful for generating equally spaced points along a bezier curve.
+ *
+ * @example
+ * const points = [];
+ * const segments = 9; // this will generate 10 equally spaced points
+ * const increment = bezier.length(100, bezierCurve) / segments;
+ * for(let i = 0; i <= segments; i++) {
+ *   const t = bezier.arcLengthToT({distance: i * increment}, bezierCurve);
+ *   const point = bezier.valueAt(t, bezierCurve);
+ *   points.push(point);
+ * }
+ * return points;
+ *
+ * @param {Object} [options] options for construction
+ * @param {Number} [options.distance=0] the distance along the bezier curve for which we want to find the corresponding t value.
+ * @param {Number} [options.segments=100] the number of segments to use when approximating the curve length.
+ * @param {Object} bezier a bezier curve.
+ * @returns a number in the [0, 1] interval or NaN if the arcLength is negative or greater than the total length of the curve.
+ * @alias module:modeling/curves/bezier.arcLengthToT
+ */
+const arcLengthToT = (options, bezier) => {
+  const defaults = {
+    distance: 0,
+    segments: 100
+  }
+  const { distance, segments } = Object.assign({}, defaults, options)
+
+  const arcLengths = lengths(segments, bezier)
+  // binary search for the index with largest value smaller than target arcLength
+  let startIndex = 0
+  let endIndex = segments
+  while (startIndex <= endIndex) {
+    const middleIndex = Math.floor(startIndex + (endIndex - startIndex) / 2)
+    const diff = arcLengths[middleIndex] - distance
+    if (diff < 0) {
+      startIndex = middleIndex + 1
+    } else if (diff > 0) {
+      endIndex = middleIndex - 1
+    } else {
+      endIndex = middleIndex
+      break
+    }
+  }
+  // if we have an exact match, return it
+  const targetIndex = endIndex
+  if (arcLengths[targetIndex] === distance) {
+    return targetIndex / segments
+  }
+  // we could get finer grain at lengths, or use simple interpolation between two points
+  const lengthBefore = arcLengths[targetIndex]
+  const lengthAfter = arcLengths[targetIndex + 1]
+  const segmentLength = lengthAfter - lengthBefore
+  // determine where we are between the 'before' and 'after' points
+  const segmentFraction = (distance - lengthBefore) / segmentLength
+  // add that fractional amount and return
+  return (targetIndex + segmentFraction) / segments
+}
+
+module.exports = arcLengthToT

package/src/curves/bezier/arcLengthToT.test.js

@@ -0,0 +1,79 @@
+const test = require('ava')
+
+const { bezier } = require('../index')
+const length = require('./length')
+const arcLengthToT = require('./arcLengthToT')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+
+test('calculate arcLengthToT for an 1D linear bezier with numeric control points', (t) => {
+  const bezierCurve = bezier.create([0, 10])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for an 1D linear bezier with array control points', (t) => {
+  const bezierCurve = bezier.create([[0], [10]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 2D linear bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [10, 10]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 2D quadratic (3 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.50001, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 2D cubic (4 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10], [10, 0]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 3D linear bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [10, 10, 10]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 3D quadratic (3 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})
+
+test('calculate arcLengthToT for a 3D cubic (4 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10], [-5, -5, 5]])
+  const len = length(100, bezierCurve)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5621, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
+  t.true(true)
+})

package/src/curves/bezier/create.d.ts

@@ -0,0 +1,5 @@
+import Bezier from './type'
+
+export default create
+
+declare function create(points: Array<number> | Array<Array<number>>): Bezier

package/src/curves/bezier/create.js

@@ -0,0 +1,81 @@
+/**
+ * Represents a bezier easing function.
+ * @typedef {Object} bezier
+ * @property {Array} points - The control points for the bezier curve. The first and last point will also be the start and end of the curve
+ * @property {string} pointType - A reference to the type and dimensionality of the points that the curve was created from
+ * @property {number} dimensions - The dimensionality of the bezier
+ * @property {Array} permutations - A pre-calculation of the bezier algorithm's co-efficients
+ * @property {Array} tangentPermutations - A pre-calculation of the bezier algorithm's tangent co-efficients
+ *
+ */
+
+/**
+ * Creates an object representing a bezier easing curve.
+ * Curves can have both an arbitrary number of control points, and an arbitrary number of dimensions.
+ *
+ * @example
+ * const b = bezier.create([0,10]) // a linear progression from 0 to 10
+ * const b = bezier.create([0, 0, 10, 10]) // a symmetrical cubic easing curve that starts slowly and ends slowly from 0 to 10
+ * const b = bezier.create([0,0,0], [0,5,10], [10,0,-5], [10,10,10]]) // a cubic 3 dimensional easing curve that can generate position arrays for modelling
+ * // Usage
+ * let position = bezier.valueAt(t,b) // where 0 < t < 1
+ * let tangent = bezier.tangentAt(t,b) // where 0 < t < 1
+ *
+ * @param {Array} points An array with at least 2 elements of either all numbers, or all arrays of numbers that are the same size.
+ * @returns {bezier} a new bezier data object
+ * @alias module:modeling/curves/bezier.create
+ */
+const create = (points) => {
+  if (!Array.isArray(points)) throw new Error('Bezier points must be a valid array/')
+  if (points.length < 2) throw new Error('Bezier points must contain at least 2 values.')
+  const pointType = getPointType(points)
+
+  return {
+    points: points,
+    pointType: pointType,
+    dimensions: pointType === 'float_single' ? 0 : points[0].length,
+    permutations: getPermutations(points.length - 1),
+    tangentPermutations: getPermutations(points.length - 2)
+  }
+}
+
+const getPointType = function (points) {
+  let firstPointType = null
+  points.forEach((point) => {
+    let pType = ''
+    if (Number.isFinite(point)) {
+      pType = 'float_single'
+    } else if (Array.isArray(point)) {
+      point.forEach((val) => {
+        if (!Number.isFinite(val)) throw new Error('Bezier point values must all be numbers.')
+      })
+      pType = 'float_' + point.length
+    } else throw new Error('Bezier points must all be numbers or arrays of number.')
+    if (firstPointType == null) {
+      firstPointType = pType
+    } else {
+      if (firstPointType !== pType) {
+        throw new Error('Bezier points must be either all numbers or all arrays of numbers of the same size.')
+      }
+    }
+  })
+  return firstPointType
+}
+
+const getPermutations = function (c) {
+  const permutations = []
+  for (let i = 0; i <= c; i++) {
+    permutations.push(factorial(c) / (factorial(i) * factorial(c - i)))
+  }
+  return permutations
+}
+
+const factorial = function (b) {
+  let out = 1
+  for (let i = 2; i <= b; i++) {
+    out *= i
+  }
+  return out
+}
+
+module.exports = create

package/src/curves/bezier/create.test.js

@@ -0,0 +1,60 @@
+const test = require('ava')
+
+const { bezier } = require('../index')
+
+test('Linear bezier (straight line between two points)', (t) => {
+  const straightLine = bezier.create([10, 20])
+  t.deepEqual(straightLine.points, [10, 20])
+  t.is(straightLine.pointType, 'float_single')
+  t.deepEqual(straightLine.permutations, [1, 1])
+  t.deepEqual(straightLine.tangentPermutations, [1])
+  t.is(straightLine.dimensions, 0)
+})
+
+test('bezier with non-numbers throws error', (t) => {
+  t.throws(() => bezier.create(['what', 20]), { instanceOf: Error })
+})
+
+test('quadratic bezier (3 control points)', (t) => {
+  const OneDCurve = bezier.create([0, 10, 20])
+  t.deepEqual(OneDCurve.points, [0, 10, 20])
+  t.is(OneDCurve.pointType, 'float_single')
+  t.deepEqual(OneDCurve.permutations, [1, 2, 1])
+  t.deepEqual(OneDCurve.tangentPermutations, [1, 1])
+  t.is(OneDCurve.dimensions, 0)
+})
+
+test('quadratic bezier (4 control points)', (t) => {
+  const OneDCurve = bezier.create([0, 0, 20, 20])
+  t.deepEqual(OneDCurve.points, [0, 0, 20, 20])
+  t.is(OneDCurve.pointType, 'float_single')
+  t.deepEqual(OneDCurve.permutations, [1, 3, 3, 1])
+  t.deepEqual(OneDCurve.tangentPermutations, [1, 2, 1])
+  t.is(OneDCurve.dimensions, 0)
+})
+
+test('bezier with numbers and array of numbers throws error', (t) => {
+  t.throws(() => bezier.create([[0, 5, 10], 20]), { instanceOf: Error })
+})
+
+test('bezier with array of numbers of different size throws error', (t) => {
+  t.throws(() => bezier.create([[0, 5, 10], [20, 0]]), { instanceOf: Error })
+})
+
+test('quadratic bezier one dimension, 3 control points', (t) => {
+  const OneDCurve = bezier.create([[0], [10], [20]])
+  t.deepEqual(OneDCurve.points, [[0], [10], [20]])
+  t.is(OneDCurve.pointType, 'float_1')
+  t.deepEqual(OneDCurve.permutations, [1, 2, 1])
+  t.deepEqual(OneDCurve.tangentPermutations, [1, 1])
+  t.is(OneDCurve.dimensions, 1)
+})
+
+test('quadratic bezier 2 dimensions, 3 control points', (t) => {
+  const TwoDCurve = bezier.create([[0, 10], [30, 10], [60, 20]])
+  t.deepEqual(TwoDCurve.points, [[0, 10], [30, 10], [60, 20]])
+  t.is(TwoDCurve.pointType, 'float_2')
+  t.deepEqual(TwoDCurve.permutations, [1, 2, 1])
+  t.deepEqual(TwoDCurve.tangentPermutations, [1, 1])
+  t.is(TwoDCurve.dimensions, 2)
+})

package/src/curves/bezier/index.d.ts

@@ -0,0 +1,9 @@
+export { default as create } from './create'
+export { default as tangentAt } from './tangentAt'
+export { default as valueAt } from './valueAt'
+export { default as lengths } from './lengths'
+export { default as length } from './length'
+export { default as arcLengthToT } from './arcLengthToT'
+
+export { default as Bezier } from './type'
+export as namespace bezier

package/src/curves/bezier/index.js

@@ -0,0 +1,13 @@
+/**
+ * Represents a bezier easing function.
+ * @see {@link bezier} for data structure information.
+ * @module modeling/curves/bezier
+ */
+module.exports = {
+  create: require('./create'),
+  valueAt: require('./valueAt'),
+  tangentAt: require('./tangentAt'),
+  lengths: require('./lengths'),
+  length: require('./length'),
+  arcLengthToT: require('./arcLengthToT')
+}

package/src/curves/bezier/length.d.ts

@@ -0,0 +1,5 @@
+import Bezier from './type'
+
+export default length
+
+declare function length(segments: number, bezier: Bezier): number

package/src/curves/bezier/length.js

@@ -0,0 +1,18 @@
+const lengths = require('./lengths')
+
+/**
+ * Approximates the length of the bezier curve by sampling it at a sequence of points, then adding up all the distances.
+ * This is equivalent to flattening the curve into lines and adding up all the line lengths.
+ *
+ * @example
+ * const b = bezier.create([[0, 0], [0, 10]]);
+ * console.log(length(100, b)) // output 10
+ *
+ * @param {Number} segments the number of segments to use when approximating the curve length.
+ * @param {Object} bezier a bezier curve.
+ * @returns an approximation of the curve's length.
+ * @alias module:modeling/curves/bezier.length
+ */
+const length = (segments, bezier) => lengths(segments, bezier)[segments]
+
+module.exports = length

package/src/curves/bezier/length.test.js

@@ -0,0 +1,54 @@
+const test = require('ava')
+
+const { bezier } = require('../index')
+const length = require('./length')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+
+test('calculate the length of an 1D linear bezier with numeric control points', (t) => {
+  const bezierCurve = bezier.create([0, 10])
+  nearlyEqual(t, length(100, bezierCurve), 10, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of an 1D linear bezier with array control points', (t) => {
+  const bezierCurve = bezier.create([[0], [10]])
+  nearlyEqual(t, length(100, bezierCurve), 10, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 2D linear bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [10, 10]])
+  nearlyEqual(t, length(100, bezierCurve), 14.1421, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 2D quadratic (3 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10]])
+  nearlyEqual(t, length(100, bezierCurve), 16.2320, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 2D cubic (4 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10], [10, 0]])
+  nearlyEqual(t, length(100, bezierCurve), 19.9992, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 3D linear bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [10, 10, 10]])
+  nearlyEqual(t, length(100, bezierCurve), 17.3205, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 3D quadratic (3 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10]])
+  nearlyEqual(t, length(100, bezierCurve), 12.7125, 0.0001)
+  t.true(true)
+})
+
+test('calculate the length of a 3D cubic (4 control points) bezier', (t) => {
+  const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10], [-5, -5, 5]])
+  nearlyEqual(t, length(100, bezierCurve), 17.2116, 0.0001)
+  t.true(true)
+})

package/src/curves/bezier/lengths.d.ts

@@ -0,0 +1,5 @@
+import Bezier from './type'
+
+export default lengths
+
+declare function lengths(segments: number, bezier: Bezier): Array<number>