@jbroll/jscad-modeling 2.12.7

package/src/operations/transforms/rotate.js

@@ -0,0 +1,76 @@
+const flatten = require('../../utils/flatten')
+
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/**
+ * Rotate the given objects using the given options.
+ * @param {Array} angles - angle (RADIANS) of rotations about X, Y, and Z axis
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
+ * @alias module:modeling/transforms.rotate
+ *
+ * @example
+ * const newsphere = rotate([TAU / 8, 0, 0], sphere())
+ */
+const rotate = (angles, ...objects) => {
+  if (!Array.isArray(angles)) throw new Error('angles must be an array')
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  // adjust the angles if necessary
+  angles = angles.slice() // don't modify the original
+  while (angles.length < 3) angles.push(0)
+
+  const yaw = angles[2]
+  const pitch = angles[1]
+  const roll = angles[0]
+
+  const matrix = mat4.fromTaitBryanRotation(mat4.create(), yaw, pitch, roll)
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+/**
+ * Rotate the given objects about the X axis, using the given options.
+ * @param {Number} angle - angle (RADIANS) of rotations about X
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
+ * @alias module:modeling/transforms.rotateX
+ */
+const rotateX = (angle, ...objects) => rotate([angle, 0, 0], objects)
+
+/**
+ * Rotate the given objects about the Y axis, using the given options.
+ * @param {Number} angle - angle (RADIANS) of rotations about Y
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
+ * @alias module:modeling/transforms.rotateY
+ */
+const rotateY = (angle, ...objects) => rotate([0, angle, 0], objects)
+
+/**
+ * Rotate the given objects about the Z axis, using the given options.
+ * @param {Number} angle - angle (RADIANS) of rotations about Z
+ * @param {...Object} objects - the objects to rotate
+ * @return {Object|Array} the rotated object, or a list of rotated objects
+ * @alias module:modeling/transforms.rotateZ
+ */
+const rotateZ = (angle, ...objects) => rotate([0, 0, angle], objects)
+
+module.exports = {
+  rotate,
+  rotateX,
+  rotateY,
+  rotateZ
+}

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

@@ -0,0 +1,154 @@
+const test = require('ava')
+
+const { TAU } = require('../../maths/constants')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { rotate, rotateX, rotateY, rotateZ } = require('./index')
+
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+
+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, TAU / 4], geometry)
+  let obs = path2.toPoints(rotated)
+  const exp = [
+    new Float32Array([0, 1]),
+    new Float32Array([-1, 0]),
+    new Float32Array([-0, -1])
+  ]
+  t.true(comparePoints(obs, exp))
+
+  rotated = rotateZ(TAU / 4, geometry)
+  obs = path2.toPoints(rotated)
+  t.notThrows(() => path2.validate(rotated))
+  t.true(comparePoints(obs, exp))
+})
+
+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, -TAU / 4], geometry)
+  let obs = geom2.toPoints(rotated)
+  const exp = [
+    new Float32Array([0, 0]),
+    new Float32Array([0, -1]),
+    new Float32Array([1, 0])
+  ]
+  t.notThrows(() => geom2.validate(rotated))
+  t.true(comparePoints(obs, exp))
+
+  rotated = rotateZ(-TAU / 4, geometry)
+  obs = geom2.toPoints(rotated)
+  t.notThrows(() => geom2.validate(rotated))
+  t.true(comparePoints(obs, exp))
+})
+
+test('rotate: rotating of a geom3 produces expected changes to polygons', (t) => {
+  const points = [
+    [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
+    [[8, -7, -12], [8, 13, -12], [8, 13, 18], [8, -7, 18]],
+    [[-2, -7, -12], [8, -7, -12], [8, -7, 18], [-2, -7, 18]],
+    [[-2, 13, -12], [-2, 13, 18], [8, 13, 18], [8, 13, -12]],
+    [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
+    [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
+  ]
+  const geometry = geom3.fromPoints(points)
+
+  // rotate about X
+  let rotated = rotate([TAU / 4], geometry)
+  let obs = geom3.toPoints(rotated)
+  let exp = [
+    [[-2, 12, -7.000000000000001], [-2, -18, -6.999999999999999],
+      [-2, -18, 13.000000000000002], [-2, 12, 13]],
+    [[8, 12, -7.000000000000001], [8, 12, 13],
+      [8, -18, 13.000000000000002], [8, -18, -6.999999999999999]],
+    [[-2, 12, -7.000000000000001], [8, 12, -7.000000000000001],
+      [8, -18, -6.999999999999999], [-2, -18, -6.999999999999999]],
+    [[-2, 12, 13], [-2, -18, 13.000000000000002],
+      [8, -18, 13.000000000000002], [8, 12, 13]],
+    [[-2, 12, -7.000000000000001], [-2, 12, 13],
+      [8, 12, 13], [8, 12, -7.000000000000001]],
+    [[-2, -18, -6.999999999999999], [8, -18, -6.999999999999999],
+      [8, -18, 13.000000000000002], [-2, -18, 13.000000000000002]]
+  ]
+  t.notThrows(() => geom3.validate(rotated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  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, -TAU / 4], geometry)
+  obs = geom3.toPoints(rotated)
+  exp = [
+    [[12, -7, -2.000000000000001], [-18, -7, -1.999999999999999],
+      [-18, 13, -1.999999999999999], [12, 13, -2.000000000000001]],
+    [[12, -7, 7.999999999999999], [12, 13, 7.999999999999999],
+      [-18, 13, 8.000000000000002], [-18, -7, 8.000000000000002]],
+    [[12, -7, -2.000000000000001], [12, -7, 7.999999999999999],
+      [-18, -7, 8.000000000000002], [-18, -7, -1.999999999999999]],
+    [[12, 13, -2.000000000000001], [-18, 13, -1.999999999999999],
+      [-18, 13, 8.000000000000002], [12, 13, 7.999999999999999]],
+    [[12, -7, -2.000000000000001], [12, 13, -2.000000000000001],
+      [12, 13, 7.999999999999999], [12, -7, 7.999999999999999]],
+    [[-18, -7, -1.999999999999999], [-18, -7, 8.000000000000002],
+      [-18, 13, 8.000000000000002], [-18, 13, -1.999999999999999]]
+  ]
+  t.notThrows(() => geom3.validate(rotated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  rotated = rotateY(-TAU / 4, geometry)
+  obs = geom3.toPoints(rotated)
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // rotate about Z
+  rotated = rotate([0, 0, TAU / 2], geometry)
+  obs = geom3.toPoints(rotated)
+  exp = [
+    [[2.000000000000001, 7, -12], [2.000000000000001, 7, 18],
+      [1.9999999999999984, -13, 18], [1.9999999999999984, -13, -12]],
+    [[-7.999999999999999, 7.000000000000001, -12], [-8.000000000000002, -12.999999999999998, -12],
+      [-8.000000000000002, -12.999999999999998, 18], [-7.999999999999999, 7.000000000000001, 18]],
+    [[2.000000000000001, 7, -12], [-7.999999999999999, 7.000000000000001, -12],
+      [-7.999999999999999, 7.000000000000001, 18], [2.000000000000001, 7, 18]],
+    [[1.9999999999999984, -13, -12], [1.9999999999999984, -13, 18],
+      [-8.000000000000002, -12.999999999999998, 18], [-8.000000000000002, -12.999999999999998, -12]],
+    [[2.000000000000001, 7, -12], [1.9999999999999984, -13, -12],
+      [-8.000000000000002, -12.999999999999998, -12], [-7.999999999999999, 7.000000000000001, -12]],
+    [[2.000000000000001, 7, 18], [-7.999999999999999, 7.000000000000001, 18],
+      [-8.000000000000002, -12.999999999999998, 18], [1.9999999999999984, -13, 18]]
+  ]
+  t.notThrows(() => geom3.validate(rotated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  rotated = rotateZ(TAU / 2, geometry)
+  obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
+  t.true(comparePolygonsAsPoints(obs, exp))
+})
+
+test('rotate: rotating of multiple objects produces expected changes', (t) => {
+  const junk = 'hello'
+  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, TAU / 4], junk, geometry1, geometry2)
+
+  t.is(rotated[0], junk)
+
+  const obs1 = path2.toPoints(rotated[1])
+  const exp1 = [[-5, -5], [-5, 5], [5, -5], [5.000000000000001, 10]]
+  t.notThrows(() => path2.validate(rotated[1]))
+  t.true(comparePoints(obs1, exp1))
+
+  const obs2 = geom2.toPoints(rotated[2])
+  const exp2 = [[5, -5], [-5, 3.061616997868383e-16], [5.000000000000001, 10]]
+  t.notThrows(() => geom2.validate(rotated[2]))
+  t.true(comparePoints(obs2, exp2))
+})

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

@@ -0,0 +1,19 @@
+import { Geometry } from '../../geometries/types'
+import { Vec1, Vec2, Vec3 } from '../../maths/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export function scale<T extends Geometry>(factors: Vec1 | Vec2 | Vec3, geometry: T): T
+export function scale<T extends Geometry>(factors: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<T>): Array<T>
+export function scale(factors: Vec1 | Vec2 | Vec3, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function scaleX<T extends Geometry>(factor: number, geometry: T): T
+export function scaleX<T extends Geometry>(factor: number, ...geometries: RecursiveArray<T>): Array<T>
+export function scaleX(factor: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function scaleY<T extends Geometry>(factor: number, geometry: T): T
+export function scaleY<T extends Geometry>(factor: number, ...geometries: RecursiveArray<T>): Array<T>
+export function scaleY(factor: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function scaleZ<T extends Geometry>(factor: number, geometry: T): T
+export function scaleZ<T extends Geometry>(factor: number, ...geometries: RecursiveArray<T>): Array<T>
+export function scaleZ(factor: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/transforms/scale.js

@@ -0,0 +1,74 @@
+const flatten = require('../../utils/flatten')
+
+const mat4 = require('../../maths/mat4')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/**
+ * Scale the given objects using the given options.
+ * @param {Array} factors - X, Y, Z factors by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
+ * @alias module:modeling/transforms.scale
+ *
+ * @example
+ * let myshape = scale([5, 0, 10], sphere())
+ */
+const scale = (factors, ...objects) => {
+  if (!Array.isArray(factors)) throw new Error('factors must be an array')
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  // adjust the factors if necessary
+  factors = factors.slice() // don't modify the original
+  while (factors.length < 3) factors.push(1)
+
+  if (factors[0] <= 0 || factors[1] <= 0 || factors[2] <= 0) throw new Error('factors must be positive')
+
+  const matrix = mat4.fromScaling(mat4.create(), factors)
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+/**
+ * Scale the given objects about the X axis using the given options.
+ * @param {Number} factor - X factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
+ * @alias module:modeling/transforms.scaleX
+ */
+const scaleX = (factor, ...objects) => scale([factor, 1, 1], objects)
+
+/**
+ * Scale the given objects about the Y axis using the given options.
+ * @param {Number} factor - Y factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
+ * @alias module:modeling/transforms.scaleY
+ */
+const scaleY = (factor, ...objects) => scale([1, factor, 1], objects)
+
+/**
+ * Scale the given objects about the Z axis using the given options.
+ * @param {Number} factor - Z factor by which to scale the objects
+ * @param {...Object} objects - the objects to scale
+ * @return {Object|Array} the scaled object, or a list of scaled objects
+ * @alias module:modeling/transforms.scaleZ
+ */
+const scaleZ = (factor, ...objects) => scale([1, 1, factor], objects)
+
+module.exports = {
+  scale,
+  scaleX,
+  scaleY,
+  scaleZ
+}

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

@@ -0,0 +1,151 @@
+const test = require('ava')
+
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { scale, scaleX, scaleY, scaleZ } = require('./index')
+
+test('scale: scaling of a path2 produces expected changes to points', (t) => {
+  const geometry = path2.fromPoints({}, [[0, 4], [1, 0]])
+
+  // scale X
+  let scaled = scale([3], geometry)
+  let obs = path2.toPoints(scaled)
+  let exp = [[0, 4], [3, 0]]
+  t.notThrows(() => path2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  scaled = scaleX(3, geometry)
+  obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  // scale Y
+  scaled = scale([1, 0.5], geometry)
+  obs = path2.toPoints(scaled)
+  exp = [[0, 2], [1, 0]]
+  t.notThrows(() => path2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  scaled = scaleY(0.5, geometry)
+  obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+})
+
+test('scale: scaling of a geom2 produces expected changes to points', (t) => {
+  const geometry = geom2.fromPoints([[-1, 0], [1, 0], [0, 1]])
+
+  // scale X
+  let scaled = scale([3], geometry)
+  let obs = geom2.toPoints(scaled)
+  let exp = [[-3, 0], [3, 0], [0, 1]]
+  t.notThrows(() => geom2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  scaled = scaleX(3, geometry)
+  obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  // scale Y
+  scaled = scale([1, 3], geometry)
+  obs = geom2.toPoints(scaled)
+  exp = [[-1, 0], [1, 0], [0, 3]]
+  t.notThrows(() => geom2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+
+  scaled = scaleY(3, geometry)
+  obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
+  t.true(comparePoints(obs, exp))
+})
+
+test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
+  const points = [
+    [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
+    [[8, -7, -12], [8, 13, -12], [8, 13, 18], [8, -7, 18]],
+    [[-2, -7, -12], [8, -7, -12], [8, -7, 18], [-2, -7, 18]],
+    [[-2, 13, -12], [-2, 13, 18], [8, 13, 18], [8, 13, -12]],
+    [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
+    [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
+  ]
+  const geometry = geom3.fromPoints(points)
+
+  // scale X
+  let scaled = scale([3], geometry)
+  let obs = geom3.toPoints(scaled)
+  let exp = [
+    [[-6, -7, -12], [-6, -7, 18], [-6, 13, 18], [-6, 13, -12]],
+    [[24, -7, -12], [24, 13, -12], [24, 13, 18], [24, -7, 18]],
+    [[-6, -7, -12], [24, -7, -12], [24, -7, 18], [-6, -7, 18]],
+    [[-6, 13, -12], [-6, 13, 18], [24, 13, 18], [24, 13, -12]],
+    [[-6, -7, -12], [-6, 13, -12], [24, 13, -12], [24, -7, -12]],
+    [[-6, -7, 18], [24, -7, 18], [24, 13, 18], [-6, 13, 18]]
+  ]
+  t.notThrows(() => geom3.validate(scaled))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  scaled = scaleX(3, geometry)
+  obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // scale Y
+  scaled = scale([1, 0.5], geometry)
+  obs = geom3.toPoints(scaled)
+  exp = [
+    [[-2, -3.5, -12], [-2, -3.5, 18], [-2, 6.5, 18], [-2, 6.5, -12]],
+    [[8, -3.5, -12], [8, 6.5, -12], [8, 6.5, 18], [8, -3.5, 18]],
+    [[-2, -3.5, -12], [8, -3.5, -12], [8, -3.5, 18], [-2, -3.5, 18]],
+    [[-2, 6.5, -12], [-2, 6.5, 18], [8, 6.5, 18], [8, 6.5, -12]],
+    [[-2, -3.5, -12], [-2, 6.5, -12], [8, 6.5, -12], [8, -3.5, -12]],
+    [[-2, -3.5, 18], [8, -3.5, 18], [8, 6.5, 18], [-2, 6.5, 18]]
+  ]
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  scaled = scaleY(0.5, geometry)
+  obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  // scale Z
+  scaled = scale([1, 1, 5], geometry)
+  obs = geom3.toPoints(scaled)
+  exp = [
+    [[-2, -7, -60], [-2, -7, 90], [-2, 13, 90], [-2, 13, -60]],
+    [[8, -7, -60], [8, 13, -60], [8, 13, 90], [8, -7, 90]],
+    [[-2, -7, -60], [8, -7, -60], [8, -7, 90], [-2, -7, 90]],
+    [[-2, 13, -60], [-2, 13, 90], [8, 13, 90], [8, 13, -60]],
+    [[-2, -7, -60], [-2, 13, -60], [8, 13, -60], [8, -7, -60]],
+    [[-2, -7, 90], [8, -7, 90], [8, 13, 90], [-2, 13, 90]]
+  ]
+  t.notThrows(() => geom3.validate(scaled))
+  t.true(comparePolygonsAsPoints(obs, exp))
+
+  scaled = scaleZ(5, geometry)
+  obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
+  t.true(comparePolygonsAsPoints(obs, exp))
+})
+
+test('scale: scaling of multiple objects produces expected changes', (t) => {
+  const junk = 'hello'
+  const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
+  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+
+  const scaled = scale([3, 1, 1], junk, geometry1, geometry2)
+
+  t.is(scaled[0], junk)
+
+  const obs1 = path2.toPoints(scaled[1])
+  const exp1 = [[-15, 5], [15, 5], [-15, -5], [30, -5]]
+  t.notThrows(() => path2.validate(scaled[1]))
+  t.true(comparePoints(obs1, exp1))
+
+  const obs2 = geom2.toPoints(scaled[2])
+  const exp2 = [[-15, -5], [0, 5], [30, -5]]
+  t.notThrows(() => geom2.validate(scaled[2]))
+  t.true(comparePoints(obs2, exp2))
+})

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

@@ -0,0 +1,7 @@
+import { Geometry } from '../../geometries/types'
+import Mat4 from '../../maths/mat4/type'
+import RecursiveArray from '../../utils/recursiveArray'
+
+export function transform<T extends Geometry>(matrix: Mat4, geometry: T): T
+export function transform<T extends Geometry>(matrix: Mat4, ...geometries: RecursiveArray<T>): Array<T>
+export function transform(matrix: Mat4, ...geometries: RecursiveArray<Geometry>): Array<Geometry>

package/src/operations/transforms/transform.js

@@ -0,0 +1,32 @@
+const flatten = require('../../utils/flatten')
+
+const geom2 = require('../../geometries/geom2')
+const geom3 = require('../../geometries/geom3')
+const path2 = require('../../geometries/path2')
+
+/**
+ * Transform the given objects using the given matrix.
+ * @param {mat4} matrix - a transformation matrix
+ * @param {...Object} objects - the objects to transform
+ * @return {Object|Array} the transformed object, or a list of transformed objects
+ * @alias module:modeling/transforms.transform
+ *
+ * @example
+ * const newsphere = transform(mat4.rotateX(TAU / 8), sphere())
+ */
+const transform = (matrix, ...objects) => {
+  // TODO how to check that the matrix is REAL?
+
+  objects = flatten(objects)
+  if (objects.length === 0) throw new Error('wrong number of arguments')
+
+  const results = objects.map((object) => {
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (geom3.isA(object)) return geom3.transform(matrix, object)
+    return object
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = transform

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

@@ -0,0 +1,76 @@
+const test = require('ava')
+
+const { comparePoints, comparePolygonsAsPoints } = require('../../../test/helpers')
+
+const mat4 = require('../../maths/mat4')
+
+const { geom2, geom3, path2 } = require('../../geometries')
+
+const { transform } = require('./index')
+
+test('transform: transforming of a path2 produces expected changes to points', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
+  let geometry = path2.fromPoints({}, [[0, 0], [1, 0]])
+
+  geometry = transform(matrix, geometry)
+  const obs = path2.toPoints(geometry)
+  const exp = [[2, 2], [3, 2]]
+  t.notThrows(() => path2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('transform: transforming of a geom2 produces expected changes to sides', (t) => {
+  const matrix = mat4.fromScaling(mat4.create(), [5, 5, 5])
+  let geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+
+  geometry = transform(matrix, geometry)
+  const obs = geom2.toPoints(geometry)
+  const exp = [[0, 0], [5, 0], [0, 5]]
+  t.notThrows(() => geom2.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('transform: transforming of a geom3 produces expected changes to polygons', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [-3, -3, -3])
+  const points = [
+    [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
+    [[8, -7, -12], [8, 13, -12], [8, 13, 18], [8, -7, 18]],
+    [[-2, -7, -12], [8, -7, -12], [8, -7, 18], [-2, -7, 18]],
+    [[-2, 13, -12], [-2, 13, 18], [8, 13, 18], [8, 13, -12]],
+    [[-2, -7, -12], [-2, 13, -12], [8, 13, -12], [8, -7, -12]],
+    [[-2, -7, 18], [8, -7, 18], [8, 13, 18], [-2, 13, 18]]
+  ]
+  let geometry = geom3.fromPoints(points)
+  geometry = transform(matrix, geometry)
+  const obs = geom3.toPoints(geometry)
+  const exp = [
+    [[-5, -10, -15], [-5, -10, 15], [-5, 10, 15], [-5, 10, -15]],
+    [[5, -10, -15], [5, 10, -15], [5, 10, 15], [5, -10, 15]],
+    [[-5, -10, -15], [5, -10, -15], [5, -10, 15], [-5, -10, 15]],
+    [[-5, 10, -15], [-5, 10, 15], [5, 10, 15], [5, 10, -15]],
+    [[-5, -10, -15], [-5, 10, -15], [5, 10, -15], [5, -10, -15]],
+    [[-5, -10, 15], [5, -10, 15], [5, 10, 15], [-5, 10, 15]]
+  ]
+  t.notThrows(() => geom3.validate(geometry))
+  t.true(comparePolygonsAsPoints(obs, exp))
+})
+
+test('transform: transforming of multiple objects produces expected changes', (t) => {
+  const junk = 'hello'
+  const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
+  const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
+
+  const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
+  const transformed = transform(matrix, junk, geometry1, geometry2)
+  t.is(transformed[0], junk)
+
+  let obs = path2.toPoints(transformed[1])
+  let exp = [[-3, 7], [7, 7], [-3, -3], [12, -3]]
+  t.notThrows(() => path2.validate(transformed[1]))
+  t.true(comparePoints(obs, exp))
+
+  obs = geom2.toPoints(transformed[2])
+  exp = [[-3, -3], [2, 7], [12, -3]]
+  t.notThrows(() => geom2.validate(transformed[2]))
+  t.true(comparePoints(obs, exp))
+})

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

@@ -0,0 +1,21 @@
+import { Geometry } from '../../geometries/types'
+import { Vec1, Vec2, Vec3 } from '../../maths/types'
+import RecursiveArray from '../../utils/recursiveArray'
+
+type Vec = Vec1 | Vec2 | Vec3
+
+export function translate<T extends Geometry>(offset: Vec, geometry: T): T
+export function translate<T extends Geometry>(offset: Vec, ...geometries: RecursiveArray<T>): Array<T>
+export function translate(offset: Vec, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function translateX<T extends Geometry>(offset: number, geometry: T): T
+export function translateX<T extends Geometry>(offset: number, ...geometries: RecursiveArray<T>): Array<T>
+export function translateX(offset: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function translateY<T extends Geometry>(offset: number, geometry: T): T
+export function translateY<T extends Geometry>(offset: number, ...geometries: RecursiveArray<T>): Array<T>
+export function translateY(offset: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>
+
+export function translateZ<T extends Geometry>(offset: number, geometry: T): T
+export function translateZ<T extends Geometry>(offset: number, ...geometries: RecursiveArray<T>): Array<T>
+export function translateZ(offset: number, ...geometries: RecursiveArray<Geometry>): Array<Geometry>