@jscad/modeling 2.11.1 → 2.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.11.1",
+  "version": "2.12.1",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "4313974b50957018d2edd010e3a251f59bea46a4"
+  "gitHead": "e07bb27d61f638348c73cc1383dfb5339060a02a"
 }

package/src/curves/bezier/arcLengthToT.js

@@ -3,7 +3,7 @@ const lengths = require('./lengths')
 /**
  * Convert a given arc length along a bezier curve to a t value.
  * Useful for generating equally spaced points along a bezier curve.
- * 
+ *
  * @example
  * const points = [];
  * const segments = 9; // this will generate 10 equally spaced points
@@ -14,7 +14,7 @@ const lengths = require('./lengths')
  *   points.push(point);
  * }
  * return points;
- * 
+ *
  * @param {Object} [options] options for construction
  * @param {Number} [options.distance=0] the distance along the bezier curve for which we want to find the corresponding t value.
  * @param {Number} [options.segments=100] the number of segments to use when approximating the curve length.
@@ -27,8 +27,8 @@ const arcLengthToT = (options, bezier) => {
     distance: 0,
     segments: 100
   }
-  const {distance, segments} = Object.assign({}, defaults, options)
-  
+  const { distance, segments } = Object.assign({}, defaults, options)
+
   const arcLengths = lengths(segments, bezier)
   // binary search for the index with largest value smaller than target arcLength
   let startIndex = 0
@@ -58,6 +58,6 @@ const arcLengthToT = (options, bezier) => {
   const segmentFraction = (distance - lengthBefore) / segmentLength
   // add that fractional amount and return
   return (targetIndex + segmentFraction) / segments
-};
+}
 
-module.exports = arcLengthToT
+module.exports = arcLengthToT

package/src/curves/bezier/arcLengthToT.test.js

@@ -9,71 +9,71 @@ const { nearlyEqual } = require('../../../test/helpers/index')
 test('calculate arcLengthToT for an 1D linear bezier with numeric control points', (t) => {
   const bezierCurve = bezier.create([0, 10])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.5, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for an 1D linear bezier with array control points', (t) => {
   const bezierCurve = bezier.create([[0], [10]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.5, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 2D linear bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0], [10, 10]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.5, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 2D quadratic (3 control points) bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.50001, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.50001, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 2D cubic (4 control points) bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0], [0, 10], [10, 10], [10, 0]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.49999, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 3D linear bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0, 0], [10, 10, 10]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.49999, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 3D quadratic (3 control points) bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.49999, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.49999, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
 })
 
 test('calculate arcLengthToT for a 3D cubic (4 control points) bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10], [-5, -5, 5]])
   const len = length(100, bezierCurve)
-  nearlyEqual(t, arcLengthToT({distance: 0}, bezierCurve), 0, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len / 2}, bezierCurve), 0.5621, 0.0001)
-  nearlyEqual(t, arcLengthToT({distance: len}, bezierCurve), 1, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: 0 }, bezierCurve), 0, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len / 2 }, bezierCurve), 0.5621, 0.0001)
+  nearlyEqual(t, arcLengthToT({ distance: len }, bezierCurve), 1, 0.0001)
   t.true(true)
-})
+})

package/src/curves/bezier/length.js

@@ -7,14 +7,12 @@ const lengths = require('./lengths')
  * @example
  * const b = bezier.create([[0, 0], [0, 10]]);
  * console.log(length(100, b)) // output 10
- * 
+ *
  * @param {Number} segments the number of segments to use when approximating the curve length.
  * @param {Object} bezier a bezier curve.
  * @returns an approximation of the curve's length.
  * @alias module:modeling/curves/bezier.length
  */
-const length = (segments, bezier) => {
-  return lengths(segments, bezier)[segments]
-};
+const length = (segments, bezier) => lengths(segments, bezier)[segments]
 
-module.exports = length
+module.exports = length

package/src/curves/bezier/length.test.js

@@ -7,7 +7,7 @@ const { nearlyEqual } = require('../../../test/helpers/index')
 
 test('calculate the length of an 1D linear bezier with numeric control points', (t) => {
   const bezierCurve = bezier.create([0, 10])
-  nearlyEqual(t, length(100, bezierCurve), 10, 0.0001) 
+  nearlyEqual(t, length(100, bezierCurve), 10, 0.0001)
   t.true(true)
 })
 
@@ -51,4 +51,4 @@ test('calculate the length of a 3D cubic (4 control points) bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0, 0], [5, 5, 5], [0, 0, 10], [-5, -5, 5]])
   nearlyEqual(t, length(100, bezierCurve), 17.2116, 0.0001)
   t.true(true)
-})
+})

package/src/curves/bezier/lengths.js

@@ -1,20 +1,20 @@
-const valueAt = require("./valueAt")
+const valueAt = require('./valueAt')
 
 /**
  * Divides the bezier curve into line segments and returns the cumulative length of those segments as an array.
  * Utility function used to calculate the curve's approximate length and determine the equivalence between arc length and time.
- * 
+ *
  * @example
  * const b = bezier.create([[0, 0], [0, 10]]);
  * const totalLength = lengths(100, b).pop(); // the last element of the array is the curve's approximate length
- * 
+ *
  * @param {Number} segments the number of segments to use when approximating the curve length.
  * @param {Object} bezier a bezier curve.
  * @returns an array containing the cumulative length of the segments.
  */
 const lengths = (segments, bezier) => {
   let sum = 0
-  let lengths = [0]
+  const lengths = [0]
   let previous = valueAt(0, bezier)
   for (let index = 1; index <= segments; index++) {
     const current = valueAt(index / segments, bezier)
@@ -23,7 +23,7 @@ const lengths = (segments, bezier) => {
     previous = current
   }
   return lengths
-};
+}
 
 /**
  * Calculates the Euclidean distance between two n-dimensional points.
@@ -31,7 +31,7 @@ const lengths = (segments, bezier) => {
  * @example
  * const distance = distanceBetween([0, 0], [0, 10]); // calculate distance between 2D points
  * console.log(distance); // output 10
- * 
+ *
  * @param {Array} a - first operand.
  * @param {Array} b - second operand.
  * @returns {Number} - distance.
@@ -41,7 +41,7 @@ const distanceBetween = (a, b) => {
     return Math.abs(a - b)
   } else if (Array.isArray(a) && Array.isArray(b)) {
     if (a.length !== b.length) {
-      throw new Error("The operands must have the same number of dimensions.")
+      throw new Error('The operands must have the same number of dimensions.')
     }
     let sum = 0
     for (let i = 0; i < a.length; i++) {
@@ -49,8 +49,8 @@ const distanceBetween = (a, b) => {
     }
     return Math.sqrt(sum)
   } else {
-    throw new Error("The operands must be of the same type, either number or array.")
+    throw new Error('The operands must be of the same type, either number or array.')
   }
-};
+}
 
-module.exports = lengths
+module.exports = lengths

package/src/curves/bezier/lengths.test.js

@@ -17,7 +17,7 @@ test('calculate lengths for a 1D linear bezier with numeric control points', (t)
 test('calculate lengths for a 1D linear bezier with array control points', (t) => {
   const bezierCurve = bezier.create([[0], [10]])
   const result = lengths(100, bezierCurve)
-  t.is(result.length, 101) 
+  t.is(result.length, 101)
   nearlyEqual(t, result[0], 0, 0.0001)
   nearlyEqual(t, result[50], 5, 0.0001)
   nearlyEqual(t, result[100], 10, 0.0001)
@@ -26,7 +26,7 @@ test('calculate lengths for a 1D linear bezier with array control points', (t) =
 test('calculate lengths for a 2D linear bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0], [10, 10]])
   const result = lengths(100, bezierCurve)
-  t.is(result.length, 101) 
+  t.is(result.length, 101)
   nearlyEqual(t, result[0], 0, 0.0001)
   nearlyEqual(t, result[50], 7.0710, 0.0001)
   nearlyEqual(t, result[100], 14.1421, 0.0001)
@@ -53,7 +53,7 @@ test('calculate lengths for a 2D cubic (4 control points) bezier', (t) => {
 test('calculate lengths for a 3D linear bezier', (t) => {
   const bezierCurve = bezier.create([[0, 0, 0], [10, 10, 10]])
   const result = lengths(100, bezierCurve)
-  t.is(result.length, 101) 
+  t.is(result.length, 101)
   nearlyEqual(t, result[0], 0, 0.0001)
   nearlyEqual(t, result[50], 8.6602, 0.0001)
   nearlyEqual(t, result[100], 17.3205, 0.0001)

package/src/geometries/geom2/transform.js

@@ -1,5 +1,7 @@
 const mat4 = require('../../maths/mat4')
 
+const reverse = require('./reverse.js')
+
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the sides, as this function only adjusts the transforms.
@@ -14,7 +16,13 @@ const mat4 = require('../../maths/mat4')
  */
 const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
-  return Object.assign({}, geometry, { transforms })
+  const transformed = Object.assign({}, geometry, { transforms })
+  // determine if the transform is mirroring in 2D
+  if (matrix[0] * matrix[5] - matrix[4] * matrix[1] < 0) {
+    // reverse the order to preserve the orientation
+    return reverse(transformed)
+  }
+  return transformed
 }
 
 module.exports = transform

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

@@ -2,7 +2,13 @@ const test = require('ava')
 
 const mat4 = require('../../maths/mat4')
 
-const { transform, fromPoints, toSides } = require('./index')
+const { measureArea } = require('../../measurements/index.js')
+
+const { mirrorX, mirrorY, mirrorZ } = require('../../operations/transforms/index.js')
+
+const { square } = require('../../primitives/index.js')
+
+const { fromPoints, transform, toOutlines, toSides } = require('./index.js')
 
 const { comparePoints, compareVectors } = require('../../../test/helpers/')
 
@@ -51,3 +57,54 @@ test('transform: adjusts the transforms of geom2', (t) => {
   t.true(comparePoints(another.sides[2], expected.sides[2]))
   t.true(compareVectors(another.transforms, expected.transforms))
 })
+
+test('transform: geom2 mirrorX', (t) => {
+  const geometry = square()
+  const transformed = mirrorX(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, 1], [-1, -1], [1, -1], [1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]]
+  ])
+})
+
+test('transform: geom2 mirrorY', (t) => {
+  const geometry = square()
+  const transformed = mirrorY(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we reversed the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[1, -1], [1, 1], [-1, 1], [-1, -1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]],
+    [[-1, 1], [-1, -1]]
+  ])
+})
+
+test('transform: geom2 mirrorZ', (t) => {
+  const geometry = square()
+  const transformed = mirrorZ(geometry)
+  t.is(measureArea(geometry), 4)
+  // area will be negative unless we DIDN'T reverse the points
+  t.is(measureArea(transformed), 4)
+  const pts = toOutlines(transformed)[0]
+  const exp = [[-1, -1], [1, -1], [1, 1], [-1, 1]]
+  t.true(comparePoints(pts, exp))
+  t.deepEqual(toSides(transformed), [
+    [[-1, 1], [-1, -1]],
+    [[-1, -1], [1, -1]],
+    [[1, -1], [1, 1]],
+    [[1, 1], [-1, 1]]
+  ])
+})

package/src/geometries/poly2/arePointsInside.js

@@ -80,11 +80,4 @@ const isPointInside = (point, polygon) => {
   return insideFlag
 }
 
-/*
- * > 0 : p2 is left of the line p0 -> p1
- * = 0 : p2 is on the line p0 -> p1
- * < 0 : p2 is right of the line p0 -> p1
- */
-const isLeft = (p0, p1, p2) => (p1[0] - p0[0]) * (p2[1] - p0[1]) - (p2[0] - p0[0]) * (p1[1] - p0[1])
-
 module.exports = arePointsInside

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,4 +1,3 @@
-const vec3 = require('../../maths/vec3')
 const vec4 = require('../../maths/vec4')
 
 const cache = new WeakMap()
@@ -10,7 +9,7 @@ const cache = new WeakMap()
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
 const measureBoundingSphere = (polygon) => {
-  let boundingSphere = cache.get(polygon)
+  const boundingSphere = cache.get(polygon)
   if (boundingSphere) return boundingSphere
 
   const vertices = polygon.vertices

package/src/maths/plane/fromNoisyPoints.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default fromNoisyPoints
+
+declare function fromNoisyPoints(out: Plane, ...vertices: Array<Vec3>): Plane

package/src/maths/plane/fromNoisyPoints.js

@@ -0,0 +1,106 @@
+const vec3 = require('../vec3')
+const fromNormalAndPoint = require('./fromNormalAndPoint')
+
+/**
+ * Create a best-fit plane from the given noisy vertices.
+ *
+ * NOTE: There are two possible orientations for every plane.
+ *       This function always produces positive orientations.
+ *
+ * See http://www.ilikebigbits.com for the original discussion
+ *
+ * @param {Plane} out - receiving plane
+ * @param {Array} vertices - list of vertices in any order or position
+ * @returns {Plane} out
+ * @alias module:modeling/maths/plane.fromNoisyPoints
+ */
+const fromNoisyPoints = (out, ...vertices) => {
+  out[0] = 0.0
+  out[1] = 0.0
+  out[2] = 0.0
+  out[3] = 0.0
+
+  // calculate the centroid of the vertices
+  // NOTE: out is the centriod
+  const n = vertices.length
+  vertices.forEach((v) => {
+    vec3.add(out, out, v)
+  })
+  vec3.scale(out, out, 1.0 / n)
+
+  // Calculate full 3x3 covariance matrix, excluding symmetries
+  let xx = 0.0
+  let xy = 0.0
+  let xz = 0.0
+  let yy = 0.0
+  let yz = 0.0
+  let zz = 0.0
+
+  const vn = vec3.create()
+  vertices.forEach((v) => {
+    // NOTE: out is the centriod
+    vec3.subtract(vn, v, out)
+    xx += vn[0] * vn[0]
+    xy += vn[0] * vn[1]
+    xz += vn[0] * vn[2]
+    yy += vn[1] * vn[1]
+    yz += vn[1] * vn[2]
+    zz += vn[2] * vn[2]
+  })
+
+  xx /= n
+  xy /= n
+  xz /= n
+  yy /= n
+  yz /= n
+  zz /= n
+
+  // Calculate the smallest Eigenvector of the covariance matrix
+  // which becomes the plane normal
+
+  vn[0] = 0.0
+  vn[1] = 0.0
+  vn[2] = 0.0
+
+  // weighted directional vector
+  const wdv = vec3.create()
+
+  // X axis
+  let det = yy * zz - yz * yz
+  wdv[0] = det
+  wdv[1] = xz * yz - xy * zz
+  wdv[2] = xy * yz - xz * yy
+
+  let weight = det * det
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // Y axis
+  det = xx * zz - xz * xz
+  wdv[0] = xz * yz - xy * zz
+  wdv[1] = det
+  wdv[2] = xy * xz - yz * xx
+
+  weight = det * det
+  if (vec3.dot(vn, wdv) < 0.0) {
+    weight = -weight
+  }
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // Z axis
+  det = xx * yy - xy * xy
+  wdv[0] = xy * yz - xz * yy
+  wdv[1] = xy * xz - yz * xx
+  wdv[2] = det
+
+  weight = det * det
+  if (vec3.dot(vn, wdv) < 0.0) {
+    weight = -weight
+  }
+  vec3.add(vn, vn, vec3.scale(wdv, wdv, weight))
+
+  // create the plane from normal and centriod
+  // NOTE: out is the centriod
+  return fromNormalAndPoint(out, vn, out)
+}
+
+module.exports = fromNoisyPoints

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

@@ -0,0 +1,24 @@
+const test = require('ava')
+const { fromNoisyPoints, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('plane: fromNoisyPoints() should return a new plane with correct values', (t) => {
+  const obs1 = fromNoisyPoints(create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+  t.true(compareVectors(obs1, [0, 0, 1, 0]))
+
+  const obs2 = fromNoisyPoints(obs1, [0, 6, 0], [0, 2, 2], [0, 6, 6])
+  t.true(compareVectors(obs2, [1, 0, 0, 0]))
+
+  // same vertices results in an invalid plane
+  const obs3 = fromNoisyPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
+  t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // co-linear vertices
+  const obs4 = fromNoisyPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
+
+  // random vertices
+  const obs5 = fromNoisyPoints(obs1, [0, 0, 0], [5, 1, -2], [3, -2, 4], [1, 1, 0])
+  t.true(compareVectors(obs5, [0.08054818365229491, 0.8764542170444571, 0.47469990050062555, 0.4185833634679763]))
+})

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

@@ -5,6 +5,7 @@ export { default as equals } from './equals'
 export { default as flip } from './flip'
 export { default as fromNormalAndPoint } from './fromNormalAndPoint'
 export { default as fromValues } from './fromValues'
+export { default as fromNoisyPoints } from './fromNoisyPoints'
 export { default as fromPoints } from './fromPoints'
 export { default as fromPointsRandom } from './fromPointsRandom'
 export { default as signedDistanceToPoint } from './signedDistanceToPoint'

package/src/maths/plane/index.js

@@ -32,6 +32,7 @@ module.exports = {
    * @function fromValues
    */
   fromValues: require('../vec4/fromValues'),
+  fromNoisyPoints: require('./fromNoisyPoints'),
   fromPoints: require('./fromPoints'),
   fromPointsRandom: require('./fromPointsRandom'),
   projectionOfPoint: require('./projectionOfPoint'),

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

@@ -25,7 +25,7 @@ class PolygonTreeNode {
     this.parent = parent
     this.children = []
     this.polygon = polygon
-    this.removed = false  // state of branch or leaf
+    this.removed = false // state of branch or leaf
   }
 
   // fill the tree with polygons. Should be called on the root node only; child nodes must

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

@@ -53,7 +53,7 @@ test('expand: round-expanding a bent line produces expected geometry', (t) => {
   const expandedPoints = geom2.toPoints(expandedPathGeom2)
 
   t.notThrows(() => geom2.validate(expandedPathGeom2))
-  const expectedArea = 56 + TAU  * delta * 1.25 // shape will have 1 and 1/4 circles
+  const expectedArea = 56 + TAU * delta * 1.25 // shape will have 1 and 1/4 circles
   nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
   const boundingBox = measureBoundingBox(expandedPathGeom2)
   t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))

package/src/operations/extrusions/extrudeHelical.js

@@ -40,7 +40,7 @@ const extrudeHelical = (options, geometry) => {
 
   let pitch
   // ignore height if pitch is set
-  if(!options.pitch && options.height) {
+  if (!options.pitch && options.height) {
     pitch = options.height / (angle / TAU)
   } else {
     pitch = options.pitch ? options.pitch : defaults.pitch
@@ -49,18 +49,17 @@ const extrudeHelical = (options, geometry) => {
   // needs at least 3 segments for each revolution
   const minNumberOfSegments = 3
 
-  if (segmentsPerRotation < minNumberOfSegments)
-    throw new Error(`The number of segments per rotation needs to be at least 3.`)
+  if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
-  let shapeSides = geom2.toSides(geometry)
+  const shapeSides = geom2.toSides(geometry)
   if (shapeSides.length === 0) throw new Error('the given geometry cannot be empty')
 
   // const pointsWithNegativeX = shapeSides.filter((s) => (s[0][0] < 0))
   const pointsWithPositiveX = shapeSides.filter((s) => (s[0][0] >= 0))
-  
+
   let baseSlice = slice.fromSides(shapeSides)
-  
-  if(pointsWithPositiveX.length === 0) {
+
+  if (pointsWithPositiveX.length === 0) {
     // only points in negative x plane, reverse
     baseSlice = slice.reverse(baseSlice)
   }