@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,173 @@
+const test = require('ava')
+
+const { geom3 } = require('../../geometries')
+
+const retessellate = require('./retessellate')
+
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
+
+test('geom3: retessellate() should create proper geometry from empty geometries', (t) => {
+  const obj1 = geom3.create()
+
+  // one empty geometry
+  const ret1 = retessellate(obj1)
+  const exp1 = {
+    polygons: [],
+    isRetesselated: true,
+    transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+  }
+  t.deepEqual(ret1, exp1)
+})
+
+test('geom3: retessellate() should create proper geometry from solid geometries', (t) => {
+  const box1 = [
+    [[-5.0, -5.0, -5.0], [-5.0, -5.0, 5.0], [-5.0, 5.0, 5.0], [-5.0, 5.0, -5.0]],
+    [[5.0, -5.0, -5.0], [5.0, 5.0, -5.0], [5.0, 5.0, 5.0], [5.0, -5.0, 5.0]],
+    [[-5.0, -5.0, -5.0], [5.0, -5.0, -5.0], [5.0, -5.0, 5.0], [-5.0, -5.0, 5.0]],
+    [[-5.0, 5.0, -5.0], [-5.0, 5.0, 5.0], [5.0, 5.0, 5.0], [5.0, 5.0, -5.0]],
+    [[-5.0, -5.0, -5.0], [-5.0, 5.0, -5.0], [5.0, 5.0, -5.0], [5.0, -5.0, -5.0]],
+    [[-5.0, -5.0, 5.0], [5.0, -5.0, 5.0], [5.0, 5.0, 5.0], [-5.0, 5.0, 5.0]]
+  ]
+
+  const box2 = [
+    [[15.0, 15.0, 15.0], [15.0, 15.0, 25.0], [15.0, 25.0, 25.0], [15.0, 25.0, 15.0]],
+    [[25.0, 15.0, 15.0], [25.0, 25.0, 15.0], [25.0, 25.0, 25.0], [25.0, 15.0, 25.0]],
+    [[15.0, 15.0, 15.0], [25.0, 15.0, 15.0], [25.0, 15.0, 25.0], [15.0, 15.0, 25.0]],
+    [[15.0, 25.0, 15.0], [15.0, 25.0, 25.0], [25.0, 25.0, 25.0], [25.0, 25.0, 15.0]],
+    [[15.0, 15.0, 15.0], [15.0, 25.0, 15.0], [25.0, 25.0, 15.0], [25.0, 15.0, 15.0]],
+    [[15.0, 15.0, 25.0], [25.0, 15.0, 25.0], [25.0, 25.0, 25.0], [15.0, 25.0, 25.0]]
+  ]
+
+  const box3 = [
+    [[-5.0, -5.0, -5.0], [-5.0, -5.0, 5.0], [-5.0, 5.0, 5.0], [-5.0, 5.0, -5.0]],
+    [[5.0, -5.0, -5.0], [5.0, 5.0, -5.0], [5.0, 5.0, 5.0], [5.0, -5.0, 5.0]],
+    [[-5.0, -5.0, -5.0], [5.0, -5.0, -5.0], [5.0, -5.0, 5.0], [-5.0, -5.0, 5.0]],
+    [[-5.0, 5.0, -5.0], [-5.0, 5.0, 5.0], [5.0, 5.0, 5.0], [5.0, 5.0, -5.0]],
+    [[-5.0, -5.0, -5.0], [-5.0, 5.0, -5.0], [5.0, 5.0, -5.0], [5.0, -5.0, -5.0]],
+    [[-5.0, -5.0, 5.0], [-5.0, -5.0, 15.0], [-5.0, 5.0, 15.0], [-5.0, 5.0, 5.0]],
+    [[5.0, -5.0, 5.0], [5.0, 5.0, 5.0], [5.0, 5.0, 15.0], [5.0, -5.0, 15.0]],
+    [[-5.0, -5.0, 5.0], [5.0, -5.0, 5.0], [5.0, -5.0, 15.0], [-5.0, -5.0, 15.0]],
+    [[-5.0, 5.0, 5.0], [-5.0, 5.0, 15.0], [5.0, 5.0, 15.0], [5.0, 5.0, 5.0]],
+    [[-5.0, -5.0, 15.0], [5.0, -5.0, 15.0], [5.0, 5.0, 15.0], [-5.0, 5.0, 15.0]]
+  ]
+
+  const box4 = [
+    [[-5.0, -5.0, -5.0], [-5.0, -5.0, 5.0], [-5.0, 5.0, 5.0], [-5.0, 5.0, -5.0]],
+    [[-5.0, -5.0, -5.0], [5.0, -5.0, -5.0], [5.0, -5.0, 5.0], [-5.0, -5.0, 5.0]],
+    [[-5.0, -5.0, -5.0], [-5.0, 5.0, -5.0], [5.0, 5.0, -5.0], [5.0, -5.0, -5.0]],
+    [[5.0, -5.0, -5.0], [5.0, 0.0, -5.0], [5.0, 0.0, 5.0], [5.0, -5.0, 5.0]],
+    [[-5.0, 5.0, -5.0], [-5.0, 5.0, 5.0], [0.0, 5.0, 5.0], [0.0, 5.0, -5.0]],
+    [[-5.0, -5.0, 5.0], [0.0, -5.0, 5.0], [0.0, 5.0, 5.0], [-5.0, 5.0, 5.0]],
+    [[5.0, 0.0, -5.0], [5.0, 5.0, -5.0], [5.0, 5.0, 0.0], [5.0, 0.0, 0.0]],
+    [[5.0, 5.0, 0.0], [5.0, 5.0, -5.0], [0.0, 5.0, -5.0], [0.0, 5.0, 0.0]],
+    [[0.0, -5.0, 5.0], [5.0, -5.0, 5.0], [5.0, 0.0, 5.0], [0.0, 0.0, 5.0]],
+    [[10.0, 0.0, 0.0], [10.0, 10.0, 0.0], [10.0, 10.0, 10.0], [10.0, 0.0, 10.0]],
+    [[0.0, 10.0, 0.0], [0.0, 10.0, 10.0], [10.0, 10.0, 10.0], [10.0, 10.0, 0.0]],
+    [[0.0, 0.0, 10.0], [10.0, 0.0, 10.0], [10.0, 10.0, 10.0], [0.0, 10.0, 10.0]],
+    [[0.0, 5.0, 10.0], [0.0, 10.0, 10.0], [0.0, 10.0, 0.0], [0.0, 5.0, 0.0]],
+    [[5.0, 0.0, 0.0], [10.0, 0.0, 0.0], [10.0, 0.0, 10.0], [5.0, 0.0, 10.0]],
+    [[5.0, 10.0, 0.0], [10.0, 10.0, 0.0], [10.0, 0.0, 0.0], [5.0, 0.0, 0.0]],
+    [[0.0, 0.0, 5.0], [0.0, 0.0, 10.0], [0.0, 5.0, 10.0], [0.0, 5.0, 5.0]],
+    [[5.0, 0.0, 5.0], [5.0, 0.0, 10.0], [0.0, 0.0, 10.0], [0.0, 0.0, 5.0]],
+    [[0.0, 5.0, 0.0], [0.0, 10.0, 0.0], [5.0, 10.0, 0.0], [5.0, 5.0, 0.0]]
+  ]
+
+  const box5 = [ // with coplanar polygons
+    [[-5.0, -5.0, -5.0], [-5.0, -5.0, 5.0], [-5.0, 5.0, 5.0], [-5.0, 5.0, -5.0]], // end
+    [[10.0, -5.0, -5.0], [10.0, -5.0, 5.0], [-5.0, -5.0, 5.0], [-5.0, -5.0, -5.0]], // side
+    [[10.0, 5.0, 5.0], [10.0, 5.0, -5.0], [-5.0, 5.0, -5.0], [-5.0, 5.0, 5.0]], // side
+    [[10.0, 5.0, -5.0], [10.0, -5.0, -5.0], [-5.0, -5.0, -5.0], [-5.0, 5.0, -5.0]], // bottom
+    [[10.0, -5.0, 5.0], [10.0, 0.0, 5.0], [-5.0, 0.0, 5.0], [-5.0, -5.0, 5.0]], // top
+    [[10.0, 0.0, 5.0], [10.0, 5.0, 5.0], [-5.0, 5.0, 5.0], [-5.0, 0.0, 5.0]], // top
+    [[10.0, -5.0, -5.0], [10.0, 5.0, -5.0], [10.0, 5.0, 5.0], [10.0, -5.0, 5.0]] // end
+  ]
+
+  const obj1 = geom3.fromPoints(box1)
+  const obj2 = geom3.fromPoints(box1.concat(box2)) // combined geometry
+  const obj3 = geom3.fromPoints(box3)
+  const obj4 = geom3.fromPoints(box4)
+  const obj5 = geom3.fromPoints(box5)
+
+  // one solid geometry
+  const ret1 = retessellate(obj1)
+  const pts1 = geom3.toPoints(ret1)
+  const exp1 = [
+    [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
+    [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
+    [[-5, -5, -5], [5, -5, -5], [5, -5, 5], [-5, -5, 5]],
+    [[-5, 5, -5], [-5, 5, 5], [5, 5, 5], [5, 5, -5]],
+    [[-5, -5, -5], [-5, 5, -5], [5, 5, -5], [5, -5, -5]],
+    [[-5, -5, 5], [5, -5, 5], [5, 5, 5], [-5, 5, 5]]
+  ]
+  t.true(comparePolygonsAsPoints(pts1, exp1))
+
+  // two non-overlapping geometries
+  const ret2 = retessellate(obj2)
+  const pts2 = geom3.toPoints(ret2)
+  const exp2 = [
+    [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
+    [[5, -5, -5], [5, 5, -5], [5, 5, 5], [5, -5, 5]],
+    [[-5, -5, -5], [5, -5, -5], [5, -5, 5], [-5, -5, 5]],
+    [[-5, 5, -5], [-5, 5, 5], [5, 5, 5], [5, 5, -5]],
+    [[-5, -5, -5], [-5, 5, -5], [5, 5, -5], [5, -5, -5]],
+    [[-5, -5, 5], [5, -5, 5], [5, 5, 5], [-5, 5, 5]],
+    [[15, 15, 15], [15, 15, 25], [15, 25, 25], [15, 25, 15]],
+    [[25, 15, 15], [25, 25, 15], [25, 25, 25], [25, 15, 25]],
+    [[15, 15, 15], [25, 15, 15], [25, 15, 25], [15, 15, 25]],
+    [[15, 25, 15], [15, 25, 25], [25, 25, 25], [25, 25, 15]],
+    [[15, 15, 15], [15, 25, 15], [25, 25, 15], [25, 15, 15]],
+    [[15, 15, 25], [25, 15, 25], [25, 25, 25], [15, 25, 25]]
+  ]
+  t.true(comparePolygonsAsPoints(pts2, exp2))
+
+  // two touching geometries (faces)
+  const ret3 = retessellate(obj3)
+  const pts3 = geom3.toPoints(ret3)
+  const exp3 = [
+    [[-5, 5, 15], [-5, 5, -5], [-5, -5, -5], [-5, -5, 15]],
+    [[5, -5, 15], [5, -5, -5], [5, 5, -5], [5, 5, 15]],
+    [[-5, -5, 15], [-5, -5, -5], [5, -5, -5], [5, -5, 15]],
+    [[5, 5, 15], [5, 5, -5], [-5, 5, -5], [-5, 5, 15]],
+    [[-5, -5, -5], [-5, 5, -5], [5, 5, -5], [5, -5, -5]],
+    [[-5, -5, 15], [5, -5, 15], [5, 5, 15], [-5, 5, 15]]
+  ]
+  t.true(comparePolygonsAsPoints(pts3, exp3))
+
+  // two overlapping geometries
+  const ret4 = retessellate(obj4)
+  const pts4 = geom3.toPoints(ret4)
+  const exp4 = [
+    [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
+    [[-5, -5, -5], [5, -5, -5], [5, -5, 5], [-5, -5, 5]],
+    [[-5, -5, -5], [-5, 5, -5], [5, 5, -5], [5, -5, -5]],
+    [[5, -5, 5], [5, -5, 0], [5, 0, 0], [5, 0, 5]],
+    [[5, -5, 0], [5, -5, -5], [5, 5, -5], [5, 5, 0]],
+    [[0, 5, 5], [0, 5, 0], [-5, 5, 0], [-5, 5, 5]],
+    [[5, 5, 0], [5, 5, -5], [-5, 5, -5], [-5, 5, 0]],
+    [[-5, 5, 5], [-5, 0, 5], [0, 0, 5], [0, 5, 5]],
+    [[-5, 0, 5], [-5, -5, 5], [5, -5, 5], [5, 0, 5]],
+    [[10, 0, 0], [10, 10, 0], [10, 10, 10], [10, 0, 10]],
+    [[0, 10, 0], [0, 10, 10], [10, 10, 10], [10, 10, 0]],
+    [[0, 0, 10], [10, 0, 10], [10, 10, 10], [0, 10, 10]],
+    [[0, 10, 10], [0, 10, 5], [0, 0, 5], [0, 0, 10]],
+    [[0, 10, 5], [0, 10, 0], [0, 5, 0], [0, 5, 5]],
+    [[0, 0, 10], [0, 0, 5], [10, 0, 5], [10, 0, 10]],
+    [[5, 0, 5], [5, -0, 0], [10, -0, 0], [10, 0, 5]],
+    [[10, 10, 0], [10, 5, 0], [0, 5, 0], [0, 10, 0]],
+    [[10, 5, 0], [10, 0, 0], [5, 0, 0], [5, 5, 0]]
+  ]
+  t.true(comparePolygonsAsPoints(pts4, exp4))
+
+  // coplanar polygons
+  const ret5 = retessellate(obj5)
+  const pts5 = geom3.toPoints(ret5)
+  const exp5 = [
+    [[-5, -5, -5], [-5, -5, 5], [-5, 5, 5], [-5, 5, -5]],
+    [[10, -5, -5], [10, -5, 5], [-5, -5, 5], [-5, -5, -5]],
+    [[10, 5, 5], [10, 5, -5], [-5, 5, -5], [-5, 5, 5]],
+    [[10, 5, -5], [10, -5, -5], [-5, -5, -5], [-5, 5, -5]],
+    [[-5, 5, 5], [-5, -5, 5], [10, -5, 5], [10, 5, 5]],
+    [[10, -5, -5], [10, 5, -5], [10, 5, 5], [10, -5, 5]]
+  ]
+  t.true(comparePolygonsAsPoints(pts5, exp5))
+})

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

@@ -0,0 +1,57 @@
+const flatten = require('../../utils/flatten')
+
+const vec2 = require('../../maths/vec2')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+const measureEpsilon = require('../../measurements/measureEpsilon')
+
+const snapPolygons = require('./snapPolygons')
+
+const snapPath2 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const points = path2.toPoints(geometry)
+  const newpoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
+  // snap can produce duplicate points, remove those
+  return path2.create(newpoints)
+}
+
+const snapGeom2 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const sides = geom2.toSides(geometry)
+  let newsides = sides.map((side) => [vec2.snap(vec2.create(), side[0], epsilon), vec2.snap(vec2.create(), side[1], epsilon)])
+  // snap can produce sides with zero (0) length, remove those
+  newsides = newsides.filter((side) => !vec2.equals(side[0], side[1]))
+  return geom2.create(newsides)
+}
+
+const snapGeom3 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const polygons = geom3.toPolygons(geometry)
+  const newpolygons = snapPolygons(epsilon, polygons)
+  return geom3.create(newpolygons)
+}
+
+/**
+ * Snap the given geometries to the precision (calculated epsilon) of the geometry.
+ * @see measurements.measureEpsilon()
+ * @param {...Object} geometries - the geometries to snap
+ * @return {Object|Array} the snapped geometry, or a list of snapped geometries
+ * @alias module:modeling/modifiers.snap
+ */
+const snap = (...geometries) => {
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('wrong number of arguments')
+
+  const results = geometries.map((geometry) => {
+    if (path2.isA(geometry)) return snapPath2(geometry)
+    if (geom2.isA(geometry)) return snapGeom2(geometry)
+    if (geom3.isA(geometry)) return snapGeom3(geometry)
+    return geometry
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = snap

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

@@ -0,0 +1,146 @@
+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')
+
+const { snap } = require('./index')
+
+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: TAU / 4 * 1000, segments: 8 })
+
+  const results = snap(geometry1, geometry2, geometry3, geometry4)
+  t.is(results.length, 4)
+
+  let pts = path2.toPoints(results[0])
+  let exp = []
+  t.true(comparePoints(pts, exp))
+
+  pts = path2.toPoints(results[1])
+  exp = [
+    [0.5, 0], [0.383022221559489, 0.3213938048432696],
+    [0.08682408883346521, 0.492403876506104], [-0.2499999999999999, 0.43301270189221935],
+    [-0.46984631039295416, 0.17101007166283444], [-0.4698463103929542, -0.17101007166283433],
+    [-0.2500000000000002, -0.43301270189221924], [0.08682408883346499, -0.49240387650610407],
+    [0.3830222215594889, -0.3213938048432698]
+  ]
+  t.true(comparePoints(pts, exp))
+
+  pts = path2.toPoints(results[2])
+  exp = [
+    [0.6666666666666666, 0], [0.5106962954126519, 0.4285250731243595],
+    [0.11576545177795361, 0.6565385020081387], [-0.33333333333333315, 0.5773502691896257],
+    [-0.6264617471906055, 0.22801342888377923], [-0.6264617471906055, -0.2280134288837791],
+    [-0.3333333333333336, -0.5773502691896256], [0.1157654517779533, -0.6565385020081387],
+    [0.5106962954126518, -0.4285250731243597]
+  ]
+  t.true(comparePoints(pts, exp))
+
+  pts = path2.toPoints(results[3])
+  exp = [
+    [1570.7979271820118, 0], [1203.3061290889411, 1009.6890116376164],
+    [272.7710864950155, 1546.9412033856784], [-785.3989635910059, 1360.3552181729126],
+    [-1476.0772155839566, 537.2521917480618], [-1476.0772155839566, -537.2521917480618],
+    [-785.3989635910059, -1360.3552181729126], [272.7710864950155, -1546.9412033856784],
+    [1203.3061290889411, -1009.6890116376164]
+  ]
+  t.true(comparePoints(pts, exp))
+})
+
+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: [TAU / 2 * 1000, TAU / 2 * 1000, TAU / 2 * 1000] })
+
+  const results = snap(geometry1, geometry2, geometry3, geometry4)
+  t.is(results.length, 4)
+
+  let pts = geom2.toPoints(results[0])
+  let exp = []
+  t.true(comparePoints(pts, exp))
+
+  pts = geom2.toPoints(results[1])
+  exp = [[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]]
+  t.true(comparePoints(pts, exp))
+
+  pts = geom2.toPoints(results[2])
+  exp = [
+    [-0.6666666666666666, -0.6666666666666666], [0.6666666666666666, -0.6666666666666666],
+    [0.6666666666666666, 0.6666666666666666], [-0.6666666666666666, 0.6666666666666666]
+  ]
+  t.true(comparePoints(pts, exp))
+
+  pts = geom2.toPoints(results[3])
+  exp = [
+    [-1570.7963267948967, -1570.7963267948967], [1570.7963267948967, -1570.7963267948967],
+    [1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967]
+  ]
+  t.true(comparePoints(pts, exp))
+})
+
+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: [TAU / 2 * 1000, TAU / 2 * 1000, TAU / 2 * 1000] })
+
+  const results = snap(geometry1, geometry2, geometry3, geometry4)
+  t.is(results.length, 4)
+
+  let pts = geom3.toPoints(results[0])
+  let exp = []
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  pts = geom3.toPoints(results[1])
+  exp = [
+    [[-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5]],
+    [[0.5, -0.5, -0.5], [0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [0.5, -0.5, 0.5]],
+    [[-0.5, -0.5, -0.5], [0.5, -0.5, -0.5], [0.5, -0.5, 0.5], [-0.5, -0.5, 0.5]],
+    [[-0.5, 0.5, -0.5], [-0.5, 0.5, 0.5], [0.5, 0.5, 0.5], [0.5, 0.5, -0.5]],
+    [[-0.5, -0.5, -0.5], [-0.5, 0.5, -0.5], [0.5, 0.5, -0.5], [0.5, -0.5, -0.5]],
+    [[-0.5, -0.5, 0.5], [0.5, -0.5, 0.5], [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5]]
+  ]
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  pts = geom3.toPoints(results[2])
+  exp = [
+    [[-0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [-0.6666666666666667, -0.6666666666666667, 0.6666666666666667],
+      [-0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, -0.6666666666666667]],
+    [[0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [0.6666666666666667, 0.6666666666666667, -0.6666666666666667],
+      [0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [0.6666666666666667, -0.6666666666666667, 0.6666666666666667]],
+    [[-0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [0.6666666666666667, -0.6666666666666667, -0.6666666666666667],
+      [0.6666666666666667, -0.6666666666666667, 0.6666666666666667], [-0.6666666666666667, -0.6666666666666667, 0.6666666666666667]],
+    [[-0.6666666666666667, 0.6666666666666667, -0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, 0.6666666666666667],
+      [0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [0.6666666666666667, 0.6666666666666667, -0.6666666666666667]],
+    [[-0.6666666666666667, -0.6666666666666667, -0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, -0.6666666666666667],
+      [0.6666666666666667, 0.6666666666666667, -0.6666666666666667], [0.6666666666666667, -0.6666666666666667, -0.6666666666666667]],
+    [[-0.6666666666666667, -0.6666666666666667, 0.6666666666666667], [0.6666666666666667, -0.6666666666666667, 0.6666666666666667],
+      [0.6666666666666667, 0.6666666666666667, 0.6666666666666667], [-0.6666666666666667, 0.6666666666666667, 0.6666666666666667]]
+  ]
+  t.true(comparePolygonsAsPoints(pts, exp))
+
+  pts = geom3.toPoints(results[3])
+  exp = [
+    [[-1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [-1570.7963267948967, -1570.7963267948967, 1570.7963267948967],
+      [-1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, -1570.7963267948967]],
+    [[1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [1570.7963267948967, 1570.7963267948967, -1570.7963267948967],
+      [1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [1570.7963267948967, -1570.7963267948967, 1570.7963267948967]],
+    [[-1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [1570.7963267948967, -1570.7963267948967, -1570.7963267948967],
+      [1570.7963267948967, -1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, -1570.7963267948967, 1570.7963267948967]],
+    [[-1570.7963267948967, 1570.7963267948967, -1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, 1570.7963267948967],
+      [1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [1570.7963267948967, 1570.7963267948967, -1570.7963267948967]],
+    [[-1570.7963267948967, -1570.7963267948967, -1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, -1570.7963267948967],
+      [1570.7963267948967, 1570.7963267948967, -1570.7963267948967], [1570.7963267948967, -1570.7963267948967, -1570.7963267948967]],
+    [[-1570.7963267948967, -1570.7963267948967, 1570.7963267948967], [1570.7963267948967, -1570.7963267948967, 1570.7963267948967],
+      [1570.7963267948967, 1570.7963267948967, 1570.7963267948967], [-1570.7963267948967, 1570.7963267948967, 1570.7963267948967]]
+  ]
+  t.true(comparePolygonsAsPoints(pts, exp))
+})

package/src/operations/modifiers/snapPolygons.js

@@ -0,0 +1,32 @@
+const vec3 = require('../../maths/vec3')
+
+const poly3 = require('../../geometries/poly3')
+
+const isValidPoly3 = (epsilon, polygon) => {
+  const area = Math.abs(poly3.measureArea(polygon))
+  return (Number.isFinite(area) && area > epsilon)
+}
+
+/*
+ * Snap the given list of polygons to the epsilon.
+ */
+const snapPolygons = (epsilon, polygons) => {
+  let newpolygons = polygons.map((polygon) => {
+    const snapvertices = polygon.vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
+    // only retain unique vertices
+    const newvertices = []
+    for (let i = 0; i < snapvertices.length; i++) {
+      const j = (i + 1) % snapvertices.length
+      if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
+    }
+    const newpolygon = poly3.create(newvertices)
+    if (polygon.color) newpolygon.color = polygon.color
+    return newpolygon
+  })
+  // snap can produce polygons with zero (0) area, remove those
+  const epsilonArea = (epsilon * epsilon * Math.sqrt(3) / 4)
+  newpolygons = newpolygons.filter((polygon) => isValidPoly3(epsilonArea, polygon))
+  return newpolygons
+}
+
+module.exports = snapPolygons

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

@@ -0,0 +1,70 @@
+const test = require('ava')
+
+const { poly3 } = require('../../geometries')
+
+const snapPolygons = require('./snapPolygons')
+
+test('snapPolygons: snap of polygons produces expected results', (t) => {
+  const polygons = [
+    // valid polygons
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10]]), // OK
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]]), // OK
+    // invalid polygons
+    poly3.create(),
+    poly3.create([[0, 0, 0]]),
+    poly3.create([[0, 0, 0], [0, 10, 0]]),
+    // duplicated vertices
+    poly3.create([
+      [-24.445112000000115, 19.346837333333426, 46.47572533333356],
+      [-24.44446933333345, 19.346837333333426, 46.47508266666689],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019]
+    ]), // OK
+    poly3.create([
+      [-24.445112000000115, 19.346837333333426, 46.47572533333356],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019]
+    ]),
+    poly3.create([
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019]
+    ]),
+    // duplicate vertices after snap
+    poly3.create([
+      [-24.445112000000115, 19.346837333333426, 46.47572533333356],
+      [-24.44446933333345, 19.346837333333426, 46.47508266666689],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
+    ]), // OK
+    poly3.create([
+      [-24.445112000000115, 19.346837333333426, 46.47572533333356],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
+    ]),
+    poly3.create([
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
+      [-23.70540266666678, 18.79864266666676, 39.56448800000019],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
+    ]),
+    // inverted polygon
+    poly3.create([
+      [20.109133333333336, -4.894033333333335, -1.0001266666666668],
+      [20.021120000000003, -5.1802133333333344, -1.0001266666666668],
+      [20.020300000000002, -5.182946666666668, -1.0001266666666668],
+      [10.097753333333335, -5.182946666666668, -1.0001266666666668],
+      [10.287720000000002, -4.894033333333335, -1.0001266666666668]
+    ])
+  ]
+
+  const results = snapPolygons(0.0001, polygons)
+  t.is(results.length, 5)
+
+  const exp3 = poly3.create([
+    [-24.4451, 19.3468, 46.4757],
+    [-24.4445, 19.3468, 46.475100000000005],
+    [-23.7054, 18.7986, 39.5645]
+  ])
+  t.deepEqual(results[3].vertices, exp3.vertices)
+})

package/src/operations/modifiers/triangulatePolygons.js

@@ -0,0 +1,45 @@
+const vec3 = require('../../maths/vec3')
+const poly3 = require('../../geometries/poly3')
+
+const triangulatePolygon = (epsilon, polygon, triangles) => {
+  const nv = polygon.vertices.length
+  if (nv > 3) {
+    if (nv > 4) {
+      // split the polygon using a midpoint
+      const midpoint = [0, 0, 0]
+      polygon.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice))
+      vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon)
+      for (let i = 0; i < nv; i++) {
+        const poly = poly3.create([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
+        if (polygon.color) poly.color = polygon.color
+        triangles.push(poly)
+      }
+      return
+    }
+    // exactly 4 vertices, use simple triangulation
+    const poly0 = poly3.create([polygon.vertices[0], polygon.vertices[1], polygon.vertices[2]])
+    const poly1 = poly3.create([polygon.vertices[0], polygon.vertices[2], polygon.vertices[3]])
+    if (polygon.color) {
+      poly0.color = polygon.color
+      poly1.color = polygon.color
+    }
+    triangles.push(poly0, poly1)
+    return
+  }
+  // exactly 3 vertices, so return the original
+  triangles.push(polygon)
+}
+
+/*
+ * Convert the given polygons into a list of triangles (polygons with 3 vertices).
+ * NOTE: this is possible because poly3 is CONVEX by definition
+ */
+const triangulatePolygons = (epsilon, polygons) => {
+  const triangles = []
+  polygons.forEach((polygon) => {
+    triangulatePolygon(epsilon, polygon, triangles)
+  })
+  return triangles
+}
+
+module.exports = triangulatePolygons

package/src/operations/transforms/align.d.ts

@@ -0,0 +1,16 @@
+import { Geometry } from '../../geometries/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export default align
+
+type NullableNumber = null | number
+
+export interface AlignOptions {
+  modes?: Array<'center' | 'max' | 'min' | 'none'>
+  relativeTo?: [NullableNumber] | [NullableNumber, NullableNumber] | [NullableNumber, NullableNumber, NullableNumber]
+  grouped?: boolean
+}
+
+declare function align<T extends Geometry>(options: AlignOptions, geometry: T): T
+declare function align<T extends Geometry>(options: AlignOptions, ...geometries: RecursiveArray<T>): Array<T>
+declare function align(options: AlignOptions, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/transforms/align.js

@@ -0,0 +1,89 @@
+const flatten = require('../../utils/flatten')
+const padArrayToLength = require('../../utils/padArrayToLength')
+const measureAggregateBoundingBox = require('../../measurements/measureAggregateBoundingBox')
+const { translate } = require('./translate')
+
+const validateOptions = (options) => {
+  if (!Array.isArray(options.modes) || options.modes.length > 3) throw new Error('align(): modes must be an array of length <= 3')
+  options.modes = padArrayToLength(options.modes, 'none', 3)
+  if (options.modes.filter((mode) => ['center', 'max', 'min', 'none'].includes(mode)).length !== 3) throw new Error('align(): all modes must be one of "center", "max" or "min"')
+
+  if (!Array.isArray(options.relativeTo) || options.relativeTo.length > 3) throw new Error('align(): relativeTo must be an array of length <= 3')
+  options.relativeTo = padArrayToLength(options.relativeTo, 0, 3)
+  if (options.relativeTo.filter((alignVal) => (Number.isFinite(alignVal) || alignVal == null)).length !== 3) throw new Error('align(): all relativeTo values must be a number, or null.')
+
+  if (typeof options.grouped !== 'boolean') throw new Error('align(): grouped must be a boolean value.')
+
+  return options
+}
+
+const populateRelativeToFromBounds = (relativeTo, modes, bounds) => {
+  for (let i = 0; i < 3; i++) {
+    if (relativeTo[i] == null) {
+      if (modes[i] === 'center') {
+        relativeTo[i] = (bounds[0][i] + bounds[1][i]) / 2
+      } else if (modes[i] === 'max') {
+        relativeTo[i] = bounds[1][i]
+      } else if (modes[i] === 'min') {
+        relativeTo[i] = bounds[0][i]
+      }
+    }
+  }
+  return relativeTo
+}
+
+const alignGeometries = (geometry, modes, relativeTo) => {
+  const bounds = measureAggregateBoundingBox(geometry)
+  const translation = [0, 0, 0]
+  for (let i = 0; i < 3; i++) {
+    if (modes[i] === 'center') {
+      translation[i] = relativeTo[i] - (bounds[0][i] + bounds[1][i]) / 2
+    } else if (modes[i] === 'max') {
+      translation[i] = relativeTo[i] - bounds[1][i]
+    } else if (modes[i] === 'min') {
+      translation[i] = relativeTo[i] - bounds[0][i]
+    }
+  }
+
+  return translate(translation, geometry)
+}
+
+/**
+ * Align the boundaries of the given geometries using the given options.
+ * @param {Object} options - options for aligning
+ * @param {Array} [options.modes = ['center', 'center', 'min']] - the point on the geometries to align to for each axis. Valid options are "center", "max", "min", and "none".
+ * @param {Array} [options.relativeTo = [0,0,0]] - The point one each axis on which to align the geometries upon.  If the value is null, then the corresponding value from the group's bounding box is used.
+ * @param {Boolean} [options.grouped = false] - if true, transform all geometries by the same amount, maintaining the relative positions to each other.
+ * @param {...Object} geometries - the geometries to align
+ * @return {Object|Array} the aligned geometry, or a list of aligned geometries
+ * @alias module:modeling/transforms.align
+ *
+ * @example
+ * let alignedGeometries = align({modes: ['min', 'center', 'none'], relativeTo: [10, null, 10], grouped: true }, geometries)
+ */
+const align = (options, ...geometries) => {
+  const defaults = {
+    modes: ['center', 'center', 'min'],
+    relativeTo: [0, 0, 0],
+    grouped: false
+  }
+  options = Object.assign({}, defaults, options)
+
+  options = validateOptions(options)
+  let { modes, relativeTo, grouped } = options
+  geometries = flatten(geometries)
+  if (geometries.length === 0) throw new Error('align(): No geometries were provided to act upon')
+
+  if (relativeTo.filter((val) => val == null).length) {
+    const bounds = measureAggregateBoundingBox(geometries)
+    relativeTo = populateRelativeToFromBounds(relativeTo, modes, bounds)
+  }
+  if (grouped) {
+    geometries = alignGeometries(geometries, modes, relativeTo)
+  } else {
+    geometries = geometries.map((geometry) => alignGeometries(geometry, modes, relativeTo))
+  }
+  return geometries.length === 1 ? geometries[0] : geometries
+}
+
+module.exports = align