@jbroll/jscad-modeling 2.12.7

package/src/maths/line2/toString.d.ts

@@ -0,0 +1,5 @@
+import Line2 from './type'
+
+export default toString
+
+declare function toString(line: Line2): string

package/src/maths/line2/toString.js

@@ -0,0 +1,10 @@
+/**
+ * Return a string representing the given line.
+ *
+ * @param {line2} line - line of reference
+ * @returns {String} string representation
+ * @alias module:modeling/maths/line2.toString
+ */
+const toString = (line) => `line2: (${line[0].toFixed(7)}, ${line[1].toFixed(7)}, ${line[2].toFixed(7)})`
+
+module.exports = toString

package/src/maths/line2/transform.d.ts

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Mat4 from '../mat4/type'
+
+export default transform
+
+declare function transform(out: Line2, line: Line2, matrix: Mat4): Line2

package/src/maths/line2/transform.js

@@ -0,0 +1,26 @@
+const vec2 = require('../vec2')
+
+const fromPoints = require('./fromPoints')
+const origin = require('./origin')
+const direction = require('./direction')
+
+/**
+ * Transforms the given line using the given matrix.
+ *
+ * @param {line2} out - receiving line
+ * @param {line2} line - line to transform
+ * @param {mat4} matrix - matrix to transform with
+ * @returns {line2} out
+ * @alias module:modeling/maths/line2.transform
+ */
+const transform = (out, line, matrix) => {
+  const org = origin(line)
+  const dir = direction(line)
+
+  vec2.transform(org, org, matrix)
+  vec2.transform(dir, dir, matrix)
+
+  return fromPoints(out, org, dir)
+}
+
+module.exports = transform

package/src/maths/line2/transform.test.js

@@ -0,0 +1,89 @@
+const test = require('ava')
+const { transform, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: transform() called with three parameters should update a line2 with correct values', (t) => {
+  const line1 = create()
+  const line2 = fromPoints(create(), [0, 0], [0, 1])
+  const line3 = fromPoints(create(), [-3, -3], [3, 3])
+
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const obs1 = create()
+  let ret1 = transform(obs1, line1, identityMatrix)
+  t.true(compareVectors(ret1, [0, 1, 0]))
+  t.true(compareVectors(obs1, [0, 1, 0]))
+  ret1 = transform(obs1, line2, identityMatrix)
+  t.true(compareVectors(ret1, [-1, 0, 0]))
+  t.true(compareVectors(obs1, [-1, 0, 0]))
+  ret1 = transform(obs1, line3, identityMatrix)
+  t.true(compareVectors(ret1, [-0.7071067811865476, 0.7071067811865476, 0]))
+  t.true(compareVectors(obs1, [-0.7071067811865476, 0.7071067811865476, 0]))
+
+  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
+  ]
+
+  const obs2 = create()
+  let ret2 = transform(obs2, line1, translationMatrix)
+  t.true(compareVectors(ret2, [0, 1, 5]))
+  t.true(compareVectors(obs2, [0, 1, 5]))
+  ret2 = transform(obs2, line2, translationMatrix)
+  t.true(compareVectors(ret2, [-1, 0, -1]))
+  t.true(compareVectors(obs2, [-1, 0, -1]))
+  ret2 = transform(obs2, line3, translationMatrix)
+  t.true(compareVectors(ret2, [-0.7071067811865478, 0.7071067811865474, 2.828427124746189]))
+  t.true(compareVectors(obs2, [-0.7071067811865478, 0.7071067811865474, 2.828427124746189]))
+
+  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
+  ]
+
+  const obs3 = create()
+  let ret3 = transform(obs3, line1, scaleMatrix)
+  t.true(compareVectors(ret3, [0, 1, 0]))
+  t.true(compareVectors(obs3, [0, 1, 0]))
+  ret3 = transform(obs3, line2, scaleMatrix)
+  t.true(compareVectors(ret3, [-1, 0, 0]))
+  t.true(compareVectors(obs3, [-1, 0, 0]))
+  ret3 = transform(obs3, line3, scaleMatrix)
+  t.true(compareVectors(ret3, [-0.9486832980505139, 0.316227766016838, 0]))
+  t.true(compareVectors(obs3, [-0.9486832980505139, 0.316227766016838, 0]))
+
+  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
+  ]
+
+  const obs4 = create()
+  let ret4 = transform(obs4, line1, rotateZMatrix)
+  t.true(compareVectors(ret4, [-1, 0, 0]))
+  t.true(compareVectors(obs4, [-1, 0, 0]))
+  ret4 = transform(obs4, line2, rotateZMatrix)
+  t.true(compareVectors(ret4, [0, -1, 0]))
+  t.true(compareVectors(obs4, [0, -1, 0]))
+  ret4 = transform(obs4, line3, rotateZMatrix)
+  t.true(compareVectors(ret4, [-0.7071067811865476, -0.7071067811865476, -0]))
+  t.true(compareVectors(obs4, [-0.7071067811865476, -0.7071067811865476, -0]))
+})

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

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

package/src/maths/line2/xAtY.d.ts

@@ -0,0 +1,5 @@
+import Line2 from './type'
+
+export default xAtY
+
+declare function xAtY(line: Line2, y: number): number

package/src/maths/line2/xAtY.js

@@ -0,0 +1,22 @@
+const origin = require('./origin')
+
+/**
+ * Determine the X coordinate of the given line at the Y coordinate.
+ *
+ * The X coordinate will be Infinity if the line is parallel to the X axis.
+ *
+ * @param {line2} line - line of reference
+ * @param {Number} y - Y coordinate on the line
+ * @return {Number} the X coordinate on the line
+ * @alias module:modeling/maths/line2.xAtY
+ */
+const xAtY = (line, y) => {
+  let x = (line[2] - (line[1] * y)) / line[0]
+  if (Number.isNaN(x)) {
+    const org = origin(line)
+    x = org[0]
+  }
+  return x
+}
+
+module.exports = xAtY

package/src/maths/line2/xAtY.test.js

@@ -0,0 +1,39 @@
+const test = require('ava')
+const { xAtY, create, fromPoints } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('line2: xAtY() should return proper values', (t) => {
+  const line1 = create()
+
+  const x1 = xAtY(line1, 0)
+  nearlyEqual(t, x1, 0, EPS)
+
+  const x2 = xAtY(line1, 6)
+  t.false(Number.isFinite(x2)) // X is infinite, as the line is parallel to X-axis
+
+  const x3 = xAtY(line1, -6)
+  t.false(Number.isFinite(x3)) // X is infinite, as the line is parallel to X-axis
+
+  const line2 = fromPoints(create(), [-5, 4], [5, -6])
+  const y1 = xAtY(line2, 0)
+  nearlyEqual(t, y1, -1, EPS)
+
+  const y2 = xAtY(line2, 1)
+  nearlyEqual(t, y2, -2, EPS)
+
+  const y3 = xAtY(line2, 2)
+  nearlyEqual(t, y3, -3, EPS)
+
+  const y4 = xAtY(line2, -1)
+  nearlyEqual(t, y4, 0, EPS)
+
+  const y5 = xAtY(line2, -2)
+  nearlyEqual(t, y5, 1, EPS)
+
+  const y6 = xAtY(line2, -3)
+  nearlyEqual(t, y6, 2, EPS)
+
+  t.true(true)
+})

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

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

package/src/maths/line3/clone.js

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

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

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

package/src/maths/line3/closestPoint.d.ts

@@ -0,0 +1,6 @@
+import Line3 from './type'
+import Vec3 from '../vec3/type'
+
+export default closestPoint
+
+declare function closestPoint(line: Line3, point: Vec3): Vec3

package/src/maths/line3/closestPoint.js

@@ -0,0 +1,24 @@
+const vec3 = require('../vec3')
+
+/**
+ * Determine the closest point on the given line to the given point.
+ *
+ * @param {line3} line - line of reference
+ * @param {vec3} point - point of reference
+ * @returns {vec3} a point
+ * @alias module:modeling/maths/line3.closestPoint
+ */
+const closestPoint = (line, point) => {
+  const lpoint = line[0]
+  const ldirection = line[1]
+
+  const a = vec3.dot(vec3.subtract(vec3.create(), point, lpoint), ldirection)
+  const b = vec3.dot(ldirection, ldirection)
+  const t = a / b
+
+  const closestpoint = vec3.scale(vec3.create(), ldirection, t)
+  vec3.add(closestpoint, closestpoint, lpoint)
+  return closestpoint
+}
+
+module.exports = closestPoint

package/src/maths/line3/closestPoint.test.js

@@ -0,0 +1,37 @@
+const test = require('ava')
+const { closestPoint, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line3: closestPoint() should return proper values', (t) => {
+  const line1 = create() // line follows X axis
+  const x1 = closestPoint(line1, [0, 0, 0])
+  t.true(compareVectors(x1, [0, 0, 0]))
+  const x2 = closestPoint(line1, [0, 1, 0])
+  t.true(compareVectors(x2, [0, 0, 0]))
+  const x3 = closestPoint(line1, [6, 0, 0])
+  t.true(compareVectors(x3, [0, 0, 0])) // rounding errors
+
+  const line2 = fromPoints(create(), [-5, -5, -5], [5, 5, 5])
+  const x4 = closestPoint(line2, [0, 0, 0])
+  t.true(compareVectors(x4, [0.000000000000, 0.000000000000, 0.00000000000]))
+  const x5 = closestPoint(line2, [1, 0, 0])
+  t.true(compareVectors(x5, [0.3333333333333339, 0.3333333333333339, 0.3333333333333339]))
+  const x6 = closestPoint(line2, [2, 0, 0])
+  t.true(compareVectors(x6, [0.6666666666666661, 0.6666666666666661, 0.6666666666666661]))
+  const x7 = closestPoint(line2, [3, 0, 0])
+  t.true(compareVectors(x7, [1, 1, 1]))
+  const x8 = closestPoint(line2, [4, 0, 0])
+  t.true(compareVectors(x8, [1.3333333333333348, 1.3333333333333348, 1.3333333333333348]))
+  const x9 = closestPoint(line2, [5, 0, 0])
+  t.true(compareVectors(x9, [1.666666666666667, 1.666666666666667, 1.666666666666667]))
+  const x10 = closestPoint(line2, [50, 0, 0])
+  t.true(compareVectors(x10, [16.666666666666668, 16.666666666666668, 16.666666666666668]))
+
+  const ya = closestPoint(line2, [-5, -5, -5])
+  t.true(compareVectors(ya, [-5, -5, -5]))
+  const yb = closestPoint(line2, [5, 5, 5])
+  t.true(compareVectors(yb, [5, 5, 5]))
+
+  t.true(true)
+})

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

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

package/src/maths/line3/copy.js

@@ -0,0 +1,17 @@
+const vec3 = require('../vec3')
+
+/**
+ * Copy the given line into the receiving line.
+ *
+ * @param {line3} out - receiving line
+ * @param {line3} line - line to copy
+ * @returns {line3} out
+ * @alias module:modeling/maths/line3.copy
+ */
+const copy = (out, line) => {
+  vec3.copy(out[0], line[0])
+  vec3.copy(out[1], line[1])
+  return out
+}
+
+module.exports = copy

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

@@ -0,0 +1,33 @@
+const test = require('ava')
+const { create, copy, fromPointAndDirection } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line3: copy() with two params should update a line3 with same values', (t) => {
+  const line1 = create()
+  const org1 = fromPointAndDirection(create(), [0, 0, 0], [1, 0, 0])
+  const ret1 = copy(line1, org1)
+  t.true(compareVectors(line1[0], [0, 0, 0]))
+  t.true(compareVectors(line1[1], [1, 0, 0]))
+  t.true(compareVectors(ret1[0], [0, 0, 0]))
+  t.true(compareVectors(ret1[1], [1, 0, 0]))
+  t.not(ret1, org1)
+
+  const line2 = create()
+  const org2 = fromPointAndDirection(create(), [1, 2, 3], [1, 0, 1])
+  const ret2 = copy(line2, org2)
+  t.true(compareVectors(line2[0], [1, 2, 3]))
+  t.true(compareVectors(line2[1], [0.7071067811865475, 0, 0.7071067811865475]))
+  t.true(compareVectors(ret2[0], [1, 2, 3]))
+  t.true(compareVectors(ret2[1], [0.7071067811865475, 0, 0.7071067811865475]))
+  t.not(ret2, org2)
+
+  const line3 = create()
+  const org3 = fromPointAndDirection(create(), [-1, -2, -3], [0, -1, -1])
+  const ret3 = copy(line3, org3)
+  t.true(compareVectors(line3[0], [-1, -2, -3]))
+  t.true(compareVectors(line3[1], [0, -0.7071067811865475, -0.7071067811865475]))
+  t.true(compareVectors(ret3[0], [-1, -2, -3]))
+  t.true(compareVectors(ret3[1], [0, -0.7071067811865475, -0.7071067811865475]))
+  t.not(ret3, org3)
+})

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

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

package/src/maths/line3/create.js

@@ -0,0 +1,23 @@
+const vec3 = require('../vec3')
+
+/**
+ * Represents a unbounded line in 3D space, positioned at a point of origin.
+ * A line is parametrized by a point of origin and a directional vector.
+ *
+ * The array contents are two 3D vectors; origin [0,0,0] and directional vector [0,0,1].
+ * @see https://en.wikipedia.org/wiki/Hesse_normal_form
+ * @typedef {Array} line3
+ */
+
+/**
+ * Create a line, positioned at 0,0,0 and lying on the X axis.
+ *
+ * @returns {line3} a new unbounded line
+ * @alias module:modeling/maths/line3.create
+ */
+const create = () => [
+  vec3.fromValues(0, 0, 0), // origin
+  vec3.fromValues(0, 0, 1) // direction
+]
+
+module.exports = create

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

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

package/src/maths/line3/direction.d.ts

@@ -0,0 +1,6 @@
+import Line3 from './type'
+import Vec3 from '../vec3/type'
+
+export default direction
+
+declare function direction(line: Line3): Vec3

package/src/maths/line3/direction.js

@@ -0,0 +1,10 @@
+/**
+ * Return the direction of the given line.
+ *
+ * @param {line3} line - line for reference
+ * @return {vec3} the relative vector in the direction of the line
+ * @alias module:modeling/maths/line3.direction
+ */
+const direction = (line) => line[1]
+
+module.exports = direction

package/src/maths/line3/direction.test.js

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { direction, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line3: direction() should return proper direction', (t) => {
+  const line1 = create()
+  const dir1 = direction(line1)
+  t.true(compareVectors(dir1, [0, 0, 1]))
+
+  const line2 = fromPoints(line1, [1, 0, 0], [0, 1, 0])
+  const dir2 = direction(line2)
+  t.true(compareVectors(dir2, [-0.7071067811865475, 0.7071067811865475, 0]))
+
+  const line3 = fromPoints(line1, [0, 1, 0], [1, 0, 0])
+  const dir3 = direction(line3)
+  t.true(compareVectors(dir3, [0.7071067811865475, -0.7071067811865475, 0]))
+
+  const line4 = fromPoints(line1, [0, 0, 1], [0, 0, -6])
+  const dir4 = direction(line4)
+  t.true(compareVectors(dir4, [0, 0, -1]))
+
+  const line5 = fromPoints(line1, [-5, -5, -5], [5, 5, 5])
+  const dir5 = direction(line5)
+  t.true(compareVectors(dir5, [0.5773502691896258, 0.5773502691896258, 0.5773502691896258]))
+})

package/src/maths/line3/distanceToPoint.d.ts

@@ -0,0 +1,6 @@
+import Line3 from './type'
+import Vec3 from '../vec3/type'
+
+export default distanceToPoint
+
+declare function distanceToPoint(line: Line3, point: Vec3): number

package/src/maths/line3/distanceToPoint.js

@@ -0,0 +1,19 @@
+const vec3 = require('../vec3')
+
+const closestPoint = require('./closestPoint')
+
+/**
+ * Calculate the distance (positive) between the given point and line.
+ *
+ * @param {line3} line - line of reference
+ * @param {vec3} point - point of reference
+ * @return {Number} distance between line and point
+ * @alias module:modeling/maths/line3.distanceToPoint
+ */
+const distanceToPoint = (line, point) => {
+  const closest = closestPoint(line, point)
+  const distancevector = vec3.subtract(vec3.create(), point, closest)
+  return vec3.length(distancevector)
+}
+
+module.exports = distanceToPoint

package/src/maths/line3/distanceToPoint.test.js

@@ -0,0 +1,31 @@
+const test = require('ava')
+const { distanceToPoint, create, fromPoints } = require('./index')
+
+const { nearlyEqual } = require('../../../test/helpers/index')
+const { EPS } = require('../constants')
+
+test('line3: distanceToPoint() should return proper values', (t) => {
+  const line1 = create()
+  const dis1 = distanceToPoint(line1, [0, 0, 0])
+  nearlyEqual(t, dis1, 0, EPS)
+  const dis2 = distanceToPoint(line1, [1, 0, 0])
+  nearlyEqual(t, dis2, 1, EPS)
+  const dis3 = distanceToPoint(line1, [0, 1, 0])
+  nearlyEqual(t, dis3, 1, EPS)
+
+  const line2 = fromPoints(create(), [-5, -5, -4], [5, 5, 6])
+  const dis4 = distanceToPoint(line2, [0, 0, 0])
+  nearlyEqual(t, dis4, 0.8164965809277724, EPS)
+  const dis5 = distanceToPoint(line2, [1, 0, 0])
+  nearlyEqual(t, dis5, 1.4142135381698608, EPS)
+  const dis6 = distanceToPoint(line2, [2, 0, 0])
+  nearlyEqual(t, dis6, 2.1602468994693043, EPS)
+  const dis7 = distanceToPoint(line2, [3, 0, 0])
+  nearlyEqual(t, dis7, 2.9439202887759617, EPS)
+  const dis8 = distanceToPoint(line2, [4, 0, 0])
+  nearlyEqual(t, dis8, 3.7416573867739413, EPS)
+  const dis9 = distanceToPoint(line2, [5, 0, 0])
+  nearlyEqual(t, dis9, 4.546060565661961, EPS)
+
+  t.true(true)
+})

package/src/maths/line3/equals.d.ts

@@ -0,0 +1,5 @@
+import Line3 from './type'
+
+export default equals
+
+declare function equals(a: Line3, b: Line3): boolean

package/src/maths/line3/equals.js

@@ -0,0 +1,25 @@
+const vec3 = require('../vec3')
+
+/**
+ * Compare the given lines for equality.
+ *
+ * @param {line3} line1 - first line to compare
+ * @param {line3} line2 - second line to compare
+ * @return {Boolean} true if lines are equal
+ * @alias module:modeling/maths/line3.equals
+ */
+const equals = (line1, line2) => {
+  // compare directions (unit vectors)
+  if (!vec3.equals(line1[1], line2[1])) return false
+
+  // compare points
+  if (!vec3.equals(line1[0], line2[0])) return false
+
+  // why would lines with the same slope (direction) and different points be equal?
+  // let distance = distanceToPoint(line1, line2[0])
+  // if (distance > EPS) return false
+
+  return true
+}
+
+module.exports = equals

package/src/maths/line3/equals.test.js

@@ -0,0 +1,17 @@
+const test = require('ava')
+const { equals, fromPointAndDirection, create } = require('./index')
+
+test('line3: equals() should return correct booleans', (t) => {
+  const line0 = fromPointAndDirection(create(), [0, 0, 0], [1, 1, 1])
+  const line1 = fromPointAndDirection(create(), [0, 0, 0], [1, 1, 1])
+  t.true(equals(line0, line1))
+
+  const line2 = fromPointAndDirection(create(), [0, 0, 0], [0, 1, 0])
+  t.false(equals(line0, line2))
+
+  const line3 = fromPointAndDirection(create(), [1, 0, 1], [0, 0, 0])
+  t.false(equals(line0, line3))
+
+  const line4 = fromPointAndDirection(create(), [1, 1, 1], [1, 1, 1])
+  t.false(equals(line0, line4))
+})

package/src/maths/line3/fromPlanes.d.ts

@@ -0,0 +1,6 @@
+import Line3 from './type'
+import Plane from '../plane/type'
+
+export default fromPlanes
+
+declare function fromPlanes(out: Line3, a: Plane, b: Plane): Line3

package/src/maths/line3/fromPlanes.js

@@ -0,0 +1,47 @@
+const vec3 = require('../vec3')
+const { solve2Linear } = require('../utils')
+
+const { EPS } = require('../constants')
+
+const fromPointAndDirection = require('./fromPointAndDirection')
+
+/**
+ * Create a line the intersection of the given planes.
+ *
+ * @param {line3} out - receiving line
+ * @param {plane} plane1 - first plane of reference
+ * @param {plane} plane2 - second plane of reference
+ * @returns {line3} out
+ * @alias module:modeling/maths/line3.fromPlanes
+ */
+const fromPlanes = (out, plane1, plane2) => {
+  let direction = vec3.cross(vec3.create(), plane1, plane2)
+  let length = vec3.length(direction)
+  if (length < EPS) {
+    throw new Error('parallel planes do not intersect')
+  }
+  length = (1.0 / length)
+  direction = vec3.scale(direction, direction, length)
+
+  const absx = Math.abs(direction[0])
+  const absy = Math.abs(direction[1])
+  const absz = Math.abs(direction[2])
+  let origin
+  let r
+  if ((absx >= absy) && (absx >= absz)) {
+    // find a point p for which x is zero
+    r = solve2Linear(plane1[1], plane1[2], plane2[1], plane2[2], plane1[3], plane2[3])
+    origin = vec3.fromValues(0, r[0], r[1])
+  } else if ((absy >= absx) && (absy >= absz)) {
+    // find a point p for which y is zero
+    r = solve2Linear(plane1[0], plane1[2], plane2[0], plane2[2], plane1[3], plane2[3])
+    origin = vec3.fromValues(r[0], 0, r[1])
+  } else {
+    // find a point p for which z is zero
+    r = solve2Linear(plane1[0], plane1[1], plane2[0], plane2[1], plane1[3], plane2[3])
+    origin = vec3.fromValues(r[0], r[1], 0)
+  }
+  return fromPointAndDirection(out, origin, direction)
+}
+
+module.exports = fromPlanes