@jscad/modeling 2.6.0 → 2.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.6.0",
+  "version": "2.7.2",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -60,5 +60,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "3d1d02f2863c65fd95406c7098c09297b3be1c10"
+  "gitHead": "b6c5675d2d9a292e0ba24896bf22d0e9dc5d4270"
 }

package/src/colors/colorize.js

@@ -1,10 +1,39 @@
 const flatten = require('../utils/flatten')
 
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+const path2 = require('../geometries/path2')
+const poly3 = require('../geometries/poly3')
+
+const colorGeom2 = (color, object) => {
+  const newgeom2 = geom2.clone(object)
+  newgeom2.color = color
+  return newgeom2
+}
+
+const colorGeom3 = (color, object) => {
+  const newgeom3 = geom3.clone(object)
+  newgeom3.color = color
+  return newgeom3
+}
+
+const colorPath2 = (color, object) => {
+  const newpath2 = path2.clone(object)
+  newpath2.color = color
+  return newpath2
+}
+
+const colorPoly3 = (color, object) => {
+  const newpoly = poly3.clone(object)
+  newpoly.color = color
+  return newpoly
+}
+
 /**
  * Assign the given color to the given objects.
  * @param {Array} color - RGBA color values, where each value is between 0 and 1.0
  * @param {Object|Array} objects - the objects of which to apply the given color
- * @return {Object|Array} given object, or list of given objects with an additional attribute 'color'
+ * @return {Object|Array} new object, or list of new objects with an additional attribute 'color'
  * @alias module:modeling/colors.colorize
  *
  * @example
@@ -22,6 +51,11 @@ const colorize = (color, ...objects) => {
   if (objects.length === 0) throw new Error('wrong number of arguments')
 
   const results = objects.map((object) => {
+    if (geom2.isA(object)) return colorGeom2(color, object)
+    if (geom3.isA(object)) return colorGeom3(color, object)
+    if (path2.isA(object)) return colorPath2(color, object)
+    if (poly3.isA(object)) return colorPoly3(color, object)
+
     object.color = color
     return object
   })

package/src/colors/colorize.test.js

@@ -43,15 +43,30 @@ test('color (rgba on geometry)', (t) => {
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)
 
-  t.is(obj0, obs[0])
+  t.not(obj0, obs[0])
   t.deepEqual(obs[0].color, [1, 1, 0.5, 0.8])
 
-  t.is(obj1, obs[1])
+  t.not(obj1, obs[1])
   t.deepEqual(obs[1].color, [1, 1, 0.5, 0.8])
 
-  t.is(obj2, obs[2])
+  t.not(obj2, obs[2])
   t.deepEqual(obs[2].color, [1, 1, 0.5, 0.8])
 
-  t.is(obj3, obs[3])
+  t.not(obj3, obs[3])
   t.deepEqual(obs[3].color, [1, 1, 0.5, 0.8])
 })
+
+test('color (returns new object)', (t) => {
+  const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  // const obj1 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  // const obj2 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  const obj3 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+
+  const obs = colorize([1, 1, 1, 0.8], obj0, obj3)
+  t.not(obj0, obs[0])
+  t.deepEqual(obs[0].color, [1, 1, 1, 0.8])
+  t.is(obj0.color, undefined)
+  t.not(obj3, obs[1])
+  t.deepEqual(obs[1].color, [1, 1, 1, 0.8])
+  t.is(obj3.color, undefined)
+})

package/src/colors/hslToRgb.js

@@ -5,7 +5,7 @@ const hueToColorComponent = require('./hueToColorComponent')
 /**
  * Converts HSL color values to RGB color values.
  *
- * @see http://en.wikipedia.org/wiki/HSL_color_space.
+ * @see http://en.wikipedia.org/wiki/HSL_color_space
  * @param {...Number|Array} values - HSL or HSLA color values
  * @return {Array} RGB or RGBA color values
  * @alias module:modeling/colors.hslToRgb

package/src/colors/hueToColorComponent.js

@@ -3,6 +3,7 @@
  * @param  {Number} p
  * @param  {Number} q
  * @param  {Number} t
+ * @return {Number} color component
  * @alias module:modeling/colors.hueToColorComponent
  */
 const hueToColorComponent = (p, q, t) => {

package/src/curves/bezier/create.js

@@ -7,14 +7,6 @@
  * @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
  *
- * @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
- *
  */
 
 /**
@@ -25,6 +17,9 @@
  * 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

package/src/curves/bezier/tangentAt.js

@@ -4,12 +4,12 @@
  * See the example called extrudeAlongPath.js
  *
  * @example
- * 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
+ * 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
  * let tangent = bezier.tangentAt(t, b)
  *
  * @param {number} t : the position of which to calculate the bezier's tangent value; 0 < t < 1
  * @param {Object} bezier : an array with at least 2 elements of either all numbers, or all arrays of numbers that are the same size.
- * @returns {array | number} the tangent at the requested position.
+ * @return {array | number} the tangent at the requested position.
  * @alias module:modeling/curves/bezier.tangentAt
  */
 const tangentAt = (t, bezier) => {

package/src/curves/index.js

@@ -1,5 +1,5 @@
 /**
- * Curves are n-dimensional mathematical constructs that define a path from point 0 to point 1
+ * Curves are n-dimensional mathematical constructs that define a path from point 0 to point 1.
  * @module modeling/curves
  * @example
  * const { bezier } = require('@jscad/modeling').curves

package/src/geometries/geom2/clone.js

@@ -1,19 +1,9 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the given geometry.
+ * Performs a shallow clone of the given geometry.
  * @param {geom2} geometry - the geometry to clone
  * @returns {geom2} new geometry
  * @alias module:modeling/geometries/geom2.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.sides = geometry.sides.map((side) => [vec2.clone(side[0]), vec2.clone(side[1])])
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/geom2/toOutlines.js

@@ -7,21 +7,16 @@ const toSides = require('./toSides')
  * This allows the edges to be traversed in order.
  */
 const toEdges = (sides) => {
-  const uniquevertices = []
+  const vertices = {}
   const getUniqueVertex = (vertex) => {
-    const i = uniquevertices.findIndex((v) => vec2.equals(v, vertex))
-    if (i < 0) {
-      uniquevertices.push(vertex)
-      return vertex
+    const key = vertex.toString()
+    if (!vertices[key]) {
+      vertices[key] = vertex
     }
-    return uniquevertices[i]
+    return vertices[key]
   }
 
-  const edges = []
-  sides.forEach((side) => {
-    edges.push([getUniqueVertex(side[0]), getUniqueVertex(side[1])])
-  })
-  return edges
+  return sides.map((side) => side.map(getUniqueVertex))
 }
 
 /**

package/src/geometries/geom2/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the sides, as this function only adjusts the transforms.

package/src/geometries/geom3/clone.js

@@ -1,21 +1,9 @@
-const mat4 = require('../../maths/mat4')
-
-const poly3 = require('../poly3')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the given geometry.
+ * Performs a shallow clone of the given geometry.
  * @param {geom3} geometry - the geometry to clone
  * @returns {geom3} a new geometry
  * @alias module:modeling/geometries/geom3.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.polygons = geometry.polygons.map((polygon) => poly3.clone(polygon))
-  out.isRetesselated = geometry.isRetesselated
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/geom3/clone.test.js

@@ -7,7 +7,6 @@ const { comparePolygons, compareVectors } = require('../../../test/helpers/')
 test('clone: Creates a clone on an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = create()
@@ -22,7 +21,6 @@ test('clone: Creates a clone of a populated geom3', (t) => {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
     ],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

package/src/geometries/geom3/create.js

@@ -4,8 +4,7 @@ const mat4 = require('../../maths/mat4')
  * Represents a 3D geometry consisting of a list of polygons.
  * @typedef {Object} geom3
  * @property {Array} polygons - list of polygons, each polygon containing three or more points
- * @property {Boolean} isRetesselated - true if retesselation has been performed
- * @property {mat4} transforms - transforms to apply to the sides, see transform()
+ * @property {mat4} transforms - transforms to apply to the polygons, see transform()
  */
 
 /**
@@ -20,7 +19,6 @@ const create = (polygons) => {
   }
   return {
     polygons: polygons,
-    isRetesselated: false,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -7,7 +7,6 @@ const { create } = require('./index')
 test('create: Creates an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   t.deepEqual(create(), expected)
@@ -20,7 +19,6 @@ test('create: Creates a populated geom3', (t) => {
   const polygons = [polygon]
   const expected = {
     polygons: polygons,
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   t.deepEqual(create(polygons), expected)

package/src/geometries/geom3/fromCompactBinary.js

@@ -18,10 +18,8 @@ const fromCompactBinary = (data) => {
 
   created.transforms = mat4.clone(data.slice(1, 17))
 
-  created.isRetesselated = !!data[17]
-
-  const numberOfVertices = data[22]
-  let ci = 23
+  const numberOfVertices = data[21]
+  let ci = 22
   let vi = data.length - (numberOfVertices * 3)
   while (vi < data.length) {
     const verticesPerPolygon = data[ci]
@@ -36,8 +34,8 @@ const fromCompactBinary = (data) => {
   }
 
   // transfer known properities, i.e. color
-  if (data[18] >= 0) {
-    created.color = [data[18], data[19], data[20], data[21]]
+  if (data[17] >= 0) {
+    created.color = [data[17], data[18], data[19], data[20]]
   }
   // TODO: how about custom properties or fields ?
   return created

package/src/geometries/geom3/fromToCompactBinary.test.js

@@ -12,7 +12,6 @@ test('toCompactBinary: converts geom3 (default)', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       -1, -1, -1, -1, // color
       0 // number of vertices
     ]
@@ -32,7 +31,6 @@ test('toCompactBinary: converts geom3 into a compact form', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       -1, -1, -1, -1, // color
       7, // number of vertices
       3, // number of vertices per polygon (2)
@@ -59,7 +57,6 @@ test('toCompactBinary: converts geom3 into a compact form', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       1, 2, 3, 4, // color
       7, // number of vertices
       3, // number of vertices per polygon (2)
@@ -84,7 +81,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     -1, -1, -1, -1, // color
     0 // number of vertices
   ]
@@ -99,7 +95,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     -1, -1, -1, -1, // color
     7, // number of vertices
     3, // number of vertices per polygon (2)
@@ -125,7 +120,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     4, 5, 6, 7, // color
     7, // number of vertices
     3, // number of vertices per polygon (2)

package/src/geometries/geom3/invert.js

@@ -5,8 +5,8 @@ const toPolygons = require('./toPolygons')
 
 /**
  * Invert the given geometry, transposing solid and empty space.
- * @params {geom3} geometry - the geometry to invert
- * @returns {geom3} a new geometry
+ * @param {geom3} geometry - the geometry to invert
+ * @return {geom3} a new geometry
  * @alias module:modeling/geometries/geom3.invert
  */
 const invert = (geometry) => {

package/src/geometries/geom3/invert.test.js

@@ -7,7 +7,6 @@ const { comparePolygons, compareVectors } = require('../../../test/helpers/')
 test('invert: Creates a invert on an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = create()
@@ -22,7 +21,6 @@ test('invert: Creates a invert of a populated geom3', (t) => {
     polygons: [
       { vertices: [[1, 0, 1], [1, 0, 0], [0, 0, 0]] }
     ],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

package/src/geometries/geom3/toCompactBinary.js

@@ -16,8 +16,8 @@ const toCompactBinary = (geom) => {
   if (geom.color) color = geom.color
 
   // FIXME why Float32Array?
-  const compacted = new Float32Array(1 + 16 + 1 + 4 + 1 + numberOfPolygons + (numberOfVertices * 3))
-  // type + transforms + isRetesselated + color + numberOfPolygons + numberOfVerticesPerPolygon[] + vertices data[]
+  const compacted = new Float32Array(1 + 16 + 4 + 1 + numberOfPolygons + (numberOfVertices * 3))
+  // type + transforms + color + numberOfPolygons + numberOfVerticesPerPolygon[] + vertices data[]
 
   compacted[0] = 1 // type code: 0 => geom2, 1 => geom3 , 2 => path2
 
@@ -38,16 +38,14 @@ const toCompactBinary = (geom) => {
   compacted[15] = transforms[14]
   compacted[16] = transforms[15]
 
-  compacted[17] = geom.isRetesselated ? 1 : 0
+  compacted[17] = color[0]
+  compacted[18] = color[1]
+  compacted[19] = color[2]
+  compacted[20] = color[3]
 
-  compacted[18] = color[0]
-  compacted[19] = color[1]
-  compacted[20] = color[2]
-  compacted[21] = color[3]
+  compacted[21] = numberOfVertices
 
-  compacted[22] = numberOfVertices
-
-  let ci = 23
+  let ci = 22
   let vi = ci + numberOfPolygons
   polygons.forEach((polygon) => {
     const points = poly3.toPoints(polygon)

package/src/geometries/geom3/toPoints.js

@@ -5,6 +5,7 @@ const toPolygons = require('./toPolygons')
 /**
  * Return the given geometry as a list of points, after applying transforms.
  * The returned array should not be modified as the points are shared with the geometry.
+ * @param {geom3} geometry - the geometry
  * @return {Array} list of points, where each sub-array represents a polygon
  * @alias module:modeling/geometries/geom3.toPoints
  */

package/src/geometries/geom3/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.

package/src/geometries/geom3/transform.test.js

@@ -18,7 +18,6 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
     ],
-    isRetesselated: false,
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

package/src/geometries/geom3/type.d.ts

@@ -6,6 +6,5 @@ export default Geom3
 
 declare interface Geom3 extends Colored {
   polygons: Array<Poly3>
-  isRetesselated: boolean
   transforms: Mat4
 }

package/src/geometries/path2/clone.js

@@ -1,20 +1,9 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the give geometry.
+ * Performs a shallow clone of the give geometry.
  * @param {path2} geometry - the geometry to clone
  * @returns {path2} a new path
  * @alias module:modeling/geometries/path2.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.points = geometry.points.map((point) => vec2.clone(point))
-  out.isClosed = geometry.isClosed
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/path2/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the points, as this function only adjusts the transforms.

package/src/geometries/poly3/isConvex.js

@@ -13,7 +13,7 @@ const areVerticesConvex = (vertices) => {
   const numvertices = vertices.length
   if (numvertices > 2) {
     // note: plane ~= normal point
-    const normal = plane.fromPoints(plane.create(), vertices[0], vertices[1], vertices[2])
+    const normal = plane.fromPoints(plane.create(), ...vertices)
     let prevprevpos = vertices[numvertices - 2]
     let prevpos = vertices[numvertices - 1]
     for (let i = 0; i < numvertices; i++) {

package/src/geometries/poly3/measureArea.js

@@ -1,4 +1,4 @@
-const vec3 = require('../../maths/vec3')
+const plane = require('./plane')
 
 /**
  * Measure the area of the given polygon.
@@ -14,19 +14,18 @@ const measureArea = (poly3) => {
   }
   const vertices = poly3.vertices
 
-  // calculate a real normal
-  const a = vertices[0]
-  const b = vertices[1]
-  const c = vertices[2]
-  const ba = vec3.subtract(vec3.create(), b, a)
-  const ca = vec3.subtract(vec3.create(), c, a)
-  const normal = vec3.cross(ba, ba, ca)
+  // calculate a normal vector
+  const normal = plane(poly3)
 
-  // determin direction of projection
+  // determine direction of projection
   const ax = Math.abs(normal[0])
   const ay = Math.abs(normal[1])
   const az = Math.abs(normal[2])
-  const an = Math.sqrt((ax * ax) + (ay * ay) + (az * az)) // length of normal
+
+  if (ax + ay + az === 0) {
+    // normal does not exist
+    return 0
+  }
 
   let coord = 3 // ignore Z coordinates
   if ((ax > ay) && (ax > az)) {
@@ -50,7 +49,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][1] * (vertices[1][2] - vertices[n - 1][2]))
       // scale to get area
-      area *= (an / (2 * normal[0]))
+      area /= (2 * normal[0])
       break
 
     case 2: // ignore Y coordinates
@@ -62,7 +61,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][2] * (vertices[1][0] - vertices[n - 1][0]))
       // scale to get area
-      area *= (an / (2 * normal[1]))
+      area /= (2 * normal[1])
       break
 
     case 3: // ignore Z coordinates
@@ -75,7 +74,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][0] * (vertices[1][1] - vertices[n - 1][1]))
       // scale to get area
-      area *= (an / (2 * normal[2]))
+      area /= (2 * normal[2])
       break
   }
   return area

package/src/geometries/poly3/measureArea.test.js

@@ -37,6 +37,21 @@ test('poly3: measureArea() should return correct values', (t) => {
   let ret4 = measureArea(ply4)
   t.is(ret4, 19.5)
 
+  // colinear vertices non-zero area
+  const ply5 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0]])
+  const ret5 = measureArea(ply5)
+  t.is(ret5, 1)
+
+  // colinear vertices empty area
+  const ply6 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+  const ret6 = measureArea(ply6)
+  t.is(ret6, 0)
+
+  // duplicate vertices empty area
+  const ply7 = fromPoints([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+  const ret7 = measureArea(ply7)
+  t.is(ret7, 0)
+
   // rotated to various angles
   let rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)

package/src/geometries/poly3/plane.js

@@ -2,8 +2,7 @@ const mplane = require('../../maths/plane/')
 
 const plane = (polygon) => {
   if (!polygon.plane) {
-    const vertices = polygon.vertices
-    polygon.plane = mplane.fromPoints(mplane.create(), vertices[0], vertices[1], vertices[2])
+    polygon.plane = mplane.fromPoints(mplane.create(), ...polygon.vertices)
   }
   return polygon.plane
 }

package/src/maths/line3/create.js

@@ -3,7 +3,8 @@ 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 and 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
  */

package/src/maths/mat4/fromRotation.js

@@ -19,7 +19,7 @@ const { EPSILON } = require('./constants')
  */
 const fromRotation = (out, rad, axis) => {
   let [x, y, z] = axis
-  let len = Math.sqrt(x * x + y * y + z * z)
+  let len = Math.hypot(x, y, z)
 
   if (Math.abs(len) < EPSILON) {
     // axis is 0,0,0 or almost

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

@@ -2,8 +2,6 @@ const test = require('ava')
 
 const { isIdentity, create, fromTranslation } = require('./index')
 
-const { compareVectors } = require('../../../test/helpers/index')
-
 test('mat4: isIdentity() should return correct values', (t) => {
   const identity = create() // identity matrix
   t.true(isIdentity(identity))