@jbroll/jscad-modeling 2.12.7

package/src/maths/mat4/fromVectorRotation.test.js

@@ -0,0 +1,127 @@
+const test = require('ava')
+
+const vec3 = require('../vec3')
+
+const create = require('./create')
+const fromVectorRotation = require('./fromVectorRotation')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromVectorRotation() called with out parameter should return a mat4 with correct values', (t) => {
+  // unit vectors, same directions
+  const out = create()
+  let ret = fromVectorRotation(out, [1, 0, 0], [1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 1, 0], [0, 1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, 1], [0, 0, 1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  // unit vectors, axis rotations
+  ret = fromVectorRotation(out, [1, 0, 0], [0, 1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [1, 0, 0], [0, 0, 1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 1, 0], [1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 1, 0], [0, 0, 1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, 1], [1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, 1], [0, 1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [-1, 0, 0], [0, -1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [-1, 0, 0], [0, 0, -1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, -1, 0], [-1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, -1, 0], [0, 0, -1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, -1], [-1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, -1], [0, -1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+
+  // unit vector, opposite directions
+  ret = fromVectorRotation(out, [1, 0, 0], [-1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [-1, 0, 0], [1, 0, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 1, 0], [0, -1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, -1, 0], [0, 1, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, 1], [0, 0, -1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, -1], [0, 0, 1])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+
+  // different units
+  ret = fromVectorRotation(out, [11, 0, 0], [0, 33, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0.11, 0], [0, 0, 0.33])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+
+  ret = fromVectorRotation(out, [0, 0, 111111.0], [0, 0.33, 0])
+  t.is(ret, out)
+  t.true(compareVectors(out, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+
+  // different quadrants
+  ret = fromVectorRotation(out, [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0.3333333333333334, 0.6666666666666669, 0.6666666666666669, 0, -0.6666666666666669, 0.666666666666667, -0.3333333333333335, 0, -0.6666666666666669, -0.3333333333333335, 0.666666666666667, 0, 0, 0, 0, 1]))
+  t.true(compareVectors([-0.5, 0.5, 0.5], vec3.transform(vec3.create(), [0.5, 0.5, 0.5], ret)))
+
+  ret = fromVectorRotation(out, [5, 5, 5], [5, 5, -5])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0.6666666666666666, -0.3333333333333333, -0.6666666666666666, 0, -0.3333333333333333, 0.6666666666666666, -0.6666666666666666, 0, 0.6666666666666666, 0.6666666666666666, 0.3333333333333333, 0, 0, 0, 0, 1]))
+  t.true(compareVectors([5, 5, -5], vec3.transform(vec3.create(), [5, 5, 5], ret)))
+
+  ret = fromVectorRotation(out, [5, 5, 5], [-5, -5, -5])
+  t.is(ret, out)
+  t.true(compareVectors(out, [0, -1, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors([-5, -5, -5], vec3.transform(vec3.create(), [5, 5, 5], ret)))
+})

package/src/maths/mat4/fromXRotation.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default fromXRotation
+
+declare function fromXRotation(out: Mat4, radians: number): Mat4

package/src/maths/mat4/fromXRotation.js

@@ -0,0 +1,41 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Creates a matrix from the given angle around the X axis.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.rotateX(dest, dest, radians)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {Number} radians - angle to rotate the matrix by
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromXRotation
+ * @example
+ * let matrix = fromXRotation(create(), TAU / 4)
+ */
+const fromXRotation = (out, radians) => {
+  const s = sin(radians)
+  const c = cos(radians)
+
+  // Perform axis-specific matrix multiplication
+  out[0] = 1
+  out[1] = 0
+  out[2] = 0
+  out[3] = 0
+  out[4] = 0
+  out[5] = c
+  out[6] = s
+  out[7] = 0
+  out[8] = 0
+  out[9] = -s
+  out[10] = c
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromXRotation

package/src/maths/mat4/fromXRotation.test.js

@@ -0,0 +1,14 @@
+const test = require('ava')
+const { fromXRotation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromXRotation() should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const obs2 = fromXRotation(create(), rotation)
+  t.true(compareVectors(obs2, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+
+  const obs3 = fromXRotation(obs2, -rotation)
+  t.true(compareVectors(obs3, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/fromYRotation.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default fromYRotation
+
+declare function fromYRotation(out: Mat4, radians: number): Mat4

package/src/maths/mat4/fromYRotation.js

@@ -0,0 +1,41 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Creates a matrix from the given angle around the Y axis.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.rotateY(dest, dest, radians)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {Number} radians - angle to rotate the matrix by
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromYRotation
+ * @example
+ * let matrix = fromYRotation(create(), TAU / 4)
+ */
+const fromYRotation = (out, radians) => {
+  const s = sin(radians)
+  const c = cos(radians)
+
+  // Perform axis-specific matrix multiplication
+  out[0] = c
+  out[1] = 0
+  out[2] = -s
+  out[3] = 0
+  out[4] = 0
+  out[5] = 1
+  out[6] = 0
+  out[7] = 0
+  out[8] = s
+  out[9] = 0
+  out[10] = c
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromYRotation

package/src/maths/mat4/fromYRotation.test.js

@@ -0,0 +1,14 @@
+const test = require('ava')
+const { fromYRotation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromYRotation() should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const obs2 = fromYRotation(create(), rotation)
+  t.true(compareVectors(obs2, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+
+  const obs3 = fromYRotation(obs2, -rotation)
+  t.true(compareVectors(obs3, [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/fromZRotation.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default fromZRotation
+
+declare function fromZRotation(out: Mat4, radians: number): Mat4

package/src/maths/mat4/fromZRotation.js

@@ -0,0 +1,41 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Creates a matrix from the given angle around the Z axis.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.rotateZ(dest, dest, radians)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {Number} radians - angle to rotate the matrix by
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromZRotation
+ * @example
+ * let matrix = fromZRotation(create(), TAU / 4)
+ */
+const fromZRotation = (out, radians) => {
+  const s = sin(radians)
+  const c = cos(radians)
+
+  // Perform axis-specific matrix multiplication
+  out[0] = c
+  out[1] = s
+  out[2] = 0
+  out[3] = 0
+  out[4] = -s
+  out[5] = c
+  out[6] = 0
+  out[7] = 0
+  out[8] = 0
+  out[9] = 0
+  out[10] = 1
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromZRotation

package/src/maths/mat4/fromZRotation.test.js

@@ -0,0 +1,14 @@
+const test = require('ava')
+const { fromZRotation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromZRotation() should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const obs2 = fromZRotation(create(), rotation)
+  t.true(compareVectors(obs2, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const obs3 = fromZRotation(obs2, -rotation)
+  t.true(compareVectors(obs3, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/identity.d.ts

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

package/src/maths/mat4/identity.js

@@ -0,0 +1,28 @@
+/**
+ * Set a matrix to the identity transform.
+ *
+ * @param {mat4} out - receiving matrix
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.identity
+ */
+const identity = (out) => {
+  out[0] = 1
+  out[1] = 0
+  out[2] = 0
+  out[3] = 0
+  out[4] = 0
+  out[5] = 1
+  out[6] = 0
+  out[7] = 0
+  out[8] = 0
+  out[9] = 0
+  out[10] = 1
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = identity

package/src/maths/mat4/identity.test.js

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { identity } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: identity() called with one parameters should update a mat4 with correct values', (t) => {
+  const obs1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret1 = identity(obs1)
+  t.true(compareVectors(obs1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.is(obs1, ret1)
+})

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

@@ -0,0 +1,29 @@
+export { default as add } from './add'
+export { default as clone } from './clone'
+export { default as copy } from './copy'
+export { default as create } from './create'
+export { default as equals } from './equals'
+export { default as fromRotation } from './fromRotation'
+export { default as fromScaling } from './fromScaling'
+export { default as fromTaitBryanRotation } from './fromTaitBryanRotation'
+export { default as fromTranslation } from './fromTranslation'
+export { default as fromValues } from './fromValues'
+export { default as fromXRotation } from './fromXRotation'
+export { default as fromYRotation } from './fromYRotation'
+export { default as fromZRotation } from './fromZRotation'
+export { default as identity } from './identity'
+export { default as isIdentity } from './isIdentity'
+export { default as isMirroring } from './isMirroring'
+export { default as mirrorByPlane } from './mirrorByPlane'
+export { default as multiply } from './multiply'
+export { default as rotate } from './rotate'
+export { default as rotateX } from './rotateX'
+export { default as rotateY } from './rotateY'
+export { default as rotateZ } from './rotateZ'
+export { default as scale } from './scale'
+export { default as subtract } from './subtract'
+export { default as toString } from './toString'
+export { default as translate } from './translate'
+
+export { default as Mat4 } from './type'
+export as namespace mat4

package/src/maths/mat4/index.js

@@ -0,0 +1,36 @@
+/**
+ * Represents a 4x4 matrix which is column-major (when typed out it looks row-major).
+ * @see {@link mat4} for data structure information.
+ * @module modeling/maths/mat4
+ */
+module.exports = {
+  add: require('./add'),
+  clone: require('./clone'),
+  copy: require('./copy'),
+  create: require('./create'),
+  invert: require('./invert'),
+  equals: require('./equals'),
+  fromRotation: require('./fromRotation'),
+  fromScaling: require('./fromScaling'),
+  fromTaitBryanRotation: require('./fromTaitBryanRotation'),
+  fromTranslation: require('./fromTranslation'),
+  fromValues: require('./fromValues'),
+  fromVectorRotation: require('./fromVectorRotation'),
+  fromXRotation: require('./fromXRotation'),
+  fromYRotation: require('./fromYRotation'),
+  fromZRotation: require('./fromZRotation'),
+  identity: require('./identity'),
+  isIdentity: require('./isIdentity'),
+  isOnlyTransformScale: require('./isOnlyTransformScale'),
+  isMirroring: require('./isMirroring'),
+  mirrorByPlane: require('./mirrorByPlane'),
+  multiply: require('./multiply'),
+  rotate: require('./rotate'),
+  rotateX: require('./rotateX'),
+  rotateY: require('./rotateY'),
+  rotateZ: require('./rotateZ'),
+  scale: require('./scale'),
+  subtract: require('./subtract'),
+  toString: require('./toString'),
+  translate: require('./translate')
+}

package/src/maths/mat4/invert.js

@@ -0,0 +1,71 @@
+/**
+ * Creates a invert copy of the given matrix.
+ * @author Julian Lloyd
+ * code from https://github.com/jlmakes/rematrix/blob/master/src/index.js
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} matrix - matrix to invert
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.invert
+ */
+const invert = (out, matrix) => {
+  const a00 = matrix[0]
+  const a01 = matrix[1]
+  const a02 = matrix[2]
+  const a03 = matrix[3]
+  const a10 = matrix[4]
+  const a11 = matrix[5]
+  const a12 = matrix[6]
+  const a13 = matrix[7]
+  const a20 = matrix[8]
+  const a21 = matrix[9]
+  const a22 = matrix[10]
+  const a23 = matrix[11]
+  const a30 = matrix[12]
+  const a31 = matrix[13]
+  const a32 = matrix[14]
+  const a33 = matrix[15]
+
+  const b00 = a00 * a11 - a01 * a10
+  const b01 = a00 * a12 - a02 * a10
+  const b02 = a00 * a13 - a03 * a10
+  const b03 = a01 * a12 - a02 * a11
+  const b04 = a01 * a13 - a03 * a11
+  const b05 = a02 * a13 - a03 * a12
+  const b06 = a20 * a31 - a21 * a30
+  const b07 = a20 * a32 - a22 * a30
+  const b08 = a20 * a33 - a23 * a30
+  const b09 = a21 * a32 - a22 * a31
+  const b10 = a21 * a33 - a23 * a31
+  const b11 = a22 * a33 - a23 * a32
+
+  // Calculate the determinant
+  let det =
+    b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06
+
+  if (!det) {
+    return null
+  }
+  det = 1.0 / det
+
+  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det
+  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det
+  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det
+  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det
+  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det
+  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det
+  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det
+  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det
+  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det
+  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det
+  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det
+  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det
+  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det
+  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det
+  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det
+  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det
+
+  return out
+}
+
+module.exports = invert

package/src/maths/mat4/invert.test.js

@@ -0,0 +1,32 @@
+const test = require('ava')
+
+const { TAU } = require('../constants')
+const vec3 = require('../vec3/index')
+
+const { create, invert, fromTranslation, fromXRotation } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: invert() translate ', (t) => {
+  const matrix = fromTranslation(create(), [10, 10, 0])
+  const matrixInv = invert(create(), matrix)
+
+  const vec1 = [0, 0, 0]
+  const vec2 = vec3.transform([0, 0, 0], vec1, matrix)
+  t.true(compareVectors(vec2, [10, 10, 0]))
+
+  const vec2back = vec3.transform([0, 0, 0], vec2, matrixInv)
+  t.true(compareVectors(vec2back, vec1))
+})
+
+test('mat4: invert() rotate ', (t) => {
+  const matrix = fromXRotation(create(), TAU / 4)
+  const matrixInv = invert(create(), matrix)
+
+  const vec1 = [10, 10, 10]
+  const vec2 = vec3.transform([0, 0, 0], vec1, matrix)
+  t.true(compareVectors(vec2, [10, -10, 10]))
+
+  const vec2back = vec3.transform([0, 0, 0], vec2, matrixInv)
+  t.true(compareVectors(vec2back, vec1))
+})

package/src/maths/mat4/isIdentity.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default isIdentity
+
+declare function isIdentity(matrix: Mat4): boolean

package/src/maths/mat4/isIdentity.js

@@ -0,0 +1,20 @@
+/**
+ * Determine whether the given matrix is the identity transform.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.equals(mat4.create(), matrix)
+ *
+ * @param {mat4} matrix - the matrix
+ * @returns {Boolean} true if matrix is the identity transform
+ * @alias module:modeling/maths/mat4.isIdentity
+ * @example
+ * if (mat4.isIdentity(mymatrix)) ...
+ */
+const isIdentity = (matrix) => (
+  matrix[0] === 1 && matrix[1] === 0 && matrix[2] === 0 && matrix[3] === 0 &&
+  matrix[4] === 0 && matrix[5] === 1 && matrix[6] === 0 && matrix[7] === 0 &&
+  matrix[8] === 0 && matrix[9] === 0 && matrix[10] === 1 && matrix[11] === 0 &&
+  matrix[12] === 0 && matrix[13] === 0 && matrix[14] === 0 && matrix[15] === 1
+)
+
+module.exports = isIdentity

package/src/maths/mat4/isIdentity.test.js

@@ -0,0 +1,11 @@
+const test = require('ava')
+
+const { isIdentity, create, fromTranslation } = require('./index')
+
+test('mat4: isIdentity() should return correct values', (t) => {
+  const identity = create() // identity matrix
+  t.true(isIdentity(identity))
+
+  const notidentity = fromTranslation(create(), [5, 5, 5])
+  t.false(isIdentity(notidentity))
+})

package/src/maths/mat4/isMirroring.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default isMirroring
+
+declare function isMirroring(matrix: Mat4): boolean

package/src/maths/mat4/isMirroring.js

@@ -0,0 +1,24 @@
+/**
+ * Determine whether the given matrix is a mirroring transformation.
+ *
+ * @param {mat4} matrix - matrix of reference
+ * @returns {Boolean} true if matrix is a mirroring transformation
+ * @alias module:modeling/maths/mat4.isMirroring
+ */
+const isMirroring = (matrix) => {
+  // const xVector = [matrix[0], matrix[4], matrix[8]]
+  // const yVector = [matrix[1], matrix[5], matrix[9]]
+  // const zVector = [matrix[2], matrix[6], matrix[10]]
+
+  // for a true orthogonal, non-mirrored base, xVector.cross(yVector) == zVector
+  // If they have an opposite direction then we are mirroring
+  // calcuate xVector.cross(yVector)
+  const x = matrix[4] * matrix[9] - matrix[8] * matrix[5]
+  const y = matrix[8] * matrix[1] - matrix[0] * matrix[9]
+  const z = matrix[0] * matrix[5] - matrix[4] * matrix[1]
+  // calcualte dot(cross, zVector)
+  const d = x * matrix[2] + y * matrix[6] + z * matrix[10]
+  return (d < 0)
+}
+
+module.exports = isMirroring

package/src/maths/mat4/isMirroring.test.js

@@ -0,0 +1,37 @@
+const test = require('ava')
+
+const plane = require('../plane')
+
+const { isMirroring, fromScaling, create, mirrorByPlane, rotate, scale, translate } = require('./index')
+
+test('mat4: isMirroring() should determine correctly', (t) => {
+  let matrix = create()
+  t.false(isMirroring(matrix))
+
+  matrix = fromScaling(create(), [2, 4, 6])
+  t.false(isMirroring(matrix))
+
+  const planeX = plane.fromPoints(plane.create(), [0, 0, 0], [0, 1, 1], [0, 1, 0])
+  const planeY = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 0, 1])
+  const planeZ = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+
+  matrix = mirrorByPlane(create(), planeX)
+  t.true(isMirroring(matrix))
+
+  matrix = mirrorByPlane(create(), planeY)
+  t.true(isMirroring(matrix))
+
+  matrix = mirrorByPlane(create(), planeZ)
+  t.true(isMirroring(matrix))
+
+  // additional transforms
+  const rotation = 90 * 0.017453292519943295
+  matrix = rotate(matrix, matrix, rotation, [0, 0, 1])
+  t.true(isMirroring(matrix))
+
+  matrix = scale(matrix, matrix, [0.5, 2, 5])
+  t.true(isMirroring(matrix))
+
+  matrix = translate(matrix, matrix, [2, -3, 600])
+  t.true(isMirroring(matrix))
+})

package/src/maths/mat4/isOnlyTransformScale.js

@@ -0,0 +1,22 @@
+
+/**
+ * Determine whether the given matrix is only translate and/or scale.
+ * This code returns true for TAU / 2 rotation as it can be interpreted as scale.
+ *
+ * @param {mat4} matrix - the matrix
+ * @returns {Boolean} true if matrix is for translate and/or scale
+ * @alias module:modeling/maths/mat4.isOnlyTransformScale
+ */
+const isOnlyTransformScale = (matrix) => (
+
+  // TODO check if it is worth the effort to add recognition of 90 deg rotations
+
+  isZero(matrix[1]) && isZero(matrix[2]) && isZero(matrix[3]) &&
+  isZero(matrix[4]) && isZero(matrix[6]) && isZero(matrix[7]) &&
+  isZero(matrix[8]) && isZero(matrix[9]) && isZero(matrix[11]) &&
+  matrix[15] === 1
+)
+
+const isZero = (num) => Math.abs(num) < Number.EPSILON
+
+module.exports = isOnlyTransformScale