@jbroll/jscad-modeling 2.12.7

package/src/maths/utils/area.js

@@ -0,0 +1,17 @@
+/**
+ * Calculate the area under the given points.
+ * @param {Array} points - list of 2D points
+ * @return {Number} area under the given points
+ * @alias module:modeling/maths/utils.area
+ */
+const area = (points) => {
+  let area = 0
+  for (let i = 0; i < points.length; i++) {
+    const j = (i + 1) % points.length
+    area += points[i][0] * points[j][1]
+    area -= points[j][0] * points[i][1]
+  }
+  return (area / 2.0)
+}
+
+module.exports = area

package/src/maths/utils/index.d.ts

@@ -0,0 +1,8 @@
+export { default as aboutEqualNormals } from './aboutEqualNormals'
+export { default as area } from './area'
+export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
+export { default as intersect } from './intersect'
+export { default as solve2Linear } from './solve2Linear'
+export { sin, cos } from './trigonometry'
+
+export as namespace utils

package/src/maths/utils/index.js

@@ -0,0 +1,15 @@
+/**
+ * Utility functions for maths.
+ * @module modeling/maths/utils
+ * @example
+ * const { area, solve2Linear } = require('@jscad/maths').utils
+ */
+module.exports = {
+  aboutEqualNormals: require('./aboutEqualNormals'),
+  area: require('./area'),
+  cos: require('./trigonometry').cos,
+  interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
+  intersect: require('./intersect'),
+  sin: require('./trigonometry').sin,
+  solve2Linear: require('./solve2Linear')
+}

package/src/maths/utils/interpolateBetween2DPointsForY.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from '../vec2/type'
+
+export default interpolateBetween2DPointsForY
+
+declare function interpolateBetween2DPointsForY(point1: Vec2, point2: Vec2, y: number): number

package/src/maths/utils/interpolateBetween2DPointsForY.js

@@ -0,0 +1,31 @@
+/**
+ * Get the X coordinate of a point with a certain Y coordinate, interpolated between two points.
+ * Interpolation is robust even if the points have the same Y coordinate
+ * @param {vec2} point1
+ * @param {vec2} point2
+ * @param {Number} y
+ * @return {Array} X and Y of interpolated point
+ * @alias module:modeling/maths/utils.interpolateBetween2DPointsForY
+ */
+const interpolateBetween2DPointsForY = (point1, point2, y) => {
+  let f1 = y - point1[1]
+  let f2 = point2[1] - point1[1]
+  if (f2 < 0) {
+    f1 = -f1
+    f2 = -f2
+  }
+  let t
+  if (f1 <= 0) {
+    t = 0.0
+  } else if (f1 >= f2) {
+    t = 1.0
+  } else if (f2 < 1e-10) { // FIXME Should this be EPS?
+    t = 0.5
+  } else {
+    t = f1 / f2
+  }
+  const result = point1[0] + t * (point2[0] - point1[0])
+  return result
+}
+
+module.exports = interpolateBetween2DPointsForY

package/src/maths/utils/intersect.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from '../vec2/type'
+
+export default intersect
+
+declare function intersect(p1: Vec2, p2: Vec2, p3: Vec2, p4: Vec2): Vec2

package/src/maths/utils/intersect.js

@@ -0,0 +1,40 @@
+/**
+ * Calculate the intersect point of the two line segments (p1-p2 and p3-p4), end points included.
+ * Note: If the line segments do NOT intersect then undefined is returned.
+ * @see http://paulbourke.net/geometry/pointlineplane/
+ * @param {vec2} p1 - first point of first line segment
+ * @param {vec2} p2 - second point of first line segment
+ * @param {vec2} p3 - first point of second line segment
+ * @param {vec2} p4 - second point of second line segment
+ * @returns {vec2} intersection point of the two line segments, or undefined
+ * @alias module:modeling/maths/utils.intersect
+ */
+const intersect = (p1, p2, p3, p4) => {
+  // Check if none of the lines are of length 0
+  if ((p1[0] === p2[0] && p1[1] === p2[1]) || (p3[0] === p4[0] && p3[1] === p4[1])) {
+    return undefined
+  }
+
+  const denominator = ((p4[1] - p3[1]) * (p2[0] - p1[0]) - (p4[0] - p3[0]) * (p2[1] - p1[1]))
+
+  // Lines are parallel
+  if (Math.abs(denominator) < Number.MIN_VALUE) {
+    return undefined
+  }
+
+  const ua = ((p4[0] - p3[0]) * (p1[1] - p3[1]) - (p4[1] - p3[1]) * (p1[0] - p3[0])) / denominator
+  const ub = ((p2[0] - p1[0]) * (p1[1] - p3[1]) - (p2[1] - p1[1]) * (p1[0] - p3[0])) / denominator
+
+  // is the intersection along the segments
+  if (ua < 0 || ua > 1 || ub < 0 || ub > 1) {
+    return undefined
+  }
+
+  // Return the x and y coordinates of the intersection
+  const x = p1[0] + ua * (p2[0] - p1[0])
+  const y = p1[1] + ua * (p2[1] - p1[1])
+
+  return [x, y]
+}
+
+module.exports = intersect

package/src/maths/utils/solve2Linear.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from '../vec2/type'
+
+export default solve2Linear
+
+declare function solve2Linear(a: number, b: number, c: number, d: number, u: number, v: number): Vec2

package/src/maths/utils/solve2Linear.js

@@ -0,0 +1,11 @@
+const solve2Linear = (a, b, c, d, u, v) => {
+  const det = a * d - b * c
+  const invdet = 1.0 / det
+  let x = u * d - b * v
+  let y = -u * c + a * v
+  x *= invdet
+  y *= invdet
+  return [x, y]
+}
+
+module.exports = solve2Linear

package/src/maths/utils/trigonometry.d.ts

@@ -0,0 +1,2 @@
+export function cos(radians: number): number
+export function sin(radians: number): number

package/src/maths/utils/trigonometry.js

@@ -0,0 +1,34 @@
+const { NEPS } = require('../constants')
+
+/*
+ * Returns zero if n is within epsilon of zero, otherwise return n
+ */
+const rezero = (n) => Math.abs(n) < NEPS ? 0 : n
+
+/**
+ * Return Math.sin but accurate for TAU / 4 rotations.
+ * Fixes rounding errors when sin should be 0.
+ *
+ * @param {Number} radians - angle in radians
+ * @returns {Number} sine of the given angle
+ * @alias module:modeling/utils.sin
+ * @example
+ * sin(TAU / 2) == 0
+ * sin(TAU) == 0
+ */
+const sin = (radians) => rezero(Math.sin(radians))
+
+/**
+ * Return Math.cos but accurate for TAU / 4 rotations.
+ * Fixes rounding errors when cos should be 0.
+ *
+ * @param {Number} radians - angle in radians
+ * @returns {Number} cosine of the given angle
+ * @alias module:modeling/utils.cos
+ * @example
+ * cos(TAU * 0.25) == 0
+ * cos(TAU * 0.75) == 0
+ */
+const cos = (radians) => rezero(Math.cos(radians))
+
+module.exports = { sin, cos }

package/src/maths/utils/trigonometry.test.js

@@ -0,0 +1,27 @@
+const test = require('ava')
+
+const { TAU } = require('../constants')
+
+const { cos, sin } = require('./trigonometry')
+
+test('utils: sin() should return rounded values', (t) => {
+  t.is(sin(0), 0)
+  t.is(sin(9), Math.sin(9))
+  t.is(sin(0.25 * TAU), 1)
+  t.is(sin(0.5 * TAU), 0)
+  t.is(sin(0.75 * TAU), -1)
+  t.is(sin(TAU), 0)
+  t.is(sin(NaN), NaN)
+  t.is(sin(Infinity), NaN)
+})
+
+test('utils: cos() should return rounded values', (t) => {
+  t.is(cos(0), 1)
+  t.is(cos(9), Math.cos(9))
+  t.is(cos(0.25 * TAU), 0)
+  t.is(cos(0.5 * TAU), -1)
+  t.is(cos(0.75 * TAU), 0)
+  t.is(cos(TAU), 1)
+  t.is(cos(NaN), NaN)
+  t.is(cos(Infinity), NaN)
+})

package/src/maths/vec1/type.d.ts

@@ -0,0 +1,3 @@
+export default Vec1
+
+declare type Vec1 = [number]

package/src/maths/vec2/abs.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default abs
+
+declare function abs(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/abs.js

@@ -0,0 +1,15 @@
+/**
+ * Calculates the absolute coordinates of the given vector.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - vector of reference
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.abs
+ */
+const abs = (out, vector) => {
+  out[0] = Math.abs(vector[0])
+  out[1] = Math.abs(vector[1])
+  return out
+}
+
+module.exports = abs

package/src/maths/vec2/abs.test.js

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { abs, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: abs() with two params should update a vec2 with correct values', (t) => {
+  const vec1 = create()
+  const ret1 = abs(vec1, [0, 0])
+  t.true(compareVectors(vec1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+  t.is(vec1, ret1)
+
+  const vec2 = create()
+  const ret2 = abs(vec2, [1, 2])
+  t.true(compareVectors(vec2, [1, 2]))
+  t.true(compareVectors(ret2, [1, 2]))
+  t.is(vec2, ret2)
+
+  const vec3 = create()
+  const ret3 = abs(vec3, [-1, -2])
+  t.true(compareVectors(vec3, [1, 2]))
+  t.true(compareVectors(ret3, [1, 2]))
+  t.is(vec3, ret3)
+})

package/src/maths/vec2/add.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default add
+
+declare function add(out: Vec2, a: Vec2, b: Vec2): Vec2

package/src/maths/vec2/add.js

@@ -0,0 +1,16 @@
+/**
+ * Adds the coordinates of two vectors (A+B).
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.add
+ */
+const add = (out, a, b) => {
+  out[0] = a[0] + b[0]
+  out[1] = a[1] + b[1]
+  return out
+}
+
+module.exports = add

package/src/maths/vec2/add.test.js

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { add, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: add() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0)
+  const ret1 = add(obs1, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+
+  const obs2 = fromValues(0, 0)
+  const ret2 = add(obs2, [1, 2], [3, 2])
+  t.true(compareVectors(obs2, [4, 4]))
+  t.true(compareVectors(ret2, [4, 4]))
+
+  const obs3 = fromValues(0, 0)
+  const ret3 = add(obs3, [1, 2], [-1, -2])
+  t.true(compareVectors(obs3, [0, 0]))
+  t.true(compareVectors(ret3, [0, 0]))
+
+  const obs4 = fromValues(0, 0)
+  const ret4 = add(obs4, [-1, -2], [-1, -2])
+  t.true(compareVectors(obs4, [-2, -4]))
+  t.true(compareVectors(ret4, [-2, -4]))
+})

package/src/maths/vec2/angle.d.ts

@@ -0,0 +1,3 @@
+import angleRadians from './angleRadians'
+
+export default angleRadians

package/src/maths/vec2/angle.js

@@ -0,0 +1 @@
+module.exports = require('./angleRadians')

package/src/maths/vec2/angleDegrees.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default angleDegrees
+
+declare function angleDegrees(vector: Vec2): number

package/src/maths/vec2/angleDegrees.js

@@ -0,0 +1,12 @@
+const angleRadians = require('./angleRadians')
+
+/**
+ * Calculate the angle of the given vector.
+ *
+ * @param {vec2} vector - vector of reference
+ * @returns {Number} angle in degrees
+ * @alias module:modeling/maths/vec2.angleDegrees
+ */
+const angleDegrees = (vector) => angleRadians(vector) * 57.29577951308232
+
+module.exports = angleDegrees

package/src/maths/vec2/angleDegrees.test.js

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { angleDegrees } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: angleDegrees() should return correct values', (t) => {
+  const distance1 = angleDegrees([0, 0])
+  nearlyEqual(t, distance1, 0.0, EPS)
+
+  const distance2 = angleDegrees([1, 2])
+  nearlyEqual(t, distance2, 63.4349488, EPS)
+
+  const distance3 = angleDegrees([1, -2])
+  nearlyEqual(t, distance3, -63.4349488, EPS)
+
+  const distance4 = angleDegrees([-1, -2])
+  nearlyEqual(t, distance4, -116.5650511, EPS)
+
+  const distance5 = angleDegrees([-1, 2])
+  nearlyEqual(t, distance5, 116.5650511, EPS)
+
+  t.true(true)
+})

package/src/maths/vec2/angleRadians.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default angleRadians
+
+declare function angleRadians(vector: Vec2): number

package/src/maths/vec2/angleRadians.js

@@ -0,0 +1,10 @@
+/**
+ * Calculate the angle of the given vector.
+ *
+ * @param {vec2} vector - vector of reference
+ * @returns {Number} angle in radians
+ * @alias module:modeling/maths/vec2.angleRadians
+ */
+const angleRadians = (vector) => Math.atan2(vector[1], vector[0]) // y=sin, x=cos
+
+module.exports = angleRadians

package/src/maths/vec2/angleRadians.test.js

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { angleRadians } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('vec2: angleRadians() should return correct values', (t) => {
+  const distance1 = angleRadians([0, 0])
+  nearlyEqual(t, distance1, 0.0, EPS)
+
+  const distance2 = angleRadians([1, 2])
+  nearlyEqual(t, distance2, 1.1071487177940904, EPS)
+
+  const distance3 = angleRadians([1, -2])
+  nearlyEqual(t, distance3, -1.1071487177940904, EPS)
+
+  const distance4 = angleRadians([-1, -2])
+  nearlyEqual(t, distance4, -2.0344439357957027, EPS)
+
+  const distance5 = angleRadians([-1, 2])
+  nearlyEqual(t, distance5, 2.0344439357957027, EPS)
+
+  t.true(true)
+})

package/src/maths/vec2/clone.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default clone
+
+declare function clone(vec: Vec2): Vec2

package/src/maths/vec2/clone.js

@@ -0,0 +1,17 @@
+const create = require('./create')
+
+/**
+ * Create a clone of the given vector.
+ *
+ * @param {vec2} vector - vector to clone
+ * @returns {vec2} a new vector
+ * @alias module:modeling/maths/vec2.clone
+ */
+const clone = (vector) => {
+  const out = create()
+  out[0] = vector[0]
+  out[1] = vector[1]
+  return out
+}
+
+module.exports = clone

package/src/maths/vec2/clone.test.js

@@ -0,0 +1,21 @@
+const test = require('ava')
+const { clone, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: clone() should return a new vec2 with same values', (t) => {
+  const org1 = fromValues(0, 0)
+  const obs1 = clone(org1)
+  t.true(compareVectors(obs1, [0, 0]))
+  t.not(obs1, org1)
+
+  const org2 = fromValues(1, 2)
+  const obs2 = clone(org2)
+  t.true(compareVectors(obs2, [1, 2]))
+  t.not(obs2, org2)
+
+  const org3 = fromValues(-1, -2)
+  const obs3 = clone(org3)
+  t.true(compareVectors(obs3, [-1, -2]))
+  t.not(obs3, org3)
+})

package/src/maths/vec2/copy.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default copy
+
+declare function copy(out: Vec2, vector: Vec2): Vec2

package/src/maths/vec2/copy.js

@@ -0,0 +1,15 @@
+/**
+ * Create a copy of the given vector.
+ *
+ * @param {vec2} out - receiving vector
+ * @param {vec2} vector - source vector
+ * @returns {vec2} out
+ * @alias module:modeling/maths/vec2.copy
+ */
+const copy = (out, vector) => {
+  out[0] = vector[0]
+  out[1] = vector[1]
+  return out
+}
+
+module.exports = copy

package/src/maths/vec2/copy.test.js

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { copy, create, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: copy() with two params should update a vec2 with same values', (t) => {
+  const out1 = create()
+  const org1 = fromValues(0, 0)
+  const ret1 = copy(out1, org1)
+  t.true(compareVectors(out1, [0, 0]))
+  t.true(compareVectors(ret1, [0, 0]))
+  t.not(ret1, org1)
+  t.is(out1, ret1)
+
+  const out2 = create()
+  const org2 = fromValues(1, 2)
+  const ret2 = copy(out2, org2)
+  t.true(compareVectors(out2, [1, 2]))
+  t.true(compareVectors(ret2, [1, 2]))
+  t.not(ret2, org2)
+  t.is(out2, ret2)
+
+  const out3 = create()
+  const org3 = fromValues(-1, -2)
+  const ret3 = copy(out3, org3)
+  t.true(compareVectors(out3, [-1, -2]))
+  t.true(compareVectors(ret3, [-1, -2]))
+  t.not(ret3, org3)
+  t.is(out3, ret3)
+})

package/src/maths/vec2/create.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default create
+
+declare function create(): Vec2

package/src/maths/vec2/create.js

@@ -0,0 +1,15 @@
+/**
+ * Represents a two dimensional vector.
+ * See fromValues().
+ * @typedef {Array} vec2
+ */
+
+/**
+ * Creates a new vector, initialized to [0,0].
+ *
+ * @returns {vec2} a new vector
+ * @alias module:modeling/maths/vec2.create
+ */
+const create = () => [0, 0]
+
+module.exports = create

package/src/maths/vec2/create.test.js

@@ -0,0 +1,10 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: create() should return a vec2 with initial values', (t) => {
+  const obs = create()
+  t.true(compareVectors(obs, [0, 0]))
+})

package/src/maths/vec2/cross.d.ts

@@ -0,0 +1,6 @@
+import Vec2 from './type'
+import Vec3 from '../vec3/type'
+
+export default cross
+
+declare function cross(out: Vec3, a: Vec2, b: Vec2): Vec3

package/src/maths/vec2/cross.js

@@ -0,0 +1,17 @@
+/**
+ * Computes the cross product (3D) of two vectors.
+ *
+ * @param {vec3} out - receiving vector (3D)
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {vec3} out
+ * @alias module:modeling/maths/vec2.cross
+ */
+const cross = (out, a, b) => {
+  out[0] = 0
+  out[1] = 0
+  out[2] = a[0] * b[1] - a[1] * b[0]
+  return out
+}
+
+module.exports = cross

package/src/maths/vec2/cross.test.js

@@ -0,0 +1,51 @@
+const test = require('ava')
+const { cross } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('vec2: cross() called with three parameters should update a vec2 with correct values', (t) => {
+  const obs1 = [0, 0, 0]
+  const ret1 = cross(obs1, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0, 0, 0]))
+  t.true(compareVectors(ret1, [0, 0, 0]))
+
+  const obs2 = [0, 0, 0]
+  const ret2 = cross(obs2, [5, 5], [10, 20])
+  t.true(compareVectors(obs2, [0, 0, 50]))
+  t.true(compareVectors(ret2, [0, 0, 50]))
+
+  const obs3 = [0, 0, 0]
+  const ret3 = cross(obs3, [5, 5], [10, -20])
+  t.true(compareVectors(obs3, [0, 0, -150]))
+  t.true(compareVectors(ret3, [0, 0, -150]))
+
+  const obs4 = [0, 0, 0]
+  const ret4 = cross(obs4, [5, 5], [-10, -20])
+  t.true(compareVectors(obs4, [0, 0, -50]))
+  t.true(compareVectors(ret4, [0, 0, -50]))
+
+  const obs5 = [0, 0, 0]
+  const ret5 = cross(obs5, [5, 5], [-10, 20])
+  t.true(compareVectors(obs5, [0, 0, 150]))
+  t.true(compareVectors(ret5, [0, 0, 150]))
+
+  const obs6 = [0, 0, 0]
+  const ret6 = cross(obs6, [5, 5], [10, 20])
+  t.true(compareVectors(obs6, [0, 0, 50]))
+  t.true(compareVectors(ret6, [0, 0, 50]))
+
+  const obs7 = [0, 0, 0]
+  const ret7 = cross(obs7, [5, 5], [10, -20])
+  t.true(compareVectors(obs7, [0, 0, -150]))
+  t.true(compareVectors(ret7, [0, 0, -150]))
+
+  const obs8 = [0, 0, 0]
+  const ret8 = cross(obs8, [5, 5], [-10, -20])
+  t.true(compareVectors(obs8, [0, 0, -50]))
+  t.true(compareVectors(ret8, [0, 0, -50]))
+
+  const obs9 = [0, 0, 0]
+  const ret9 = cross(obs9, [5, 5], [-10, 20])
+  t.true(compareVectors(obs9, [0, 0, 150]))
+  t.true(compareVectors(ret9, [0, 0, 150]))
+})

package/src/maths/vec2/distance.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from './type'
+
+export default distance
+
+declare function distance(a: Vec2, b: Vec2): number

package/src/maths/vec2/distance.js

@@ -0,0 +1,15 @@
+/**
+ * Calculates the distance between two vectors.
+ *
+ * @param {vec2} a - first operand
+ * @param {vec2} b - second operand
+ * @returns {Number} distance
+ * @alias module:modeling/maths/vec2.distance
+ */
+const distance = (a, b) => {
+  const x = b[0] - a[0]
+  const y = b[1] - a[1]
+  return Math.sqrt(x * x + y * y)
+}
+
+module.exports = distance