@jscad/modeling 2.9.4 → 2.10.0

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,21 +21,21 @@ 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, 4.898587196589413e-16, 8], [26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8]],
-    [[10, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [10, 4.898587196589413e-16, 8], [7.0710678118654755, 7.071067811865475, 8]],
-    [[10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [10, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8]],
-    [[26, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [26, -4.898587196589413e-16, -8], [18.38477631085024, 18.384776310850235, -8]],
-    [[26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
-    [[7.071067811865476, 7.0710678118654755, -8], [7.071067811865476, 7.0710678118654755, 8], [18.384776310850242, 18.384776310850235, 8]],
-    [[18.384776310850242, 18.384776310850235, 8], [18.384776310850242, 18.384776310850235, -8], [7.071067811865476, 7.0710678118654755, -8]],
-    [[26, 4.898587196589413e-16, 8], [10, 4.898587196589413e-16, 8], [10, -4.898587196589413e-16, -8]],
-    [[10, -4.898587196589413e-16, -8], [26, -4.898587196589413e-16, -8], [26, 4.898587196589413e-16, 8]]
+    [[10, 0, 8], [26, 0, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[10, 0, 8], [18.38477631085024, 18.384776310850235, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [10, 0, 8], [7.0710678118654755, 7.071067811865475, 8]],
+    [[10, 0, -8], [7.0710678118654755, 7.071067811865475, 8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [10, 0, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
+    [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
+    [[7.0710678118654755, 7.071067811865475, -8], [7.0710678118654755, 7.071067811865475, 8], [18.38477631085024, 18.384776310850235, 8]],
+    [[18.38477631085024, 18.384776310850235, 8], [18.38477631085024, 18.384776310850235, -8], [7.0710678118654755, 7.071067811865475, -8]],
+    [[26, 0, 8], [10, 0, 8], [10, 0, -8]],
+    [[10, 0, -8], [26, 0, -8], [26, 0, 8]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
@@ -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],
@@ -95,14 +97,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   geometry2 = geom2.fromPoints([[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 64)
 
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.fromPoints([[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.notThrows.skip(() => geom3.validate(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 80)
 })
 
@@ -110,48 +112,48 @@ 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, 4.898587196589413e-16, 8], [7, 4.898587196589413e-16, 8], [-6.123233995736767e-17, 7, 8]],
-    [[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.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589413e-16, 2.999519565323715e-32, 8], [-6.123233995736767e-17, 7, 8]],
-    [[-6.123233995736767e-17, 7, 8], [9.184850993605148e-16, 7, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8]],
-    [[0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8], [7, 4.898587196589413e-16, 8]]
+    [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
+    [[7, 0, -8], [0, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
+    [[7, 0, 8], [0, 7, -8], [0, 7, 8]],
+    [[0, 0, -8], [0, 0, 8], [0, 7, 8]],
+    [[0, 7, 8], [0, 7, -8], [0, 0, -8]],
+    [[7, 0, 8], [0, 0, 8], [0, 0, -8]],
+    [[0, 0, -8], [7, 0, -8], [7, 0, 8]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // 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, -4.898587196589413e-16, -8], [3.4638242249419727e-16, -3.4638242249419736e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, -4.898587196589413e-16, -8], [0.7071067811865479, 0.7071067811865471, -8]],
-    [[2, 2.4492935982947064e-16, 4], [0.7071067811865479, 0.7071067811865471, -8], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [2, 2.4492935982947064e-16, 4], [1.414213562373095, 1.4142135623730951, 4]],
-    [[1, 4.898587196589413e-16, 8], [1.414213562373095, 1.4142135623730951, 4], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, 4.898587196589413e-16, 8], [0.7071067811865472, 0.7071067811865478, 8]],
-    [[0.7071067811865479, 0.7071067811865471, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [0.7071067811865479, 0.7071067811865471, -8], [5.51091059616309e-16, 1, -8]],
-    [[1.414213562373095, 1.4142135623730951, 4], [5.51091059616309e-16, 1, -8], [-1.2246467991473532e-16, 2, 4]],
-    [[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]],
-    [[5.51091059616309e-16, 1, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[-4.898587196589415e-16, 2.9995195653237163e-32, 8], [-4.286263797015738e-16, 1, 8], [-1.2246467991473544e-16, 2, 4]],
-    [[-1.2246467991473544e-16, 2, 4], [5.51091059616309e-16, 1, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
-    [[0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8], [1, -4.898587196589413e-16, -8]],
-    [[2, 2.4492935982947064e-16, 4], [1, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8]],
-    [[0, 4.898587196589413e-16, 8], [1, -4.898587196589413e-16, -8], [2, 2.4492935982947064e-16, 4]]
+    [[1, 0, -8], [0, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
+    [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [2, 0, 4], [1.4142135623730951, 1.414213562373095, 4]],
+    [[1, 0, 8], [1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0, 0, 8], [1, 0, 8], [0.7071067811865476, 0.7071067811865475, 8]],
+    [[0.7071067811865476, 0.7071067811865475, -8], [0, 0, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0.7071067811865476, 0.7071067811865475, -8], [0, 1, -8]],
+    [[1.4142135623730951, 1.414213562373095, 4], [0, 1, -8], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [1.4142135623730951, 1.414213562373095, 4], [0, 2, 4]],
+    [[0.7071067811865476, 0.7071067811865475, 8], [0, 2, 4], [0, 1, 8]],
+    [[0, 0, 8], [0.7071067811865476, 0.7071067811865475, 8], [0, 1, 8]],
+    [[0, 1, -8], [0, 0, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 1, 8], [0, 2, 4]],
+    [[0, 2, 4], [0, 1, -8], [0, 0, 8]],
+    [[0, 0, 8], [0, 0, -8], [1, 0, -8]],
+    [[2, 0, 4], [1, 0, 8], [0, 0, 8]],
+    [[0, 0, 8], [1, 0, -8], [2, 0, 4]]
   ]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

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

@@ -29,10 +29,10 @@ test('project (defaults)', (t) => {
     [0, -5.000013333333333],
     [5.000013333333333, 0],
     [-5.000013333333333, 0],
-    [-2.9999933333333333, 0],
-    [2.9999933333333333, 0],
     [0, 2.9999933333333333],
+    [-2.9999933333333333, 0],
     [0, -2.9999933333333333],
+    [2.9999933333333333, 0],
     [0, 5.000013333333333]
   ]
   t.true(comparePoints(pts, exp))

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/extrusions/slice/repair.js

@@ -40,7 +40,7 @@ const repair = (slice) => {
     let bestReplacement
     missingOut.forEach((key2) => {
       const v2 = vertexMap.get(key2)
-      const distance = Math.hypot(v1[0] - v2[0], v1[1] - v2[1])
+      const distance = vec3.distance(v1, v2)
       if (distance < bestDistance) {
         bestDistance = distance
         bestReplacement = v2

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

@@ -28,15 +28,15 @@ const addSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, verte
   } else {
     sidemap.get(newsidetag).push(newsideobj)
   }
-  if (starttag in vertextag2sidestart) {
-    vertextag2sidestart[starttag].push(newsidetag)
+  if (vertextag2sidestart.has(starttag)) {
+    vertextag2sidestart.get(starttag).push(newsidetag)
   } else {
-    vertextag2sidestart[starttag] = [newsidetag]
+    vertextag2sidestart.set(starttag, [newsidetag])
   }
-  if (endtag in vertextag2sideend) {
-    vertextag2sideend[endtag].push(newsidetag)
+  if (vertextag2sideend.has(endtag)) {
+    vertextag2sideend.get(endtag).push(newsidetag)
   } else {
-    vertextag2sideend[endtag] = [newsidetag]
+    vertextag2sideend.set(endtag, [newsidetag])
   }
   return newsidetag
 }
@@ -67,18 +67,18 @@ const deleteSide = (sidemap, vertextag2sidestart, vertextag2sideend, vertex0, ve
   }
 
   // adjust start and end lists
-  idx = vertextag2sidestart[starttag].indexOf(sidetag)
+  idx = vertextag2sidestart.get(starttag).indexOf(sidetag)
   if (assert && idx < 0) throw new Error('assert failed')
-  vertextag2sidestart[starttag].splice(idx, 1)
-  if (vertextag2sidestart[starttag].length === 0) {
-    delete vertextag2sidestart[starttag]
+  vertextag2sidestart.get(starttag).splice(idx, 1)
+  if (vertextag2sidestart.get(starttag).length === 0) {
+    vertextag2sidestart.delete(starttag)
   }
 
-  idx = vertextag2sideend[endtag].indexOf(sidetag)
+  idx = vertextag2sideend.get(endtag).indexOf(sidetag)
   if (assert && idx < 0) throw new Error('assert failed')
-  vertextag2sideend[endtag].splice(idx, 1)
-  if (vertextag2sideend[endtag].length === 0) {
-    delete vertextag2sideend[endtag]
+  vertextag2sideend.get(endtag).splice(idx, 1)
+  if (vertextag2sideend.get(endtag).length === 0) {
+    vertextag2sideend.delete(endtag)
   }
 }
 
@@ -158,25 +158,24 @@ const insertTjunctions = (polygons) => {
   }
 
   if (sidemap.size > 0) {
-    // console.log('insertTjunctions',sidemap.size)
     // STEP 2 : create a list of starting sides and ending sides
-    const vertextag2sidestart = {}
-    const vertextag2sideend = {}
-    const sidestocheck = {}
+    const vertextag2sidestart = new Map()
+    const vertextag2sideend = new Map()
+    const sidesToCheck = new Map()
     for (const [sidetag, sideobjs] of sidemap) {
-      sidestocheck[sidetag] = true
+      sidesToCheck.set(sidetag, true)
       sideobjs.forEach((sideobj) => {
         const starttag = getTag(sideobj.vertex0)
         const endtag = getTag(sideobj.vertex1)
-        if (starttag in vertextag2sidestart) {
-          vertextag2sidestart[starttag].push(sidetag)
+        if (vertextag2sidestart.has(starttag)) {
+          vertextag2sidestart.get(starttag).push(sidetag)
         } else {
-          vertextag2sidestart[starttag] = [sidetag]
+          vertextag2sidestart.set(starttag, [sidetag])
         }
-        if (endtag in vertextag2sideend) {
-          vertextag2sideend[endtag].push(sidetag)
+        if (vertextag2sideend.has(endtag)) {
+          vertextag2sideend.get(endtag).push(sidetag)
         } else {
-          vertextag2sideend[endtag] = [sidetag]
+          vertextag2sideend.set(endtag, [sidetag])
         }
       })
     }
@@ -187,13 +186,13 @@ const insertTjunctions = (polygons) => {
       if (sidemap.size === 0) break
 
       for (const sidetag of sidemap.keys()) {
-        sidestocheck[sidetag] = true
+        sidesToCheck.set(sidetag, true)
       }
 
       let donesomething = false
       while (true) {
-        const sidetags = Object.keys(sidestocheck)
-        if (sidetags.length === 0) break // sidestocheck is empty, we're done!
+        const sidetags = Array.from(sidesToCheck.keys())
+        if (sidetags.length === 0) break // sidesToCheck is empty, we're done!
         const sidetagtocheck = sidetags[0]
         let donewithside = true
         if (sidemap.has(sidetagtocheck)) {
@@ -207,12 +206,12 @@ const insertTjunctions = (polygons) => {
             const endvertextag = getTag(endvertex)
             let matchingsides = []
             if (directionindex === 0) {
-              if (startvertextag in vertextag2sideend) {
-                matchingsides = vertextag2sideend[startvertextag]
+              if (vertextag2sideend.has(startvertextag)) {
+                matchingsides = vertextag2sideend.get(startvertextag)
               }
             } else {
-              if (startvertextag in vertextag2sidestart) {
-                matchingsides = vertextag2sidestart[startvertextag]
+              if (vertextag2sidestart.has(startvertextag)) {
+                matchingsides = vertextag2sidestart.get(startvertextag)
               }
             }
             for (let matchingsideindex = 0; matchingsideindex < matchingsides.length; matchingsideindex++) {
@@ -267,8 +266,8 @@ const insertTjunctions = (polygons) => {
                     deleteSide(sidemap, vertextag2sidestart, vertextag2sideend, matchingside.vertex0, matchingside.vertex1, polygonindex)
                     const newsidetag1 = addSide(sidemap, vertextag2sidestart, vertextag2sideend, matchingside.vertex0, endvertex, polygonindex)
                     const newsidetag2 = addSide(sidemap, vertextag2sidestart, vertextag2sideend, endvertex, matchingside.vertex1, polygonindex)
-                    if (newsidetag1 !== null) sidestocheck[newsidetag1] = true
-                    if (newsidetag2 !== null) sidestocheck[newsidetag2] = true
+                    if (newsidetag1 !== null) sidesToCheck.set(newsidetag1, true)
+                    if (newsidetag2 !== null) sidesToCheck.set(newsidetag2, true)
                     donewithside = false
                     directionindex = 2 // skip reverse direction check
                     donesomething = true
@@ -280,7 +279,7 @@ const insertTjunctions = (polygons) => {
           } // for directionindex
         } // if(sidetagtocheck in sidemap)
         if (donewithside) {
-          delete sidestocheck[sidetagtocheck]
+          sidesToCheck.delete(sidetagtocheck)
         }
       }
       if (!donesomething) break

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?