@jscad/modeling 2.9.6 → 2.11.0

package/src/operations/extrusions/extrudeHelical.js

@@ -0,0 +1,114 @@
+const { TAU } = require('../../maths/constants')
+const slice = require('./slice')
+const mat4 = require('../../maths/mat4')
+const extrudeFromSlices = require('./extrudeFromSlices')
+const geom2 = require('../../geometries/geom2')
+
+/**
+ * Perform a helical extrude of the geometry, using the given options.
+ *
+ * @param {Object} options - options for extrusion
+ * @param {Number} [options.angle=TAU] - angle of the extrusion (RADIANS) positive for right-hand rotation, negative for left-hand
+ * @param {Number} [options.startAngle=0] - start angle of the extrusion (RADIANS)
+ * @param {Number} [options.pitch=10] - elevation gain for each turn
+ * @param {Number} [options.height] - total height of the helix path. Ignored if pitch is set.
+ * @param {Number} [options.endOffset=0] - offset the final radius of the extrusion, allowing for tapered helix, and or spiral
+ * @param {Number} [options.segmentsPerRotation=32] - number of segments per full rotation of the extrusion
+ * @param {geom2} geometry - the geometry to extrude
+ * @returns {geom3} the extruded geometry
+ * @alias module:modeling/extrusions.extrudeHelical
+ *
+ * @example
+ * const myshape = extrudeHelical(
+ *  {
+ *      angle: Math.PI * 4,
+ *      pitch: 10,
+ *      segmentsPerRotation: 64
+ *  },
+ *  circle({size: 3, center: [10, 0]})
+ * )
+ */
+const extrudeHelical = (options, geometry) => {
+  const defaults = {
+    angle: TAU,
+    startAngle: 0,
+    pitch: 10,
+    endOffset: 0,
+    segmentsPerRotation: 32
+  }
+  const { angle, endOffset, segmentsPerRotation, startAngle } = Object.assign({}, defaults, options)
+
+  let pitch
+  // ignore height if pitch is set
+  if(!options.pitch && options.height) {
+    pitch = options.height / (angle / TAU)
+  } else {
+    pitch = options.pitch ? options.pitch : defaults.pitch
+  }
+
+  // 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.`)
+
+  let 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) {
+    // only points in negative x plane, reverse
+    baseSlice = slice.reverse(baseSlice)
+  }
+
+  const calculatedSegments = Math.round(segmentsPerRotation / TAU * Math.abs(angle))
+  const segments = calculatedSegments >= 2 ? calculatedSegments : 2
+  // define transform matrix variables for performance increase
+  const step1 = mat4.create()
+  let matrix
+  const sliceCallback = (progress, index, base) => {
+    const zRotation = startAngle + angle / segments * index
+    const xOffset = endOffset / segments * index
+    const zOffset = (zRotation - startAngle) / TAU * pitch
+
+    // TODO: check for valid geometry after translations
+    // ie all the points have to be either x > -xOffset or x < -xOffset
+    // this would have to be checked for every transform, and handled
+    //
+    // not implementing, as this currently doesn't break anything,
+    // only creates inside-out polygons
+
+    // create transformation matrix
+    mat4.multiply(
+      step1,
+      // then apply offsets
+      mat4.fromTranslation(mat4.create(), [xOffset, 0, zOffset * Math.sign(angle)]),
+      // first rotate "flat" 2D shape from XY to XZ plane
+      mat4.fromXRotation(mat4.create(), -TAU / 4 * Math.sign(angle)) // rotate the slice correctly to not create inside-out polygon
+    )
+
+    matrix = mat4.create()
+    mat4.multiply(
+      matrix,
+      // finally rotate around Z axis
+      mat4.fromZRotation(mat4.create(), zRotation),
+      step1
+    )
+    return slice.transform(matrix, base)
+  }
+
+  return extrudeFromSlices(
+    {
+      // "base" slice is counted as segment, so add one for complete final rotation
+      numberOfSlices: segments + 1,
+      callback: sliceCallback
+    },
+    baseSlice
+  )
+}
+
+module.exports = extrudeHelical

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

@@ -0,0 +1,62 @@
+const test = require('ava')
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+const { TAU } = require('../../maths/constants')
+const { geom2, geom3 } = require('../../geometries')
+const { circle } = require('../../primitives')
+
+const { extrudeHelical } = require('./index')
+
+test('extrudeHelical: (defaults) extruding of a geom2 produces an expected geom3', (t) => {
+    const geometry2 = geom2.fromPoints([[10, 8], [10, -8], [26, -8], [26, 8]])
+
+    const geometry3 = extrudeHelical({}, geometry2)
+    const pts = geom3.toPoints(geometry3)
+    t.notThrows(() => geom3.validate(geometry3))
+})
+
+test('extrudeHelical: (defaults) extruding of a circle produces an expected geom3', (t) => {
+    const geometry2 = circle({ size: 3, center: [10, 0] })
+
+    const geometry3 = extrudeHelical({}, geometry2)
+    t.notThrows(() => geom3.validate(geometry3))
+})
+
+test('extrudeHelical: (angle) extruding of a circle produces an expected geom3', (t) => {
+    const maxRevolutions = 10
+    const geometry2 = circle({ size: 3, center: [10, 0] })
+    for (const index of [...Array(maxRevolutions).keys()]) {
+        // also test negative angles
+        const geometry3 = extrudeHelical({angle: TAU * (index - maxRevolutions / 2)}, geometry2)
+        t.notThrows(() => geom3.validate(geometry3))
+    }
+})
+
+test('extrudeHelical: (pitch) extruding of a circle produces an expected geom3', (t) => {
+    const startPitch = -10
+    const geometry2 = circle({ size: 3, center: [10, 0] })
+    for (const index of [...Array(20).keys()]) {
+        // also test negative pitches
+        const geometry3 = extrudeHelical({pitch: startPitch + index}, geometry2)
+        t.notThrows(() => geom3.validate(geometry3))
+    }
+})
+
+test('extrudeHelical: (endRadiusOffset) extruding of a circle produces an expected geom3', (t) => {
+    const startOffset = -5
+    const geometry2 = circle({ size: 3, center: [10, 0] })
+    for (const index of [...Array(10).keys()]) {
+        // also test negative pitches
+        const geometry3 = extrudeHelical({endRadiusOffset: startOffset + index}, geometry2)
+        t.notThrows(() => geom3.validate(geometry3))
+    }
+})
+
+test('extrudeHelical: (segments) extruding of a circle produces an expected geom3', (t) => {
+    const startSegments = 3
+    const geometry2 = circle({ size: 3, center: [10, 0] })
+    for (const index of [...Array(30).keys()]) {
+        // also test negative pitches
+        const geometry3 = extrudeHelical({segments: startSegments + index}, geometry2)
+        t.notThrows(() => geom3.validate(geometry3))
+    }
+})

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/index.js

@@ -10,6 +10,7 @@ module.exports = {
   extrudeLinear: require('./extrudeLinear'),
   extrudeRectangular: require('./extrudeRectangular'),
   extrudeRotate: require('./extrudeRotate'),
+  extrudeHelical: require('./extrudeHelical'),
   project: require('./project'),
   slice: require('./slice')
 }

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')

package/src/operations/transforms/rotate.test.js

@@ -1,5 +1,7 @@
 const test = require('ava')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { rotate, rotateX, rotateY, rotateZ } = require('./index')
@@ -10,7 +12,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[1, 0], [0, 1], [-1, 0]])
 
   // rotate about Z
-  let rotated = rotate([0, 0, Math.PI / 2], geometry)
+  let rotated = rotate([0, 0, TAU / 4], geometry)
   let obs = path2.toPoints(rotated)
   const exp = [
     new Float32Array([0, 1]),
@@ -19,7 +21,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
   ]
   t.true(comparePoints(obs, exp))
 
-  rotated = rotateZ(Math.PI / 2, geometry)
+  rotated = rotateZ(TAU / 4, geometry)
   obs = path2.toPoints(rotated)
   t.notThrows(() => path2.validate(rotated))
   t.true(comparePoints(obs, exp))
@@ -29,7 +31,7 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
   const geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
 
   // rotate about Z
-  let rotated = rotate([0, 0, -Math.PI / 2], geometry)
+  let rotated = rotate([0, 0, -TAU / 4], geometry)
   let obs = geom2.toPoints(rotated)
   const exp = [
     new Float32Array([0, 0]),
@@ -39,7 +41,7 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
   t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 
-  rotated = rotateZ(-Math.PI / 2, geometry)
+  rotated = rotateZ(-TAU / 4, geometry)
   obs = geom2.toPoints(rotated)
   t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
@@ -57,7 +59,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   const geometry = geom3.fromPoints(points)
 
   // rotate about X
-  let rotated = rotate([Math.PI / 2], geometry)
+  let rotated = rotate([TAU / 4], geometry)
   let obs = geom3.toPoints(rotated)
   let exp = [
     [[-2, 12, -7.000000000000001], [-2, -18, -6.999999999999999],
@@ -76,13 +78,13 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateX(Math.PI / 2, geometry)
+  rotated = rotateX(TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
-  rotated = rotate([0, -Math.PI / 2], geometry)
+  rotated = rotate([0, -TAU / 4], geometry)
   obs = geom3.toPoints(rotated)
   exp = [
     [[12, -7, -2.000000000000001], [-18, -7, -1.999999999999999],
@@ -101,12 +103,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateY(-Math.PI / 2, geometry)
+  rotated = rotateY(-TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Z
-  rotated = rotate([0, 0, Math.PI], geometry)
+  rotated = rotate([0, 0, TAU / 2], geometry)
   obs = geom3.toPoints(rotated)
   exp = [
     [[2.000000000000001, 7, -12], [2.000000000000001, 7, 18],
@@ -125,7 +127,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateZ(Math.PI, geometry)
+  rotated = rotateZ(TAU / 2, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -136,7 +138,7 @@ test('rotate: rotating of multiple objects produces expected changes', (t) => {
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
   const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
 
-  const rotated = rotate([0, 0, Math.PI / 2], junk, geometry1, geometry2)
+  const rotated = rotate([0, 0, TAU / 4], junk, geometry1, geometry2)
 
   t.is(rotated[0], junk)
 

package/src/operations/transforms/transform.js

@@ -12,7 +12,7 @@ const path2 = require('../../geometries/path2')
  * @alias module:modeling/transforms.transform
  *
  * @example
- * const newsphere = transform(mat4.rotateX(Math.PI/4), sphere())
+ * const newsphere = transform(mat4.rotateX(TAU / 8), sphere())
  */
 const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?