@jscad/modeling 2.9.6 → 2.10.0

package/src/maths/mat4/isOnlyTransformScale.js

@@ -1,7 +1,7 @@
 
 /**
  * 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.
+ * 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

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

@@ -1,9 +1,11 @@
 const test = require('ava')
 
+const { TAU } = require('../constants')
+
 const { isOnlyTransformScale, create, fromTranslation, fromTaitBryanRotation, fromScaling, invert, multiply } = require('./index')
 
 test('mat4: isOnlyTransformScale() should return true for right angles', (t) => {
-  let someRotation = fromTaitBryanRotation(create(), Math.PI, 0, 0)
+  let someRotation = fromTaitBryanRotation(create(), TAU / 2, 0, 0)
   t.true(isOnlyTransformScale(someRotation))
   t.true(isOnlyTransformScale(invert(create(), someRotation)))
 

package/src/maths/rotation.test.js

@@ -2,15 +2,18 @@ const test = require('ava')
 
 const { compareVectors } = require('../../test/helpers/index')
 
-const { mat4, vec2, vec3 } = require('./index')
+const { constants, mat4, vec2, vec3 } = require('./index')
 
 // ALL POSITIVE ROTATIONS ARE CLOCKWISE
 // see https://webglfundamentals.org/webgl/lessons/webgl-3d-orthographic.html
 // IN A LEFT-HANDED COORDINATE SYSTEM
 
+// JSCAD IS RIGHT-HANDED COORDINATE SYSTEM
+// WHERE POSITIVE ROTATIONS ARE COUNTER-CLOCKWISE
+
 // identity matrices for comparisons
 
-const rad90 = Math.PI / 2
+const rad90 = constants.TAU / 4
 
 // +90 degree rotation about X
 const cwX90Matrix = [

package/src/maths/utils/trigonometry.js

@@ -6,28 +6,28 @@ const { NEPS } = require('../constants')
 const rezero = (n) => Math.abs(n) < NEPS ? 0 : n
 
 /**
- * Return Math.sin but accurate for 90 degree rotations.
+ * Return Math.sin but accurate for TAU / 4 rotations.
  * Fixes rounding errors when sin should be 0.
  *
  * @param {Number} radians - angle in radians
  * @returns {Number} sine of the given angle
  * @alias module:modeling/utils.sin
  * @example
- * sin(Math.PI) == 0
- * sin(2 * Math.PI) == 0
+ * sin(TAU / 2) == 0
+ * sin(TAU) == 0
  */
 const sin = (radians) => rezero(Math.sin(radians))
 
 /**
- * Return Math.cos but accurate for 90 degree rotations.
+ * Return Math.cos but accurate for TAU / 4 rotations.
  * Fixes rounding errors when cos should be 0.
  *
  * @param {Number} radians - angle in radians
  * @returns {Number} cosine of the given angle
  * @alias module:modeling/utils.cos
  * @example
- * cos(0.5 * Math.PI) == 0
- * cos(1.5 * Math.PI) == 0
+ * cos(TAU * 0.25) == 0
+ * cos(TAU * 0.75) == 0
  */
 const cos = (radians) => rezero(Math.cos(radians))
 

package/src/maths/utils/trigonometry.test.js

@@ -1,14 +1,16 @@
 const test = require('ava')
 
+const { TAU } = require('../constants')
+
 const { cos, sin } = require('./trigonometry')
 
 test('utils: sin() should return rounded values', (t) => {
   t.is(sin(0), 0)
   t.is(sin(9), Math.sin(9))
-  t.is(sin(0.5 * Math.PI), 1)
-  t.is(sin(1.0 * Math.PI), 0)
-  t.is(sin(1.5 * Math.PI), -1)
-  t.is(sin(2.0 * Math.PI), 0)
+  t.is(sin(0.25 * TAU), 1)
+  t.is(sin(0.5 * TAU), 0)
+  t.is(sin(0.75 * TAU), -1)
+  t.is(sin(TAU), 0)
   t.is(sin(NaN), NaN)
   t.is(sin(Infinity), NaN)
 })
@@ -16,10 +18,10 @@ test('utils: sin() should return rounded values', (t) => {
 test('utils: cos() should return rounded values', (t) => {
   t.is(cos(0), 1)
   t.is(cos(9), Math.cos(9))
-  t.is(cos(0.5 * Math.PI), 0)
-  t.is(cos(1.0 * Math.PI), -1)
-  t.is(cos(1.5 * Math.PI), 0)
-  t.is(cos(2.0 * Math.PI), 1)
+  t.is(cos(0.25 * TAU), 0)
+  t.is(cos(0.5 * TAU), -1)
+  t.is(cos(0.75 * TAU), 0)
+  t.is(cos(TAU), 1)
   t.is(cos(NaN), NaN)
   t.is(cos(Infinity), NaN)
 })

package/src/maths/vec2/fromAngleDegrees.js

@@ -8,6 +8,6 @@ const fromAngleRadians = require('./fromAngleRadians')
  * @returns {vec2} out
  * @alias module:modeling/maths/vec2.fromAngleDegrees
  */
-const fromAngleDegrees = (out, degrees) => fromAngleRadians(out, Math.PI * degrees / 180)
+const fromAngleDegrees = (out, degrees) => fromAngleRadians(out, degrees * 0.017453292519943295)
 
 module.exports = fromAngleDegrees

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

@@ -1,4 +1,7 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { fromAngleRadians, create } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
@@ -7,6 +10,6 @@ test('vec2: fromAngleRadians() should return a new vec2 with correct values', (t
   const obs1 = fromAngleRadians(create(), 0)
   t.true(compareVectors(obs1, [1.0, 0.0]))
 
-  const obs2 = fromAngleRadians(obs1, Math.PI)
+  const obs2 = fromAngleRadians(obs1, TAU / 2)
   t.true(compareVectors(obs2, [-1, 1.2246468525851679e-16]))
 })

package/src/maths/vec2/normal.js

@@ -1,3 +1,5 @@
+const { TAU } = require('../constants')
+
 const create = require('./create')
 const rotate = require('./rotate')
 
@@ -10,6 +12,6 @@ const rotate = require('./rotate')
  * @returns {vec2} out
  * @alias module:modeling/maths/vec2.normal
  */
-const normal = (out, vector) => rotate(out, vector, create(), (Math.PI / 2))
+const normal = (out, vector) => rotate(out, vector, create(), (TAU / 4))
 
 module.exports = normal

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

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotate, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec2: rotate() called with three parameters should update a vec2 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0)
   const ret1 = rotate(obs1, [0, 0], [0, 0], 0)

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

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateX, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateX() called with four parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateX(obs1, [0, 0, 0], [0, 0, 0], 0)

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

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateY, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateY() called with three parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateY(obs1, [0, 0, 0], [0, 0, 0], 0)

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

@@ -1,10 +1,13 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+
 const { rotateZ, fromValues } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
 
 test('vec3: rotateZ() called with four parameters should update a vec3 with correct values', (t) => {
-  const radians = 90 * Math.PI / 180
+  const radians = TAU / 4
 
   const obs1 = fromValues(0, 0, 0)
   const ret1 = rotateZ(obs1, [0, 0, 0], [0, 0, 0], 0)

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

@@ -1,9 +1,11 @@
 const test = require('ava')
 
 const { comparePoints, nearlyEqual } = require('../../../test/helpers')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 const measureBoundingBox = require('../../measurements/measureBoundingBox')
 const area = require('../../maths/utils/area')
+const { TAU } = require('../../maths/constants')
 const sphere = require('../../primitives/sphere')
 
 const { expand } = require('./index')
@@ -51,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 + 2 * Math.PI * 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/expansions/expandShell.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../../maths/constants')
+const { EPS, TAU } = require('../../maths/constants')
 
 const mat4 = require('../../maths/mat4')
 const vec3 = require('../../maths/vec3')
@@ -120,7 +120,7 @@ const expandShell = (options, geometry) => {
 
     // first of all equally spaced around the cylinder:
     for (let i = 0; i < segments; i++) {
-      addUniqueAngle(angles, (i * Math.PI * 2 / segments))
+      addUniqueAngle(angles, (i * TAU / segments))
     }
 
     // and also at every normal of all touching planes:
@@ -130,10 +130,10 @@ const expandShell = (options, geometry) => {
       const co = vec3.dot(xbase, planenormal)
       let angle = Math.atan2(si, co)
 
-      if (angle < 0) angle += Math.PI * 2
+      if (angle < 0) angle += TAU
       addUniqueAngle(angles, angle)
       angle = Math.atan2(-si, -co)
-      if (angle < 0) angle += Math.PI * 2
+      if (angle < 0) angle += TAU
       addUniqueAngle(angles, angle)
     }
 

package/src/operations/expansions/offsetFromPoints.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../../maths/constants')
+const { EPS, TAU } = require('../../maths/constants')
 
 const intersect = require('../../maths/utils/intersect')
 const line2 = require('../../maths/line2')
@@ -139,7 +139,7 @@ const offsetFromPoints = (options, points) => {
 
       if (rotation !== 0.0) {
         // generate the segments
-        cornersegments = Math.floor(segments * (Math.abs(rotation) / (2 * Math.PI)))
+        cornersegments = Math.floor(segments * (Math.abs(rotation) / TAU))
         const step = rotation / cornersegments
         const start = vec2.angle(vec2.subtract(v0, corner.s0[1], corner.c))
         const cornerpoints = []

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

@@ -2,6 +2,7 @@ const test = require('ava')
 
 const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
 
+const { TAU } = require('../../maths/constants')
 const mat4 = require('../../maths/mat4')
 
 const { geom2, geom3, poly3 } = require('../../geometries')
@@ -56,10 +57,10 @@ test('extrudeFromSlices (torus)', (t) => {
   hex = poly3.transform(mat4.fromTranslation(mat4.create(), [0, 20, 0]), hex)
   hex = slice.fromPoints(poly3.toPoints(hex))
 
-  const angle = Math.PI / 4
+  const angle = TAU / 8
   const geometry3 = extrudeFromSlices(
     {
-      numberOfSlices: Math.PI * 2 / angle,
+      numberOfSlices: TAU / angle,
       capStart: false,
       capEnd: false,
       close: true,

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

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const comparePolygonsAsPoints = require('../../../test/helpers/comparePolygonsAsPoints')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { extrudeLinear } = require('./index')
@@ -77,7 +79,7 @@ test('extrudeLinear (no twist)', (t) => {
 test('extrudeLinear (twist)', (t) => {
   const geometry2 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
 
-  let geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / -4 }, geometry2)
+  let geometry3 = extrudeLinear({ height: 15, twistAngle: -TAU / 8 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   let exp = [
     [[5, -5, 0], [5, 5, 0], [7.0710678118654755, 4.440892098500626e-16, 15]],
@@ -105,7 +107,7 @@ test('extrudeLinear (twist)', (t) => {
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 3 }, geometry2)
+  geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 4, twistSteps: 3 }, geometry2)
   pts = geom3.toPoints(geometry3)
   exp = [
     [[5, -5, 0], [5, 5, 0], [1.830127018922194, 6.830127018922193, 5]],
@@ -140,7 +142,7 @@ test('extrudeLinear (twist)', (t) => {
   t.is(pts.length, 28)
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 30 }, geometry2)
+  geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 244)

package/src/operations/extrusions/extrudeRectangular.js

@@ -18,7 +18,7 @@ const extrudeRectangularGeom2 = require('./extrudeRectangularGeom2')
  *
  * @example
  * let mywalls = extrudeRectangular({size: 1, height: 3}, square({size: 20}))
- * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: Math.PI}, square({size: 20}))
+ * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: TAU / 2}, square({size: 20}))
  */
 const extrudeRectangular = (options, ...objects) => {
   const defaults = {

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

@@ -1,5 +1,7 @@
 const test = require('ava')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3 } = require('../../geometries')
 
 const { arc, rectangle } = require('../../primitives')
@@ -7,7 +9,7 @@ const { arc, rectangle } = require('../../primitives')
 const { extrudeRectangular } = require('./index')
 
 test('extrudeRectangular (defaults)', (t) => {
-  const geometry1 = arc({ radius: 5, endAngle: Math.PI / 2, segments: 16 })
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
   const geometry2 = rectangle({ size: [5, 5] })
 
   let obs = extrudeRectangular({ }, geometry1)
@@ -22,7 +24,7 @@ test('extrudeRectangular (defaults)', (t) => {
 })
 
 test('extrudeRectangular (chamfer)', (t) => {
-  const geometry1 = arc({ radius: 5, endAngle: Math.PI / 2, segments: 16 })
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
   const geometry2 = rectangle({ size: [5, 5] })
 
   let obs = extrudeRectangular({ corners: 'chamfer' }, geometry1)
@@ -37,7 +39,7 @@ test('extrudeRectangular (chamfer)', (t) => {
 })
 
 test('extrudeRectangular (segments = 8, round)', (t) => {
-  const geometry1 = arc({ radius: 5, endAngle: Math.PI / 2, segments: 16 })
+  const geometry1 = arc({ radius: 5, endAngle: TAU / 4, segments: 16 })
   const geometry2 = rectangle({ size: [5, 5] })
 
   let obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry1)

package/src/operations/extrusions/extrudeRotate.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../../maths/constants')
 const mat4 = require('../../maths/mat4')
 
 const { mirrorX } = require('../transforms/mirror')
@@ -12,7 +13,7 @@ const extrudeFromSlices = require('./extrudeFromSlices')
  * Rotate extrude the given geometry using the given options.
  *
  * @param {Object} options - options for extrusion
- * @param {Number} [options.angle=PI*2] - angle of the extrusion (RADIANS)
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS)
  * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
  * @param {String} [options.overflow='cap'] - what to do with points outside of bounds (+ / - x) :
  * defaults to capping those points to 0 (only supported behaviour for now)
@@ -22,24 +23,24 @@ const extrudeFromSlices = require('./extrudeFromSlices')
  * @alias module:modeling/extrusions.extrudeRotate
  *
  * @example
- * const myshape = extrudeRotate({segments: 8, angle: Math.PI}, circle({size: 3, center: [4, 0]}))
+ * const myshape = extrudeRotate({segments: 8, angle: TAU / 2}, circle({size: 3, center: [4, 0]}))
  */
 const extrudeRotate = (options, geometry) => {
   const defaults = {
     segments: 12,
     startAngle: 0,
-    angle: (Math.PI * 2),
+    angle: TAU,
     overflow: 'cap'
   }
   let { segments, startAngle, angle, overflow } = Object.assign({}, defaults, options)
 
   if (segments < 3) throw new Error('segments must be greater then 3')
 
-  startAngle = Math.abs(startAngle) > (Math.PI * 2) ? startAngle % (Math.PI * 2) : startAngle
-  angle = Math.abs(angle) > (Math.PI * 2) ? angle % (Math.PI * 2) : angle
+  startAngle = Math.abs(startAngle) > TAU ? startAngle % TAU : startAngle
+  angle = Math.abs(angle) > TAU ? angle % TAU : angle
 
   let endAngle = startAngle + angle
-  endAngle = Math.abs(endAngle) > (Math.PI * 2) ? endAngle % (Math.PI * 2) : endAngle
+  endAngle = Math.abs(endAngle) > TAU ? endAngle % TAU : endAngle
 
   if (endAngle < startAngle) {
     const x = startAngle
@@ -47,11 +48,11 @@ const extrudeRotate = (options, geometry) => {
     endAngle = x
   }
   let totalRotation = endAngle - startAngle
-  if (totalRotation <= 0.0) totalRotation = (Math.PI * 2)
+  if (totalRotation <= 0.0) totalRotation = TAU
 
-  if (Math.abs(totalRotation) < (Math.PI * 2)) {
+  if (Math.abs(totalRotation) < TAU) {
     // adjust the segments to achieve the total rotation requested
-    const anglePerSegment = (Math.PI * 2) / segments
+    const anglePerSegment = TAU / segments
     segments = Math.floor(Math.abs(totalRotation) / anglePerSegment)
     if (Math.abs(totalRotation) > (segments * anglePerSegment)) segments++
   }
@@ -108,18 +109,18 @@ const extrudeRotate = (options, geometry) => {
   }
 
   const rotationPerSlice = totalRotation / segments
-  const isCapped = Math.abs(totalRotation) < (Math.PI * 2)
+  const isCapped = Math.abs(totalRotation) < TAU
   const baseSlice = slice.fromSides(geom2.toSides(geometry))
   slice.reverse(baseSlice, baseSlice)
 
   const matrix = mat4.create()
   const createSlice = (progress, index, base) => {
     let Zrotation = rotationPerSlice * index + startAngle
-    // fix rounding error when rotating 2 * PI radians
-    if (totalRotation === Math.PI * 2 && index === segments) {
+    // fix rounding error when rotating TAU radians
+    if (totalRotation === TAU && index === segments) {
       Zrotation = startAngle
     }
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), Math.PI / 2))
+    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), TAU / 4))
 
     return slice.transform(matrix, base)
   }

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

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3 } = require('../../geometries')
 
 const { extrudeRotate } = require('./index')
@@ -19,7 +21,7 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
 
   // test angle
-  let geometry3 = extrudeRotate({ segments: 4, angle: Math.PI / 4 }, geometry2)
+  let geometry3 = extrudeRotate({ segments: 4, angle: TAU / 8 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   const exp = [
     [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
@@ -54,7 +56,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
   const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
 
   // test startAngle
-  let geometry3 = extrudeRotate({ segments: 5, startAngle: Math.PI / 4 }, geometry2)
+  let geometry3 = extrudeRotate({ segments: 5, startAngle: TAU / 8 }, geometry2)
   let pts = geom3.toPoints(geometry3)
   let exp = [
     [7.0710678118654755, 7.071067811865475, 8],
@@ -65,7 +67,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 
-  geometry3 = extrudeRotate({ segments: 5, startAngle: Math.PI / -4 }, geometry2)
+  geometry3 = extrudeRotate({ segments: 5, startAngle: -TAU / 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
   exp = [
     [7.0710678118654755, -7.071067811865475, 8],
@@ -110,7 +112,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   // overlap of Y axis; even number of + and - points
   let geometry = geom2.fromPoints([[-1, 8], [-1, -8], [7, -8], [7, 8]])
 
-  let obs = extrudeRotate({ segments: 4, angle: Math.PI / 2 }, geometry)
+  let obs = extrudeRotate({ segments: 4, angle: TAU / 4 }, geometry)
   let pts = geom3.toPoints(obs)
   let exp = [
     [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
@@ -129,7 +131,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   // overlap of Y axis; larger number of - points
   geometry = geom2.fromPoints([[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]])
 
-  obs = extrudeRotate({ segments: 8, angle: Math.PI / 2 }, geometry)
+  obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry)
   pts = geom3.toPoints(obs)
   exp = [
     [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],

package/src/operations/extrusions/slice/calculatePlane.test.js

@@ -1,5 +1,6 @@
 const test = require('ava')
 
+const { TAU } = require('../../../maths/constants')
 const { mat4 } = require('../../../maths')
 
 const { calculatePlane, fromPoints, transform } = require('./index')
@@ -15,11 +16,11 @@ test('slice: calculatePlane() returns correct plans for various slices', (t) =>
   const plane2 = calculatePlane(slice2)
   t.true(compareVectors(plane2, [0, 0, 1, 0]))
 
-  const slice3 = transform(mat4.fromXRotation(mat4.create(), Math.PI / 2), slice2)
+  const slice3 = transform(mat4.fromXRotation(mat4.create(), TAU / 4), slice2)
   const plane3 = calculatePlane(slice3)
   t.true(compareVectors(plane3, [0, -1, 0, 0]))
 
-  const slice4 = transform(mat4.fromZRotation(mat4.create(), Math.PI / 2), slice3)
+  const slice4 = transform(mat4.fromZRotation(mat4.create(), TAU / 4), slice3)
   const plane4 = calculatePlane(slice4)
   t.true(compareVectors(plane4, [1, 0, 0, 0]))
 

package/src/operations/extrusions/slice/index.js

@@ -1,4 +1,6 @@
 /**
+ * Represents a 3D geometry consisting of a list of edges.
+ * @see {@link slice} for data structure information.
  * @module modeling/extrusions/slice
  */
 module.exports = {

package/src/operations/modifiers/generalize.d.ts

@@ -0,0 +1,12 @@
+import { Geometry } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export interface GeneralizeOptions {
+  snap?: boolean
+  simplify?: boolean
+  triangulate?: boolean
+}
+
+export function generalize<T extends Geometry>(options: GeneralizeOptions, geometry: T): T
+export function generalize<T extends Geometry>(options: GeneralizeOptions, ...geometries: RecursiveArray<T>): Array<T>
+export function generalize(options: GeneralizeOptions, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/modifiers/generalize.test.js

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom3 } = require('../../geometries')
 
 const { cuboid } = require('../../primitives')
@@ -9,7 +11,7 @@ const { cuboid } = require('../../primitives')
 const { generalize } = require('./index')
 
 test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
-  const geometry1 = cuboid({ size: [Math.PI, Math.PI / 2, Math.PI * 2] })
+  const geometry1 = cuboid({ size: [TAU / 2, TAU / 4, TAU] })
 
   // apply no modifications
   let result = generalize({}, geometry1)

package/src/operations/modifiers/index.d.ts

@@ -0,0 +1,2 @@
+export { default as generalize } from './generalize'
+export { default as snap } from './snap'

package/src/operations/modifiers/snap.d.ts

@@ -0,0 +1,6 @@
+import { Geometry } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export function snap<T extends Geometry>(geometry: T): T
+export function snap<T extends Geometry>(...geometries: RecursiveArray<T>): Array<T>
+export function snap(...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/modifiers/snap.test.js

@@ -2,6 +2,8 @@ const test = require('ava')
 
 const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { arc, rectangle, cuboid } = require('../../primitives')
@@ -12,7 +14,7 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry1 = path2.create()
   const geometry2 = arc({ radius: 1 / 2, segments: 8 })
   const geometry3 = arc({ radius: 1.3333333333333333 / 2, segments: 8 })
-  const geometry4 = arc({ radius: Math.PI * 1000 / 2, segments: 8 })
+  const geometry4 = arc({ radius: TAU / 4 * 1000, segments: 8 })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 4)
@@ -56,7 +58,7 @@ test('snap: snap of a geom2 produces an expected geom2', (t) => {
   const geometry1 = geom2.create()
   const geometry2 = rectangle({ size: [1, 1, 1] })
   const geometry3 = rectangle({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
-  const geometry4 = rectangle({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
+  const geometry4 = rectangle({ size: [TAU / 2 * 1000, TAU / 2 * 1000, TAU / 2 * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 4)
@@ -88,7 +90,7 @@ test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [1, 1, 1] })
   const geometry3 = cuboid({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
-  const geometry4 = cuboid({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
+  const geometry4 = cuboid({ size: [TAU / 2 * 1000, TAU / 2 * 1000, TAU / 2 * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 4)

package/src/operations/transforms/rotate.js

@@ -14,7 +14,7 @@ const path2 = require('../../geometries/path2')
  * @alias module:modeling/transforms.rotate
  *
  * @example
- * const newsphere = rotate([Math.PI / 4, 0, 0], sphere())
+ * const newsphere = rotate([TAU / 8, 0, 0], sphere())
  */
 const rotate = (angles, ...objects) => {
   if (!Array.isArray(angles)) throw new Error('angles must be an array')