@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/maths/OrthoNormalBasis.js

@@ -1,207 +0,0 @@
-const mat4 = require('./mat4')
-
-const vec2 = require('./vec2')
-const vec3 = require('./vec3')
-
-/*
- * Class OrthoNormalBasis
- * Reprojects points on a 3D plane onto a 2D plane
- * or from a 2D plane back onto the 3D plane
- * @param  {plane} plane
- * @param  {vec3} rightvector
- */
-const OrthoNormalBasis = function (plane, rightvector) {
-  if (arguments.length < 2) {
-    // choose an arbitrary right hand vector, making sure it is somewhat orthogonal to the plane normal:
-    rightvector = vec3.orthogonal(vec3.create(), plane)
-  }
-  this.v = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), plane, rightvector))
-  this.u = vec3.cross(vec3.create(), this.v, plane)
-  this.plane = plane
-  this.planeorigin = vec3.scale(vec3.create(), plane, plane[3])
-}
-
-// Get an orthonormal basis for the standard XYZ planes.
-// Parameters: the names of two 3D axes. The 2d x axis will map to the first given 3D axis, the 2d y
-// axis will map to the second.
-// Prepend the axis with a "-" to invert the direction of this axis.
-// For example: OrthoNormalBasis.GetCartesian("-Y","Z")
-//   will return an orthonormal basis where the 2d X axis maps to the 3D inverted Y axis, and
-//   the 2d Y axis maps to the 3D Z axis.
-OrthoNormalBasis.GetCartesian = function (xaxisid, yaxisid) {
-  const axisid = xaxisid + '/' + yaxisid
-  let planenormal, rightvector
-  if (axisid === 'X/Y') {
-    planenormal = [0, 0, 1]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Y/-X') {
-    planenormal = [0, 0, 1]
-    rightvector = [0, 1, 0]
-  } else if (axisid === '-X/-Y') {
-    planenormal = [0, 0, 1]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Y/X') {
-    planenormal = [0, 0, 1]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-X/Y') {
-    planenormal = [0, 0, -1]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Y/-X') {
-    planenormal = [0, 0, -1]
-    rightvector = [0, -1, 0]
-  } else if (axisid === 'X/-Y') {
-    planenormal = [0, 0, -1]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Y/X') {
-    planenormal = [0, 0, -1]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'X/Z') {
-    planenormal = [0, -1, 0]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Z/-X') {
-    planenormal = [0, -1, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === '-X/-Z') {
-    planenormal = [0, -1, 0]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Z/X') {
-    planenormal = [0, -1, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === '-X/Z') {
-    planenormal = [0, 1, 0]
-    rightvector = [-1, 0, 0]
-  } else if (axisid === '-Z/-X') {
-    planenormal = [0, 1, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === 'X/-Z') {
-    planenormal = [0, 1, 0]
-    rightvector = [1, 0, 0]
-  } else if (axisid === 'Z/X') {
-    planenormal = [0, 1, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === 'Y/Z') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'Z/-Y') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 0, 1]
-  } else if (axisid === '-Y/-Z') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-Z/Y') {
-    planenormal = [1, 0, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === '-Y/Z') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, -1, 0]
-  } else if (axisid === '-Z/-Y') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 0, -1]
-  } else if (axisid === 'Y/-Z') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 1, 0]
-  } else if (axisid === 'Z/Y') {
-    planenormal = [-1, 0, 0]
-    rightvector = [0, 0, 1]
-  } else {
-    throw new Error('OrthoNormalBasis.GetCartesian: invalid combination of axis identifiers. Should pass two string arguments from [X,Y,Z,-X,-Y,-Z], being two different axes.')
-  }
-  return new OrthoNormalBasis(new Plane(new Vector3D(planenormal), 0), new Vector3D(rightvector))
-}
-
-/*
-// test code for OrthoNormalBasis.GetCartesian()
-OrthoNormalBasis.GetCartesian_Test=function() {
-  let axisnames=["X","Y","Z","-X","-Y","-Z"];
-  let axisvectors=[[1,0,0], [0,1,0], [0,0,1], [-1,0,0], [0,-1,0], [0,0,-1]];
-  for(let axis1=0; axis1 < 3; axis1++) {
-    for(let axis1inverted=0; axis1inverted < 2; axis1inverted++) {
-      let axis1name=axisnames[axis1+3*axis1inverted];
-      let axis1vector=axisvectors[axis1+3*axis1inverted];
-      for(let axis2=0; axis2 < 3; axis2++) {
-        if(axis2 != axis1) {
-          for(let axis2inverted=0; axis2inverted < 2; axis2inverted++) {
-            let axis2name=axisnames[axis2+3*axis2inverted];
-            let axis2vector=axisvectors[axis2+3*axis2inverted];
-            let orthobasis=OrthoNormalBasis.GetCartesian(axis1name, axis2name);
-            let test1=orthobasis.to3D(new Vector2D([1,0]));
-            let test2=orthobasis.to3D(new Vector2D([0,1]));
-            let expected1=new Vector3D(axis1vector);
-            let expected2=new Vector3D(axis2vector);
-            let d1=test1.distanceTo(expected1);
-            let d2=test2.distanceTo(expected2);
-            if( (d1 > 0.01) || (d2 > 0.01) ) {
-              throw new Error("Wrong!");
-  }}}}}}
-  throw new Error("OK");
-};
-*/
-
-// The z=0 plane, with the 3D x and y vectors mapped to the 2D x and y vector
-OrthoNormalBasis.Z0Plane = function () {
-  const plane = new Plane(new Vector3D([0, 0, 1]), 0)
-  return new OrthoNormalBasis(plane, new Vector3D([1, 0, 0]))
-}
-
-OrthoNormalBasis.prototype = {
-
-  getProjectionMatrix: function () {
-    return mat4.fromValues(
-      this.u[0], this.v[0], this.plane[0], 0,
-      this.u[1], this.v[1], this.plane[1], 0,
-      this.u[2], this.v[2], this.plane[2], 0,
-      0, 0, -this.plane[3], 1
-    )
-  },
-
-  getInverseProjectionMatrix: function () {
-    const p = vec3.scale(vec3.create(), this.plane, this.plane[3])
-    return mat4.fromValues(
-      this.u[0], this.u[1], this.u[2], 0,
-      this.v[0], this.v[1], this.v[2], 0,
-      this.plane[0], this.plane[1], this.plane[2], 0,
-      p[0], p[1], p[2], 1
-    )
-  },
-
-  to2D: function (point) {
-    return vec2.fromValues(vec3.dot(point, this.u), vec3.dot(point, this.v))
-  },
-
-  to3D: function (point) {
-    const v1 = vec3.scale(vec3.create(), this.u, point[0])
-    const v2 = vec3.scale(vec3.create(), this.v, point[1])
-
-    const v3 = vec3.add(v1, v1, this.planeorigin)
-    const v4 = vec3.add(v2, v2, v3)
-    return v4
-  },
-
-  line3Dto2D: function (line3d) {
-    const a = line3d.point
-    const b = line3d.direction.plus(a)
-    const a2d = this.to2D(a)
-    const b2d = this.to2D(b)
-    return Line2D.fromPoints(a2d, b2d)
-  },
-
-  line2Dto3D: function (line2d) {
-    const a = line2d.origin()
-    const b = line2d.direction().plus(a)
-    const a3d = this.to3D(a)
-    const b3d = this.to3D(b)
-    return Line3D.fromPoints(a3d, b3d)
-  },
-
-  transform: function (matrix4x4) {
-    // todo: this may not work properly in case of mirroring
-    const newplane = this.plane.transform(matrix4x4)
-    const rightpointTransformed = this.u.transform(matrix4x4)
-    const originTransformed = new Vector3D(0, 0, 0).transform(matrix4x4)
-    const newrighthandvector = rightpointTransformed.minus(originTransformed)
-    const newbasis = new OrthoNormalBasis(newplane, newrighthandvector)
-    return newbasis
-  }
-}
-
-module.exports = OrthoNormalBasis

package/src/maths/utils/index.d.ts

@@ -1,8 +0,0 @@
-export { default as aboutEqualNormals } from './aboutEqualNormals'
-export { default as area } from './area'
-export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
-export { default as intersect } from './intersect'
-export { default as solve2Linear } from './solve2Linear'
-export { sin, cos } from './trigonometry'
-
-export as namespace utils

package/src/maths/utils/index.js

@@ -1,15 +0,0 @@
-/**
- * Utility functions for maths.
- * @module modeling/maths/utils
- * @example
- * const { area, solve2Linear } = require('@jscad/maths').utils
- */
-module.exports = {
-  aboutEqualNormals: require('./aboutEqualNormals'),
-  area: require('./area'),
-  cos: require('./trigonometry').cos,
-  interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
-  intersect: require('./intersect'),
-  sin: require('./trigonometry').sin,
-  solve2Linear: require('./solve2Linear')
-}

package/src/operations/booleans/fromFakePolygons.js

@@ -1,52 +0,0 @@
-const vec2 = require('../../maths/vec2')
-
-const geom2 = require('../../geometries/geom2')
-
-const fromFakePolygon = (epsilon, polygon) => {
-  // this can happen based on union, seems to be residuals -
-  // return null and handle in caller
-  if (polygon.vertices.length < 4) {
-    return null
-  }
-  const vert1Indices = []
-  const points3D = polygon.vertices.filter((vertex, i) => {
-    if (vertex[2] > 0) {
-      vert1Indices.push(i)
-      return true
-    }
-    return false
-  })
-
-  if (points3D.length !== 2) {
-    throw new Error('Assertion failed: fromFakePolygon: not enough points found') // TBD remove later
-  }
-
-  const points2D = points3D.map((v3) => {
-    const x = Math.round(v3[0] / epsilon) * epsilon + 0 // no more -0
-    const y = Math.round(v3[1] / epsilon) * epsilon + 0 // no more -0
-    return vec2.fromValues(x, y)
-  })
-
-  if (vec2.equals(points2D[0], points2D[1])) return null
-
-  const d = vert1Indices[1] - vert1Indices[0]
-  if (d === 1 || d === 3) {
-    if (d === 1) {
-      points2D.reverse()
-    }
-  } else {
-    throw new Error('Assertion failed: fromFakePolygon: unknown index ordering')
-  }
-  return points2D
-}
-
-/*
- * Convert the given polygons to a list of sides.
- * The polygons must have only z coordinates +1 and -1, as constructed by to3DWalls().
- */
-const fromFakePolygons = (epsilon, polygons) => {
-  const sides = polygons.map((polygon) => fromFakePolygon(epsilon, polygon)).filter((polygon) => (polygon !== null))
-  return geom2.create(sides)
-}
-
-module.exports = fromFakePolygons

package/src/operations/booleans/to3DWalls.js

@@ -1,36 +0,0 @@
-const vec3 = require('../../maths/vec3')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
-
-/*
- * Create a polygon (wall) from the given Z values and side.
- */
-const to3DWall = (z0, z1, side) => {
-  const points = [
-    vec3.fromVec2(vec3.create(), side[0], z0),
-    vec3.fromVec2(vec3.create(), side[1], z0),
-    vec3.fromVec2(vec3.create(), side[1], z1),
-    vec3.fromVec2(vec3.create(), side[0], z1)
-  ]
-  return poly3.create(points)
-}
-
-/*
- * Create a 3D geometry with walls, as constructed from the given options and geometry.
- *
- * @param {Object} options - options with Z offsets
- * @param {geom2} geometry - geometry used as base of walls
- * @return {geom3} the new geometry
- */
-const to3DWalls = (options, geometry) => {
-  const sides = geom2.toSides(geometry)
-
-  const polygons = sides.map((side) => to3DWall(options.z0, options.z1, side))
-
-  const result = geom3.create(polygons)
-  return result
-}
-
-module.exports = to3DWalls

package/src/operations/expansions/expand.d.ts

@@ -1,18 +0,0 @@
-import { Path2, Geom2, Geom3 } from '../../geometries/types'
-import { Corners } from '../../utils/corners'
-import RecursiveArray from '../../utils/recursiveArray'
-
-export default expand
-
-export interface ExpandOptions {
-  delta?: number
-  corners?: Corners
-  segments?: number
-}
-
-type Geom = Path2 | Geom2 | Geom3
-
-declare function expand(options: ExpandOptions, geometry: Path2 | Geom2): Geom2
-declare function expand(options: ExpandOptions, geometry: Geom3): Geom3
-declare function expand<T extends Geom>(options?: ExpandOptions, ...geometries: RecursiveArray<T>): Array<T>
-declare function expand(options?: ExpandOptions, ...geometries: RecursiveArray<Geom>): Array<Geom>

package/src/operations/expansions/expand.js

@@ -1,42 +0,0 @@
-const flatten = require('../../utils/flatten')
-
-const geom2 = require('../../geometries/geom2')
-const geom3 = require('../../geometries/geom3')
-const path2 = require('../../geometries/path2')
-
-const expandGeom2 = require('./expandGeom2')
-const expandGeom3 = require('./expandGeom3')
-const expandPath2 = require('./expandPath2')
-
-/**
- * Expand the given geometry using the given options.
- * Both internal and external space is expanded for 2D and 3D shapes.
- *
- * Note: Contract is expand using a negative delta.
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='edge'] - type of corner to create after expanding; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {...Objects} objects - the geometries to expand
- * @return {Object|Array} new geometry, or list of new geometries
- * @alias module:modeling/expansions.expand
- *
- * @example
- * let newarc = expand({delta: 5, corners: 'edge'}, arc({}))
- * let newsquare = expand({delta: 5, corners: 'chamfer'}, square({size: 30}))
- * let newsphere = expand({delta: 2, corners: 'round'}, cuboid({size: [20, 25, 5]}))
- */
-const expand = (options, ...objects) => {
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
-  const results = objects.map((object) => {
-    if (path2.isA(object)) return expandPath2(options, object)
-    if (geom2.isA(object)) return expandGeom2(options, object)
-    if (geom3.isA(object)) return expandGeom3(options, object)
-    return object
-  })
-  return results.length === 1 ? results[0] : results
-}
-
-module.exports = expand

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

@@ -1,188 +0,0 @@
-const test = require('ava')
-
-const { comparePoints, nearlyEqual } = require('../../../test/helpers')
-
-const { geom2, geom3, path2 } = require('../../geometries')
-const measureBoundingBox = require('../../measurements/measureBoundingBox')
-const area = require('../../maths/utils/area')
-const { TAU } = require('../../maths/constants')
-const sphere = require('../../primitives/sphere')
-
-const { expand } = require('./index')
-
-test('expand: edge-expanding a straight line produces rectangle', (t) => {
-  const points = [[0, 0], [0, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 40)
-  t.true(comparePoints(measureBoundingBox(expandedPathGeom2), [[-2, 0, 0], [2, 10, 0]]))
-})
-
-test('expand: edge-expanding a bent line produces expected geometry', (t) => {
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 60)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: edge-expanding a bent line, reversed points, produces expected geometry', (t) => {
-  const points = [[-5, 10], [0, 10], [0, 0]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 60)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: round-expanding a bent line produces expected geometry', (t) => {
-  const delta = 2
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta, corners: 'round', segments: 128 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  const expectedArea = 56 + TAU  * delta * 1.25 // shape will have 1 and 1/4 circles
-  nearlyEqual(t, area(expandedPoints), expectedArea, 0.01, 'Measured area should be pretty close')
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-7, -2, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: chamfer-expanding a bent line produces expected geometry', (t) => {
-  const delta = 2
-  const points = [[0, 0], [0, 10], [-5, 10]]
-  const linePath2 = path2.fromPoints({ closed: false }, points)
-  const expandedPathGeom2 = expand({ delta, corners: 'chamfer', segments: 8 }, linePath2)
-  const expandedPoints = geom2.toPoints(expandedPathGeom2)
-
-  t.notThrows(() => geom2.validate(expandedPathGeom2))
-  t.is(area(expandedPoints), 58)
-  const boundingBox = measureBoundingBox(expandedPathGeom2)
-  t.true(comparePoints(boundingBox, [[-5, 0, 0], [2, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
-})
-
-test('expand: expanding of a geom2 produces expected changes to points', (t) => {
-  const geometry = geom2.fromPoints([[-8, -8], [8, -8], [8, 8], [-8, 8]])
-
-  const obs = expand({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom2.toPoints(obs)
-  const exp = [
-    [-9.414213562373096, -9.414213562373096],
-    [-8, -10],
-    [8, -10],
-    [9.414213562373096, -9.414213562373096],
-    [10, -8],
-    [10, 8],
-    [9.414213562373096, 9.414213562373096],
-    [8, 10],
-    [-8, 10],
-    [-9.414213562373096, 9.414213562373096],
-    [-10, 8],
-    [-10, -8]
-  ]
-  t.notThrows(() => geom2.validate(obs))
-  t.is(pts.length, 12)
-  t.true(comparePoints(pts, exp))
-})
-
-test('expand: expanding of a geom3 produces expected changes to polygons', (t) => {
-  const polygonsAsPoints = [
-    [[-5, -5, -5], [-5, -5, 15], [-5, 15, 15], [-5, 15, -5]],
-    [[15, -5, -5], [15, 15, -5], [15, 15, 15], [15, -5, 15]],
-    [[-5, -5, -5], [15, -5, -5], [15, -5, 15], [-5, -5, 15]],
-    [[-5, 15, -5], [-5, 15, 15], [15, 15, 15], [15, 15, -5]],
-    [[-5, -5, -5], [-5, 15, -5], [15, 15, -5], [15, -5, -5]],
-    [[-5, -5, 15], [15, -5, 15], [15, 15, 15], [-5, 15, 15]]
-  ]
-  const geometry = geom3.fromPoints(polygonsAsPoints)
-
-  const obs = expand({ delta: 2, corners: 'round', segments: 8 }, geometry)
-  const pts = geom3.toPoints(obs)
-  const exp0 = [
-    [-7, -5, -5],
-    [-7, -5, 15],
-    [-7, 15, 15],
-    [-7, 15, -5]
-  ]
-  const exp61 = [
-    [15, -7, 15],
-    [16.414213562373096, -6.414213562373095, 15],
-    [16, -6.414213562373095, 16]
-  ]
-
-  t.notThrows.skip(() => geom3.validate(obs))
-  t.is(pts.length, 62)
-  t.true(comparePoints(pts[0], exp0))
-  t.true(comparePoints(pts[61], exp61))
-
-  const geometry2 = sphere({ radius: 5, segments: 8 })
-  const obs2 = expand({ delta: 5 }, geometry2)
-  const pts2 = geom3.toPoints(obs2)
-  t.notThrows.skip(() => geom3.validate(obs2))
-  t.is(pts2.length, 864)
-})
-
-test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {
-  const geometry = geom2.create([
-    [[-75, 75], [-75, -75]],
-    [[-75, -75], [75, -75]],
-    [[75, -75], [75, 75]],
-    [[-40, 75], [-75, 75]],
-    [[75, 75], [40, 75]],
-    [[40, 75], [40, 0]],
-    [[40, 0], [-40, 0]],
-    [[-40, 0], [-40, 75]],
-    [[15, -10], [15, -40]],
-    [[-15, -10], [15, -10]],
-    [[-15, -40], [-15, -10]],
-    [[-8, -40], [-15, -40]],
-    [[15, -40], [8, -40]],
-    [[-8, -25], [-8, -40]],
-    [[8, -25], [-8, -25]],
-    [[8, -40], [8, -25]],
-    [[-2, -15], [-2, -19]],
-    [[-2, -19], [2, -19]],
-    [[2, -19], [2, -15]],
-    [[2, -15], [-2, -15]]
-  ])
-
-  // expand +
-  const obs = expand({ delta: 2, corners: 'edge' }, geometry)
-  const pts = geom2.toPoints(obs)
-  const exp = [
-    [77, -77],
-    [77, 77],
-    [38, 77],
-    [38, 2],
-    [-38, 2],
-    [-37.99999999999999, 77],
-    [-77, 77],
-    [16.999999999999996, -42],
-    [6, -42],
-    [6, -27],
-    [-6, -27],
-    [-6.000000000000001, -42],
-    [-17, -42],
-    [-16.999999999999996, -8],
-    [17, -8.000000000000004],
-    [-4, -21],
-    [3.9999999999999996, -21],
-    [4, -13],
-    [-4, -13],
-    [-77, -77]
-  ]
-  t.notThrows(() => geom2.validate(obs))
-  t.is(pts.length, 20)
-  t.true(comparePoints(pts, exp))
-})

package/src/operations/expansions/expandGeom2.js

@@ -1,43 +0,0 @@
-const geom2 = require('../../geometries/geom2')
-
-const offsetFromPoints = require('./offsetFromPoints')
-
-/*
- * Expand the given geometry (geom2) using the given options (if any).
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='edge'] - type corner to create during of expansion; edge, chamfer, round
- * @param {Integer} [options.segments=16] - number of segments when creating round corners
- * @param {geom2} geometry - the geometry to expand
- * @returns {geom2} expanded geometry
- */
-const expandGeom2 = (options, geometry) => {
-  const defaults = {
-    delta: 1,
-    corners: 'edge',
-    segments: 16
-  }
-  const { delta, corners, segments } = Object.assign({ }, defaults, options)
-
-  if (!(corners === 'edge' || corners === 'chamfer' || corners === 'round')) {
-    throw new Error('corners must be "edge", "chamfer", or "round"')
-  }
-
-  // convert the geometry to outlines, and generate offsets from each
-  const outlines = geom2.toOutlines(geometry)
-  const newoutlines = outlines.map((outline) => {
-    options = {
-      delta,
-      corners,
-      closed: true,
-      segments
-    }
-    return offsetFromPoints(options, outline)
-  })
-
-  // create a composite geometry from the new outlines
-  const allsides = newoutlines.reduce((sides, newoutline) => sides.concat(geom2.toSides(geom2.fromPoints(newoutline))), [])
-  return geom2.create(allsides)
-}
-
-module.exports = expandGeom2

package/src/operations/expansions/expandGeom3.js

@@ -1,36 +0,0 @@
-const geom3 = require('../../geometries/geom3')
-
-const union = require('../booleans/union')
-
-const expandShell = require('./expandShell')
-
-/*
- * Expand the given geometry (geom3) using the given options (if any).
- * @param {Object} options - options for expand
- * @param {Number} [options.delta=1] - delta (+/-) of expansion
- * @param {String} [options.corners='round'] - type corner to create during of expansion; round
- * @param {Integer} [options.segments=12] - number of segments when creating round corners
- * @param {geom3} geometry - the geometry to expand
- * @returns {geom3} expanded geometry
- */
-const expandGeom3 = (options, geometry) => {
-  const defaults = {
-    delta: 1,
-    corners: 'round',
-    segments: 12
-  }
-  const { delta, corners, segments } = Object.assign({ }, defaults, options)
-
-  if (!(corners === 'round')) {
-    throw new Error('corners must be "round" for 3D geometries')
-  }
-
-  const polygons = geom3.toPolygons(geometry)
-  if (polygons.length === 0) throw new Error('the given geometry cannot be empty')
-
-  options = { delta, corners, segments }
-  const expanded = expandShell(options, geometry)
-  return union(geometry, expanded)
-}
-
-module.exports = expandGeom3

package/src/operations/expansions/extrudePolygon.js

@@ -1,34 +0,0 @@
-const mat4 = require('../../maths/mat4')
-const vec3 = require('../../maths/vec3')
-
-const geom3 = require('../../geometries/geom3')
-const poly3 = require('../../geometries/poly3')
-
-// Extrude a polygon in the direction of the offsetvector.
-// Returns (geom3) a new geometry
-const extrudePolygon = (offsetvector, polygon1) => {
-  const direction = vec3.dot(poly3.plane(polygon1), offsetvector)
-  if (direction > 0) {
-    polygon1 = poly3.invert(polygon1)
-  }
-
-  const newpolygons = [polygon1]
-
-  const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1)
-  const numvertices = polygon1.vertices.length
-  for (let i = 0; i < numvertices; i++) {
-    const nexti = (i < (numvertices - 1)) ? i + 1 : 0
-    const sideFacePolygon = poly3.create([
-      polygon1.vertices[i],
-      polygon2.vertices[i],
-      polygon2.vertices[nexti],
-      polygon1.vertices[nexti]
-    ])
-    newpolygons.push(sideFacePolygon)
-  }
-  newpolygons.push(poly3.invert(polygon2))
-
-  return geom3.create(newpolygons)
-}
-
-module.exports = extrudePolygon