@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Vec2 from '../vec2/type'
+
+export default closestPoint
+
+declare function closestPoint(line: Line2, point: Vec2): Vec2

package/src/maths/line2/closestPoint.js

@@ -0,0 +1,25 @@
+const vec2 = require('../vec2')
+
+const direction = require('./direction')
+const origin = require('./origin')
+
+/**
+ * Determine the closest point on the given line to the given point.
+ *
+ * @param {line2} line - line of reference
+ * @param {vec2} point - point of reference
+ * @returns {vec2} closest point
+ * @alias module:modeling/maths/line2.closestPoint
+ */
+const closestPoint = (line, point) => {
+  const orig = origin(line)
+  const dir = direction(line)
+
+  const v = vec2.subtract(vec2.create(), point, orig)
+  const dist = vec2.dot(v, dir)
+  vec2.scale(v, dir, dist)
+  vec2.add(v, v, orig)
+  return v
+}
+
+module.exports = closestPoint

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

@@ -0,0 +1,48 @@
+const test = require('ava')
+const { closestPoint, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: closestPoint() should return proper values', (t) => {
+  const line1 = create()
+  const x1 = closestPoint(line1, [0, 0])
+  t.true(compareVectors(x1, [0, 0]))
+  const x2 = closestPoint(line1, [0, 1])
+  t.true(compareVectors(x2, [0, 0]))
+  // const x3 = closestPoint([6, 0], line1)
+  // t.true(compareVectors(x3, [6, -0])) // rounding errors
+
+  const line2 = fromPoints(create(), [-5, 5], [5, -5])
+  const x4 = closestPoint(line2, [0, 0])
+  t.true(compareVectors(x4, [0, 0]))
+  const x5 = closestPoint(line2, [1, 0])
+  t.true(compareVectors(x5, [0.5, -0.5]))
+  const x6 = closestPoint(line2, [2, 0])
+  t.true(compareVectors(x6, [1, -1]))
+  const x7 = closestPoint(line2, [3, 0])
+  t.true(compareVectors(x7, [1.5, -1.5]))
+  const x8 = closestPoint(line2, [4, 0])
+  t.true(compareVectors(x8, [2, -2]))
+  const x9 = closestPoint(line2, [5, 0])
+  t.true(compareVectors(x9, [2.5, -2.5]))
+  const x10 = closestPoint(line2, [50, 0])
+  t.true(compareVectors(x10, [25, -25]))
+
+  const ya = closestPoint(line2, [-5, 5])
+  t.true(compareVectors(ya, [-5, 5]))
+  const yb = closestPoint(line2, [5, -5])
+  t.true(compareVectors(yb, [5, -5]))
+
+  const za = closestPoint(line2, [4, -6])
+  t.true(compareVectors(za, [5, -5]))
+  const zb = closestPoint(line2, [3, -7])
+  t.true(compareVectors(zb, [5, -5]))
+
+  t.true(true)
+})
+
+test('line2: closestPoint() should return proper values (issue #1225)', (t) => {
+  const line = fromPoints(create(), [10, 0], [0, 10])
+  const closest = closestPoint(line, [0, 0])
+  t.true(compareVectors(closest, [5, 5]))
+})

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

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

package/src/maths/line2/copy.js

@@ -0,0 +1,16 @@
+/**
+ * Copy the given line to the receiving line.
+ *
+ * @param {line2} out - receiving line
+ * @param {line2} line - line to copy
+ * @returns {line2} out
+ * @alias module:modeling/maths/line2.copy
+ */
+const copy = (out, line) => {
+  out[0] = line[0]
+  out[1] = line[1]
+  out[2] = line[2]
+  return out
+}
+
+module.exports = copy

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

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

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

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

package/src/maths/line2/create.js

@@ -0,0 +1,20 @@
+/**
+ * Represents a unbounded line in 2D space, positioned at a point of origin.
+ * A line is parametrized by a normal vector (perpendicular to the line, rotated 90 degrees counter clockwise) and
+ * distance from the origin.
+ *
+ * Equation: A Point (P) is on Line (L) if dot(L.normal, P) == L.distance
+ *
+ * The contents of the array are a normal [0,1] and a distance [2].
+ * @typedef {Array} line2
+ */
+
+/**
+ * Create a line, positioned at 0,0, and running along the X axis.
+ *
+ * @returns {line2} a new unbounded line
+ * @alias module:modeling/maths/line2.create
+ */
+const create = () => [0, 1, 0] // normal and distance
+
+module.exports = create

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

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

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

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Vec2 from '../vec2/type'
+
+export default direction
+
+declare function direction(line: Line2): Vec2

package/src/maths/line2/direction.js

@@ -0,0 +1,16 @@
+const vec2 = require('../vec2')
+
+/**
+ * Return the direction of the given line.
+ *
+ * @param {line2} line - line of reference
+ * @return {vec2} a vector in the direction of the line
+ * @alias module:modeling/maths/line2.direction
+ */
+const direction = (line) => {
+  const vector = vec2.normal(vec2.create(), line)
+  vec2.negate(vector, vector)
+  return vector
+}
+
+module.exports = direction

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

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

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

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

package/src/maths/line2/distanceToPoint.js

@@ -0,0 +1,17 @@
+const vec2 = require('../vec2')
+
+/**
+ * Calculate the distance (positive) between the given point and line.
+ *
+ * @param {line2} line - line of reference
+ * @param {vec2} point - point of reference
+ * @return {Number} distance between line and point
+ * @alias module:modeling/maths/line2.distanceToPoint
+ */
+const distanceToPoint = (line, point) => {
+  let distance = vec2.dot(point, line)
+  distance = Math.abs(distance - line[2])
+  return distance
+}
+
+module.exports = distanceToPoint

package/src/maths/line2/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('line2: distanceToPoint() should return proper values', (t) => {
+  const line1 = create()
+  const dis1 = distanceToPoint(line1, [0, 0])
+  nearlyEqual(t, dis1, 0, EPS)
+  const dis2 = distanceToPoint(line1, [1, 0])
+  nearlyEqual(t, dis2, 0, EPS)
+  const dis3 = distanceToPoint(line1, [0, 1])
+  nearlyEqual(t, dis3, 1, EPS)
+
+  const line2 = fromPoints(create(), [-5, 4], [5, -6])
+  const dis4 = distanceToPoint(line2, [0, 0])
+  nearlyEqual(t, dis4, 0.7071067690849304, EPS)
+  const dis5 = distanceToPoint(line2, [1, 0])
+  nearlyEqual(t, dis5, 1.4142135381698608, EPS)
+  const dis6 = distanceToPoint(line2, [2, 0])
+  nearlyEqual(t, dis6, 2.1213203072547913, EPS)
+  const dis7 = distanceToPoint(line2, [3, 0])
+  nearlyEqual(t, dis7, 2.8284270763397217, EPS)
+  const dis8 = distanceToPoint(line2, [4, 0])
+  nearlyEqual(t, dis8, 3.535533845424652, EPS)
+  const dis9 = distanceToPoint(line2, [5, 0])
+  nearlyEqual(t, dis9, 4.2426406145095825, EPS)
+
+  t.true(true)
+})

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

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

package/src/maths/line2/equals.js

@@ -0,0 +1,11 @@
+/**
+ * Compare the given lines for equality.
+ *
+ * @param {line2} line1 - first line to compare
+ * @param {line2} line2 - second line to compare
+ * @return {Boolean} true if lines are equal
+ * @alias module:modeling/maths/line2.equals
+ */
+const equals = (line1, line2) => (line1[0] === line2[0]) && (line1[1] === line2[1] && (line1[2] === line2[2]))
+
+module.exports = equals

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

@@ -0,0 +1,26 @@
+const test = require('ava')
+const { equals, fromValues } = require('./index')
+
+test('line2: equals() should return correct booleans', (t) => {
+  const line0 = fromValues(0, 0, 0)
+  const line1 = fromValues(0, 0, 0)
+  t.true(equals(line0, line1))
+
+  const line2 = fromValues(1, 1, 1)
+  t.false(equals(line0, line2))
+
+  const line3 = fromValues(1, 1, 0)
+  t.false(equals(line0, line3))
+
+  const line4 = fromValues(0, 1, 1)
+  t.false(equals(line0, line4))
+
+  const line5 = fromValues(1, 0, 0)
+  t.false(equals(line0, line5))
+
+  const line6 = fromValues(0, 1, 0)
+  t.false(equals(line0, line6))
+
+  const line7 = fromValues(0, 0, 1)
+  t.false(equals(line0, line7))
+})

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

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Vec2 from '../vec2/type'
+
+export default fromPoints
+
+declare function fromPoints(out: Line2, point1: Vec2, point2: Vec2): Line2

package/src/maths/line2/fromPoints.js

@@ -0,0 +1,26 @@
+const vec2 = require('../vec2')
+
+/**
+ * Create a new line that passes through the given points.
+ *
+ * @param {line2} out - receiving line
+ * @param {vec2} point1 - start point of the line
+ * @param {vec2} point2 - end point of the line
+ * @returns {line2} a new unbounded line
+ * @alias module:modeling/maths/line2.fromPoints
+ */
+const fromPoints = (out, point1, point2) => {
+  const vector = vec2.subtract(vec2.create(), point2, point1) // directional vector
+
+  vec2.normal(vector, vector)
+  vec2.normalize(vector, vector) // normalized
+
+  const distance = vec2.dot(point1, vector)
+
+  out[0] = vector[0]
+  out[1] = vector[1]
+  out[2] = distance
+  return out
+}
+
+module.exports = fromPoints

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

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { fromPoints, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: fromPoints() should return a new line2 with correct values', (t) => {
+  const out = create()
+
+  const obs1 = fromPoints(out, [0, 0], [0, 0])
+  t.true(compareVectors(obs1, [0, 0, 0]))
+
+  const obs2 = fromPoints(out, [1, 0], [0, 1])
+  t.true(compareVectors(obs2, [-0.7071067811865476, -0.7071067811865475, -0.7071067811865476]))
+
+  const obs3 = fromPoints(out, [0, 1], [1, 0])
+  t.true(compareVectors(obs3, [0.7071067811865476, 0.7071067811865475, 0.7071067811865475]))
+
+  const obs4 = fromPoints(out, [0, 6], [6, 0])
+  t.true(compareVectors(obs4, [0.7071067811865476, 0.7071067811865476, 4.242640687119286]))
+
+  // line2 created from the same points results in an invalid line2
+  const obs9 = fromPoints(out, [0, 5], [0, 5])
+  t.true(compareVectors(obs9, [0, 0, 0]))
+})

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

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

package/src/maths/line2/fromValues.js

@@ -0,0 +1,20 @@
+const create = require('./create')
+
+/**
+ * Creates a new line initialized with the given values.
+ *
+ * @param {Number} x - X coordinate of the unit normal
+ * @param {Number} y - Y coordinate of the unit normal
+ * @param {Number} d - distance of the line from [0,0]
+ * @returns {line2} a new unbounded line
+ * @alias module:modeling/maths/line2.fromValues
+ */
+const fromValues = (x, y, d) => {
+  const out = create()
+  out[0] = x
+  out[1] = y
+  out[2] = d
+  return out
+}
+
+module.exports = fromValues

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

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: fromValues() should return a new line2 with correct values', (t) => {
+  const obs1 = fromValues(0, 0, 0)
+  t.true(compareVectors(obs1, [0, 0, 0]))
+
+  const obs2 = fromValues(0, 1, -5)
+  t.true(compareVectors(obs2, [0, 1, -5]))
+})

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

@@ -0,0 +1,18 @@
+export { default as clone } from './clone'
+export { default as closestPoint } from './closestPoint'
+export { default as copy } from './copy'
+export { default as create } from './create'
+export { default as direction } from './direction'
+export { default as distanceToPoint } from './distanceToPoint'
+export { default as equals } from './equals'
+export { default as fromPoints } from './fromPoints'
+export { default as fromValues } from './fromValues'
+export { default as intersectPointOfLines } from './intersectPointOfLines'
+export { default as origin } from './origin'
+export { default as reverse } from './reverse'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+export { default as xAtY } from './xAtY'
+
+export { default as Line2 } from './type'
+export as namespace line2

package/src/maths/line2/index.js

@@ -0,0 +1,22 @@
+/**
+ * Represents a unbounded line in 2D space, positioned at a point of origin.
+ * @see {@link line2} for data structure information.
+ * @module modeling/maths/line2
+ */
+module.exports = {
+  clone: require('./clone'),
+  closestPoint: require('./closestPoint'),
+  copy: require('./copy'),
+  create: require('./create'),
+  direction: require('./direction'),
+  distanceToPoint: require('./distanceToPoint'),
+  equals: require('./equals'),
+  fromPoints: require('./fromPoints'),
+  fromValues: require('./fromValues'),
+  intersectPointOfLines: require('./intersectPointOfLines'),
+  origin: require('./origin'),
+  reverse: require('./reverse'),
+  toString: require('./toString'),
+  transform: require('./transform'),
+  xAtY: require('./xAtY')
+}

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

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Vec2 from '../vec2/type'
+
+export default intersectPointOfLines
+
+declare function intersectPointOfLines(a: Line2, b: Line2): Vec2

package/src/maths/line2/intersectPointOfLines.js

@@ -0,0 +1,21 @@
+const vec2 = require('../vec2')
+const { solve2Linear } = require('../utils')
+
+/**
+ * Return the point of intersection between the given lines.
+ *
+ * NOTES:
+ * The point will have Infinity values if the lines are parallel.
+ * The point will have NaN values if the lines are the same.
+ *
+ * @param {line2} line1 - line of reference
+ * @param {line2} line2 - line of reference
+ * @return {vec2} the point of intersection
+ * @alias module:modeling/maths/line2.intersectPointOfLines
+ */
+const intersectToLine = (line1, line2) => {
+  const point = solve2Linear(line1[0], line1[1], line2[0], line2[1], line1[2], line2[2])
+  return vec2.clone(point)
+}
+
+module.exports = intersectToLine

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

@@ -0,0 +1,31 @@
+const test = require('ava')
+const { intersectPointOfLines, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: intersectPointOfLines() should return proper points', (t) => {
+  const line1 = create()
+
+  const line2 = fromPoints(create(), [1, 0], [0, 1])
+  const int2 = intersectPointOfLines(line1, line2)
+  t.true(compareVectors(int2, [1, 0]))
+
+  // same lines opposite directions
+  const line3 = fromPoints(create(), [0, 1], [1, 0])
+  const int3 = intersectPointOfLines(line3, line2)
+  t.true(compareVectors(int3, [NaN, NaN]))
+
+  // parallel lines
+  const line4 = fromPoints(create(), [0, 6], [6, 0])
+  const int4 = intersectPointOfLines(line4, line3)
+  t.true(compareVectors(int4, [Infinity, -Infinity]))
+
+  // intersecting lines
+  const line5 = fromPoints(create(), [0, -6], [6, 0])
+  const int5 = intersectPointOfLines(line5, line4)
+  t.true(compareVectors(int5, [6, 0], 1e-15))
+
+  const line6 = fromPoints(create(), [-6, 0], [0, -6])
+  const int6 = intersectPointOfLines(line6, line5)
+  t.true(compareVectors(int6, [0, -6], 1e-15))
+})

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

@@ -0,0 +1,6 @@
+import Line2 from './type'
+import Vec2 from '../vec2/type'
+
+export default origin
+
+declare function origin(line: Line2): Vec2

package/src/maths/line2/origin.js

@@ -0,0 +1,13 @@
+const vec2 = require('../vec2')
+
+/**
+ * Return the origin of the given line.
+ * The origin is the point on the line which is closest to the origin [0, 0].
+ *
+ * @param {line2} line - line of reference
+ * @return {vec2} the origin of the line
+ * @alias module:modeling/maths/line2.origin
+ */
+const origin = (line) => vec2.scale(vec2.create(), line, line[2])
+
+module.exports = origin

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

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { origin, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: origin() should return proper origins', (t) => {
+  const line1 = create()
+  const org1 = origin(line1)
+  t.true(compareVectors(org1, [0, 0]))
+
+  const line2 = fromPoints(create(), [1, 0], [0, 1])
+  const org2 = origin(line2)
+  t.true(compareVectors(org2, [0.5000000000000001, 0.5]))
+
+  const line3 = fromPoints(create(), [0, 1], [1, 0])
+  const org3 = origin(line3)
+  t.true(compareVectors(org3, [0.5, 0.4999999999999999]))
+
+  const line4 = fromPoints(create(), [0, 6], [6, 0])
+  const org4 = origin(line4)
+  t.true(compareVectors(org4, [3.0000000000000004, 3.0000000000000004]))
+
+  const line5 = fromPoints(create(), [-5, 5], [5, -5])
+  const org5 = origin(line5)
+  t.true(compareVectors(org5, [0, 0]))
+
+  const line6 = fromPoints(create(), [10, 0], [0, 10])
+  const org6 = origin(line6)
+  t.true(compareVectors(org6, [5, 5]))
+})

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

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

package/src/maths/line2/reverse.js

@@ -0,0 +1,20 @@
+const vec2 = require('../vec2')
+
+const copy = require('./copy')
+const fromValues = require('./fromValues')
+
+/**
+ * Create a new line in the opposite direction as the given.
+ *
+ * @param {line2} out - receiving line
+ * @param {line2} line - line to reverse
+ * @returns {line2} out
+ * @alias module:modeling/maths/line2.reverse
+ */
+const reverse = (out, line) => {
+  const normal = vec2.negate(vec2.create(), line)
+  const distance = -line[2]
+  return copy(out, fromValues(normal[0], normal[1], distance))
+}
+
+module.exports = reverse

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

@@ -0,0 +1,36 @@
+const test = require('ava')
+const { reverse, create, fromPoints } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('line2: reverse() called with two parameters should update a line2 with proper values', (t) => {
+  const line1 = create()
+  const obs1 = create()
+  const ret1 = reverse(obs1, line1)
+  t.true(compareVectors(ret1, [0, -1, 0]))
+  t.true(compareVectors(obs1, [0, -1, 0]))
+
+  const line2 = fromPoints(create(), [1, 0], [0, 1])
+  const obs2 = create()
+  const ret2 = reverse(obs2, line2)
+  t.true(compareVectors(ret2, [0.7071067811865476, 0.7071067811865475, 0.7071067811865476]))
+  t.true(compareVectors(obs2, [0.7071067811865476, 0.7071067811865475, 0.7071067811865476]))
+
+  const line3 = fromPoints(create(), [0, 1], [1, 0])
+  const obs3 = create()
+  const ret3 = reverse(obs3, line3)
+  t.true(compareVectors(ret3, [-0.7071067811865476, -0.7071067811865475, -0.7071067811865475]))
+  t.true(compareVectors(obs3, [-0.7071067811865476, -0.7071067811865475, -0.7071067811865475]))
+
+  const line4 = fromPoints(create(), [0, 6], [6, 0])
+  const obs4 = create()
+  const ret4 = reverse(obs4, line4)
+  t.true(compareVectors(ret4, [-0.7071067811865476, -0.7071067811865476, -4.242640687119286]))
+  t.true(compareVectors(obs4, [-0.7071067811865476, -0.7071067811865476, -4.242640687119286]))
+
+  const line5 = fromPoints(create(), [-5, 5], [5, -5])
+  const obs5 = create()
+  const ret5 = reverse(obs5, line5)
+  t.true(compareVectors(ret5, [-0.7071067811865475, -0.7071067811865475, -0]))
+  t.true(compareVectors(obs5, [-0.7071067811865475, -0.7071067811865475, -0]))
+})