@jscad/modeling 2.6.0 → 2.7.2

package/src/maths/mat4/isOnlyTransformScale.js

@@ -1,10 +1,11 @@
 
 /**
- * Determine whether the given matrix is translate+scale.
- * this code returns true for 180 rotation as it can be interpreted as scale (-1,-1)
- *
- * this method is primarily useful for measureBoundingBox
+ * Determine whether the given matrix is only translate and/or scale.
+ * This code returns true for PI 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) => (
 

package/src/maths/mat4/rotate.js

@@ -12,7 +12,7 @@ const copy = require('./copy')
  */
 const rotate = (out, matrix, radians, 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) < 0.000001) {
     // axis is 0,0,0 or almost

package/src/maths/plane/fromPoints.js

@@ -10,17 +10,39 @@ const vec3 = require('../vec3')
  * @returns {plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */
-const fromPoints = (out, a, b, c) => {
-  const ba = vec3.subtract(vec3.create(), b, a)
-  const ca = vec3.subtract(vec3.create(), c, a)
-  vec3.cross(ba, ba, ca)
-  vec3.normalize(ba, ba) // normal part
-  const w = vec3.dot(ba, a)
+const fromPoints = (out, ...vertices) => {
+  const len = vertices.length
 
-  out[0] = ba[0]
-  out[1] = ba[1]
-  out[2] = ba[2]
-  out[3] = w
+  // Calculate normal vector for a single vertex
+  // Inline to avoid allocations
+  const ba = vec3.create()
+  const ca = vec3.create()
+  const vertexNormal = (index) => {
+    const a = vertices[index]
+    const b = vertices[(index + 1) % len]
+    const c = vertices[(index + 2) % len]
+    vec3.subtract(ba, b, a) // ba = b - a
+    vec3.subtract(ca, c, a) // ca = c - a
+    vec3.cross(ba, ba, ca) // ba = ba x ca
+    vec3.normalize(ba, ba)
+    return ba
+  }
+
+  out[0] = 0
+  out[1] = 0
+  out[2] = 0
+  if (len === 3) {
+    // optimization for triangles, which are always coplanar
+    vec3.copy(out, vertexNormal(0))
+  } else {
+    // sum of vertex normals
+    vertices.forEach((v, i) => {
+      vec3.add(out, out, vertexNormal(i))
+    })
+    // renormalize normal vector
+    vec3.normalize(out, out)
+  }
+  out[3] = vec3.dot(out, vertices[0])
   return out
 }
 

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

@@ -13,4 +13,8 @@ test('plane: fromPoints() should return a new plane with correct values', (t) =>
   // planes created from the same points results in an invalid plane
   const obs3 = fromPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
   t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // polygon with co-linear vertices
+  const obs4 = fromPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
 })

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

@@ -25,5 +25,15 @@ test('vec2: length() should return correct values', (t) => {
   const length5 = length(vec5)
   nearlyEqual(t, length5, 2.23606, EPS)
 
+  // huge vector
+  const vec6 = fromValues(1e200, 1e200)
+  const length6 = length(vec6)
+  nearlyEqual(t, length6, Math.SQRT2 * 1e200, EPS)
+
+  // tiny vector
+  const vec7 = fromValues(1e-200, 1e-200)
+  const length7 = length(vec7)
+  nearlyEqual(t, length7, Math.SQRT2 * 1e-200, EPS)
+
   t.true(true)
 })

package/src/maths/vec3/angle.js

@@ -15,8 +15,8 @@ const angle = (a, b) => {
   const bx = b[0]
   const by = b[1]
   const bz = b[2]
-  const mag1 = Math.sqrt(ax * ax + ay * ay + az * az)
-  const mag2 = Math.sqrt(bx * bx + by * by + bz * bz)
+  const mag1 = Math.hypot(ax, ay, az)
+  const mag2 = Math.hypot(bx, by, bz)
   const mag = mag1 * mag2
   const cosine = mag && dot(a, b) / mag
   return Math.acos(Math.min(Math.max(cosine, -1), 1))

package/src/maths/vec3/angle.test.js

@@ -25,5 +25,22 @@ test('vec3: angle() should return correct values', (t) => {
   const angle4 = angle(veca4, vec4)
   nearlyEqual(t, angle4, 3.14159, EPS)
 
+  const vec5a = fromValues(1, 0, 0)
+  const vec5b = fromValues(1, 1, 0)
+  const angle5 = angle(vec5a, vec5b)
+  nearlyEqual(t, angle5, 0.785398, EPS)
+
+  // tiny values
+  const vec6a = fromValues(1, 0, 0)
+  const vec6b = fromValues(1e-200, 1e-200, 0)
+  const angle6 = angle(vec6a, vec6b)
+  nearlyEqual(t, angle6, 0.785398, EPS)
+
+  // huge values
+  const vec7a = fromValues(1, 0, 0)
+  const vec7b = fromValues(1e200, 1e200, 0)
+  const angle7 = angle(vec7a, vec7b)
+  nearlyEqual(t, angle7, 0.785398, EPS)
+
   t.true(true)
 })

package/src/maths/vec3/length.test.js

@@ -41,5 +41,15 @@ test('vec3: length() should return correct values', (t) => {
   const length9 = length(vec9)
   nearlyEqual(t, length9, 3.74165, EPS)
 
+  // huge vector
+  const vec10 = fromValues(1e200, 0, 1e200)
+  const length10 = length(vec10)
+  nearlyEqual(t, length10, Math.SQRT2 * 1e200, EPS)
+
+  // tiny vector
+  const vec11 = fromValues(1e-200, 0, 1e-200)
+  const length11 = length(vec11)
+  nearlyEqual(t, length11, Math.SQRT2 * 1e-200, EPS)
+
   t.true(true)
 })

package/src/measurements/measureBoundingBox.js

@@ -2,7 +2,6 @@ const flatten = require('../utils/flatten')
 
 const vec2 = require('../maths/vec2')
 const vec3 = require('../maths/vec3')
-const mat4 = require('../maths/mat4')
 
 const geom2 = require('../geometries/geom2')
 const geom3 = require('../geometries/geom3')
@@ -12,133 +11,86 @@ const poly3 = require('../geometries/poly3')
 const cache = new WeakMap()
 
 /*
- * Measure the min and max bounds of the given (path2) geometry.points.
- * @return {Array[]} the min and max bounds for the geometry.points
+ * Measure the min and max bounds of the given (path2) geometry.
+ * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfPath2Points = (points) => {
-  let boundingBox = cache.get(points)
+const measureBoundingBoxOfPath2 = (geometry) => {
+  let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
+  const points = path2.toPoints(geometry)
+
   let minpoint
   if (points.length === 0) {
     minpoint = vec2.create()
   } else {
     minpoint = vec2.clone(points[0])
   }
-  const maxpoint = vec2.clone(minpoint)
+  let maxpoint = vec2.clone(minpoint)
 
   points.forEach((point) => {
     vec2.min(minpoint, minpoint, point)
     vec2.max(maxpoint, maxpoint, point)
   })
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
 
-  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
-  cache.set(points, boundingBox)
+  boundingBox = [minpoint, maxpoint]
+
+  cache.set(geometry, boundingBox)
 
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (path2) geometry.
+ * Measure the min and max bounds of the given (geom2) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfPath2 = (geometry) => {
+const measureBoundingBoxOfGeom2 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfPath2Points(geometry.points), geometry.transforms)
+  const points = geom2.toPoints(geometry)
+
+  let minpoint
+  if (points.length === 0) {
+    minpoint = vec2.create()
   } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfPath2Points(path2.toPoints(geometry))
+    minpoint = vec2.clone(points[0])
   }
+  let maxpoint = vec2.clone(minpoint)
 
-  cache.set(geometry, boundingBox)
-
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom2) geometry.points/sides.
- * @return {Array[]} the min and max bounds for the geometr.points/sidesy
- */
-const measureBoundingBoxOfGeom2Points = ({ points, sides }) => {
-  const cacheKey = points || sides
-  let boundingBox = cache.get(cacheKey)
-  if (boundingBox) return boundingBox
-
-  let minpoint, maxpoint
-
-  if (points) {
-    if (points.length === 0) {
-      minpoint = vec2.create()
-    } else {
-      minpoint = vec2.clone(points[0])
-    }
-    maxpoint = vec2.clone(minpoint)
+  points.forEach((point) => {
+    vec2.min(minpoint, minpoint, point)
+    vec2.max(maxpoint, maxpoint, point)
+  })
 
-    points.forEach((point) => {
-      vec2.min(minpoint, minpoint, point)
-      vec2.max(maxpoint, maxpoint, point)
-    })
-  } else { // sides
-    // to avoid calling costly toPoints, we take advantage of the knowlege how the toPoints works
-    if (sides.length === 0) {
-      minpoint = vec2.create()
-    } else {
-      minpoint = vec2.clone(sides[0][0])
-    }
-    maxpoint = vec2.clone(minpoint)
-
-    sides.forEach((side) => {
-      vec2.min(minpoint, minpoint, side[0])
-      vec2.max(maxpoint, maxpoint, side[0])
-    })
-  }
+  minpoint = [minpoint[0], minpoint[1], 0]
+  maxpoint = [maxpoint[0], maxpoint[1], 0]
 
-  boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
+  boundingBox = [minpoint, maxpoint]
 
-  cache.set(cacheKey, boundingBox)
+  cache.set(geometry, boundingBox)
 
   return boundingBox
 }
 
 /*
- * Measure the min and max bounds of the given (geom2) geometry.
+ * Measure the min and max bounds of the given (geom3) geometry.
  * @return {Array[]} the min and max bounds for the geometry
  */
-const measureBoundingBoxOfGeom2 = (geometry) => {
+const measureBoundingBoxOfGeom3 = (geometry) => {
   let boundingBox = cache.get(geometry)
   if (boundingBox) return boundingBox
 
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom2Points(geometry), geometry.transforms)
-  } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfGeom2Points({ points: geom2.toPoints(geometry) })
-  }
-
-  cache.set(geometry, boundingBox)
-
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom3) geometry.polygons.
- * @return {Array[]} the min and max bounds for the geometry.polygons
- */
-const measureBoundingBoxOfGeom3Polygons = (polygons) => {
-  let boundingBox = cache.get(polygons)
-  if (boundingBox) return boundingBox
+  const polygons = geom3.toPolygons(geometry)
 
-  const minpoint = vec3.create()
+  let minpoint = vec3.create()
   if (polygons.length > 0) {
     const points = poly3.toPoints(polygons[0])
     vec3.copy(minpoint, points[0])
   }
-  const maxpoint = vec3.clone(minpoint)
+  let maxpoint = vec3.clone(minpoint)
 
   polygons.forEach((polygon) => {
     poly3.toPoints(polygon).forEach((point) => {
@@ -147,41 +99,16 @@ const measureBoundingBoxOfGeom3Polygons = (polygons) => {
     })
   })
 
-  boundingBox = [[minpoint[0], minpoint[1], minpoint[2]], [maxpoint[0], maxpoint[1], maxpoint[2]]]
+  minpoint = [minpoint[0], minpoint[1], minpoint[2]]
+  maxpoint = [maxpoint[0], maxpoint[1], maxpoint[2]]
 
-  cache.set(polygons, boundingBox)
-
-  return boundingBox
-}
-
-/*
- * Measure the min and max bounds of the given (geom3) geometry.
- * @return {Array[]} the min and max bounds for the geometry
- */
-const measureBoundingBoxOfGeom3 = (geometry) => {
-  let boundingBox = cache.get(geometry)
-  if (boundingBox) return boundingBox
-
-  if (mat4.isOnlyTransformScale(geometry.transforms)) {
-    // get boundingBox of original points and transform it
-    boundingBox = transformBoundingBox(measureBoundingBoxOfGeom3Polygons(geometry.polygons), geometry.transforms)
-  } else {
-    // transform the points and then caclulate the boundingBox
-    boundingBox = measureBoundingBoxOfGeom3Polygons(geom3.toPolygons(geometry))
-  }
+  boundingBox = [minpoint, maxpoint]
 
   cache.set(geometry, boundingBox)
 
   return boundingBox
 }
 
-const transformBoundingBox = (boundingBox, transforms) => {
-  if (transforms && !mat4.isIdentity(transforms)) {
-    return [vec3.transform(vec3.create(), boundingBox[0], transforms), vec3.transform(vec3.create(), boundingBox[1], transforms)]
-  }
-  return boundingBox
-}
-
 /**
  * Measure the min and max bounds of the given geometries.
  * @param {...Object} geometries - the geometries to measure
@@ -204,15 +131,4 @@ const measureBoundingBox = (...geometries) => {
   return results.length === 1 ? results[0] : results
 }
 
-/**
- * Shortcut for geometries that are complex but have a fast way to calculate bounding box.
- * Ellipsoid, or cylinder can provide boundingBox that pre-calculated based on parameters without traversing points.
- *
- * Another option is to calculate boundingBox durint toPoints (so the boundingBox could be calculated during transform)
- *
- * NOTE: It seems that measureBoundingBox is used all over the place, and it would be wise to allow
- * shortcuts for calculating it, as default implementation goes through all points in geometry which is bound to be slow.
-*/
-measureBoundingBox.setCache = (geometry, boundingBox) => cache.set(geometry, boundingBox)
-
 module.exports = measureBoundingBox

package/src/measurements/measureBoundingBox.test.js

@@ -4,6 +4,8 @@ const { geom2, geom3, path2 } = require('../geometries')
 
 const { line, rectangle, cuboid } = require('../primitives')
 
+const { mirror } = require('../operations/transforms')
+
 const { measureBoundingBox } = require('./index')
 
 test('measureBoundingBox (single objects)', (t) => {
@@ -56,3 +58,9 @@ test('measureBoundingBox (multiple objects)', (t) => {
   allbounds = measureBoundingBox(aline, arect, acube, o)
   t.deepEqual(allbounds, [[[10, 10, 0], [15, 15, 0]], [[-5, -10, 0], [5, 10, 0]], [[-1, -1, -1], [1, 1, 1]], [[0, 0, 0], [0, 0, 0]]])
 })
+
+test('measureBoundingBox invert', (t) => {
+  const acube = mirror({}, cuboid())
+  const cbounds = measureBoundingBox(acube)
+  t.deepEqual(cbounds, [[-1, -1, -1], [1, 1, 1]])
+})

package/src/measurements/measureCenterOfMass.js

@@ -4,7 +4,6 @@ const vec3 = require('../maths/vec3')
 
 const geom2 = require('../geometries/geom2')
 const geom3 = require('../geometries/geom3')
-const path2 = require('../geometries/path2')
 
 const cacheOfCenterOfMass = new WeakMap()
 

package/src/measurements/measureEpsilon.js

@@ -8,25 +8,19 @@ const measureBoundingBox = require('./measureBoundingBox')
  * Measure the epsilon of the given (path2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfPath2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom3) geometry.
  * @return {Float} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom3 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
-}
+const measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
 
 /**
  * Measure the epsilon of the given geometries.

package/src/operations/booleans/reTesselateCoplanarPolygons.js

@@ -309,7 +309,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
           const polygon = poly3.fromPointsAndPlane(vertices3d, plane) // TODO support shared
 
           // if we let empty polygon out, next retesselate will crash
-          if(polygon.vertices.length) destpolygons.push(polygon)
+          if (polygon.vertices.length) destpolygons.push(polygon)
         }
       }
     } // if(yindex > 0)

package/src/operations/booleans/retessellate.js

@@ -10,9 +10,7 @@ const reTesselateCoplanarPolygons = require('./reTesselateCoplanarPolygons')
 const NEPS = 1e-13
 
 // Compare two normals (unit vectors) for equality.
-const aboutEqualNormals = (a, b) => {
-  return (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
-}
+const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
 
 const coplanar = (plane1, plane2) => {
   // expect the same distance from the origin, within tolerance

package/src/operations/booleans/trees/PolygonTreeNode.js

@@ -20,7 +20,6 @@ const splitPolygonByPlane = require('./splitPolygonByPlane')
 // remove() removes a polygon from the tree. Once a polygon is removed, the parent polygons are invalidated
 // since they are no longer intact.
 class PolygonTreeNode {
-
   // constructor creates the root node
   constructor () {
     this.parent = null

package/src/operations/expansions/expand.js

@@ -10,6 +10,8 @@ const expandPath2 = require('./expandPath2')
 
 /**
  * Expand the given geometry using the given options.
+ * Both interal and external space is expanded for 2D and 3D shapes.
+ *
  * Note: Contract is expand using a negative delta.
  * @param {Object} options - options for expand
  * @param {Number} [options.delta=1] - delta (+/-) of expansion

package/src/operations/expansions/expand.test.js

@@ -120,7 +120,7 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = expand({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
-  t.is(pts2.length, 2059)
+  t.is(pts2.length, 2065)
 })
 
 test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {

package/src/operations/expansions/offset.js

@@ -8,6 +8,7 @@ const offsetPath2 = require('./offsetPath2')
 
 /**
  * Create offset geometry from the given geometry using the given options.
+ * Offsets from internal and external space are created.
  * @param {Object} options - options for offset
  * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
  * @param {String} [options.corners='edge'] - type of corner to create after offseting; edge, chamfer, round

package/src/operations/extrusions/extrudeLinear.js

@@ -7,7 +7,7 @@ const extrudeLinearGeom2 = require('./extrudeLinearGeom2')
 /**
  * Extrude the given geometry in an upward linear direction using the given options.
  * @param {Object} options - options for extrude
- * @param {Array} [options.height=1] the height of the extrusion
+ * @param {Number} [options.height=1] the height of the extrusion
  * @param {Number} [options.twistAngle=0] the final rotation (RADIANS) about the origin of the shape (if any)
  * @param {Integer} [options.twistSteps=1] the resolution of the twist about the axis (if any)
  * @param {...Object} geometry - the list of geometry to extrude

package/src/operations/extrusions/extrudeRectangular.js

@@ -17,7 +17,8 @@ const extrudeRectangularGeom2 = require('./extrudeRectangularGeom2')
  * @alias module:modeling/extrusions.extrudeRectangular
  *
  * @example
- * let mywalls = extrudeRectangular({offset: [0,0,10]}, square())
+ * let mywalls = extrudeRectangular({size: 1, height: 3}, square({size: 20}))
+ * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: Math.PI}, square({size: 20}))
  */
 const extrudeRectangular = (options, ...objects) => {
   const defaults = {

package/src/operations/extrusions/extrudeRotate.test.js

@@ -107,10 +107,14 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[7, -4.898587196589413e-16, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [9.184850993605148e-16, 7, -8]],
     [[7, 4.898587196589413e-16, 8], [7, -4.898587196589413e-16, -8], [9.184850993605148e-16, 7, -8]],
     [[7, 4.898587196589413e-16, 8], [9.184850993605148e-16, 7, -8], [-6.123233995736767e-17, 7, 8]],
-    [[-4.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
-     [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
-     [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]]
+    [
+      [-4.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
+      [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]
+    ],
+    [
+      [7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
+      [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]
+    ]
   ]
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -133,12 +137,16 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[0.7071067811865472, 0.7071067811865478, 8], [1.414213562373095, 1.4142135623730951, 4], [-1.2246467991473532e-16, 2, 4]],
     [[0.7071067811865472, 0.7071067811865478, 8], [-1.2246467991473532e-16, 2, 4], [-4.286263797015736e-16, 1, 8]],
     [[-3.4638242249419727e-16, 3.4638242249419736e-16, 8], [0.7071067811865472, 0.7071067811865478, 8], [-4.286263797015736e-16, 1, 8]],
-    [[-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
-     [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
-     [ 4.898587196589414e-16, 0, -8]],
-    [[0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
-     [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
-     [0, 4.898587196589411e-16, 8]]
+    [
+      [-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
+      [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
+      [4.898587196589414e-16, 0, -8]
+    ],
+    [
+      [0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
+      [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
+      [0, 4.898587196589411e-16, 8]
+    ]
   ]
   t.is(pts.length, 14)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/hulls/quickhull/QuickHull.js

@@ -722,7 +722,7 @@ class QuickHull {
     for (let i = 0; i < this.newFaces.length; i += 1) {
       const face = this.newFaces[i]
       if (face.mark === VISIBLE) {
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {}
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {} // eslint-disable-line no-empty
       }
     }
 
@@ -733,7 +733,7 @@ class QuickHull {
       const face = this.newFaces[i]
       if (face.mark === NON_CONVEX) {
         face.mark = VISIBLE
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {}
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {} // eslint-disable-line no-empty
       }
     }
 

package/src/operations/modifiers/edges.js

@@ -99,9 +99,7 @@ const splitPolygon = (openedge, polygon, eps) => {
 /*
  * TBD This should be part of vec3.
  */
-const almostEquals = (eps, v1, v2) => {
-  return (Math.abs(v1[0] - v2[0]) <= eps && Math.abs(v1[1] - v2[1]) <= eps && Math.abs(v1[2] - v2[2]) <= eps)
-}
+const almostEquals = (eps, v1, v2) => (Math.abs(v1[0] - v2[0]) <= eps && Math.abs(v1[1] - v2[1]) <= eps && Math.abs(v1[2] - v2[2]) <= eps)
 
 const enclosedEdge = (openedge, edge, eps) => {
   if (openedge.distance < edge.distance) {

package/src/operations/modifiers/generalize.js

@@ -15,16 +15,11 @@ const repairTjunctions = require('./repairTjunctions')
 
 /*
  */
-const generalizePath2 = (options, geometry) => {
-  return geometry
-}
-
+const generalizePath2 = (options, geometry) => geometry
 
 /*
  */
-const generalizeGeom2 = (options, geometry) => {
-  return geometry
-}
+const generalizeGeom2 = (options, geometry) => geometry
 
 /*
  */
@@ -78,6 +73,7 @@ const generalizeGeom3 = (options, geometry) => {
  * @param {Boolean} [options.simplify=false] the geometries should be simplified
  * @param {Boolean} [options.triangulate=false] the geometries should be triangulated
  * @param {Boolean} [options.repair=false] the geometries should be repaired
+ * @param {...Object} geometries - the geometries to generalize
  * @return {Object|Array} the modified geometry, or a list of modified geometries
  * @alias module:modeling/modifiers.generalize
  */

package/src/operations/modifiers/snapPolygons.js

@@ -3,7 +3,7 @@ const vec3 = require('../../maths/vec3')
 const poly3 = require('../../geometries/poly3')
 
 const isValidPoly3 = (epsilon, polygon) => {
-  const area = poly3.measureArea(polygon)
+  const area = Math.abs(poly3.measureArea(polygon))
   return (Number.isFinite(area) && area > epsilon)
 }
 
@@ -17,7 +17,7 @@ const snapPolygons = (epsilon, polygons) => {
     const newvertices = []
     for (let i = 0; i < snapvertices.length; i++) {
       const j = (i + 1) % snapvertices.length
-      if (! vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
+      if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
     }
     const newpolygon = poly3.create(newvertices)
     if (polygon.color) newpolygon.color = polygon.color