@jscad/modeling 2.5.2 → 2.7.0

package/src/measurements/measureCenterOfMass.js

@@ -0,0 +1,106 @@
+const flatten = require('../utils/flatten')
+
+const vec3 = require('../maths/vec3')
+
+const geom2 = require('../geometries/geom2')
+const geom3 = require('../geometries/geom3')
+
+const cacheOfCenterOfMass = new WeakMap()
+
+/*
+ * Measure the center of mass for the given geometry.
+ *
+ * @see http://paulbourke.net/geometry/polygonmesh/
+ * @return {Array} the center of mass for the geometry
+ */
+const measureCenterOfMassGeom2 = (geometry) => {
+  let centerOfMass = cacheOfCenterOfMass.get(geometry)
+  if (centerOfMass !== undefined) return centerOfMass
+
+  const sides = geom2.toSides(geometry)
+
+  let area = 0
+  let x = 0
+  let y = 0
+  if (sides.length > 0) {
+    for (let i = 0; i < sides.length; i++) {
+      const p1 = sides[i][0]
+      const p2 = sides[i][1]
+
+      const a = p1[0] * p2[1] - p1[1] * p2[0]
+      area += a
+      x += (p1[0] + p2[0]) * a
+      y += (p1[1] + p2[1]) * a
+    }
+    area /= 2
+
+    const f = 1 / (area * 6)
+    x *= f
+    y *= f
+  }
+
+  centerOfMass = vec3.fromValues(x, y, 0)
+
+  cacheOfCenterOfMass.set(geometry, centerOfMass)
+  return centerOfMass
+}
+
+/*
+ * Measure the center of mass for the given geometry.
+ * @return {Array} the center of mass for the geometry
+ */
+const measureCenterOfMassGeom3 = (geometry) => {
+  let centerOfMass = cacheOfCenterOfMass.get(geometry)
+  if (centerOfMass !== undefined) return centerOfMass
+
+  centerOfMass = vec3.create() // 0, 0, 0
+
+  const polygons = geom3.toPolygons(geometry)
+  if (polygons.length === 0) return centerOfMass
+
+  let totalVolume = 0
+  const vector = vec3.create() // for speed
+  polygons.forEach((polygon) => {
+    // calculate volume and center of each tetrahedon
+    const vertices = polygon.vertices
+    for (let i = 0; i < vertices.length - 2; i++) {
+      vec3.cross(vector, vertices[i + 1], vertices[i + 2])
+      const volume = vec3.dot(vertices[0], vector) / 6
+
+      totalVolume += volume
+
+      vec3.add(vector, vertices[0], vertices[i + 1])
+      vec3.add(vector, vector, vertices[i + 2])
+      const weightedCenter = vec3.scale(vector, vector, 1 / 4 * volume)
+
+      vec3.add(centerOfMass, centerOfMass, weightedCenter)
+    }
+  })
+  vec3.scale(centerOfMass, centerOfMass, 1 / totalVolume)
+
+  cacheOfCenterOfMass.set(geometry, centerOfMass)
+  return centerOfMass
+}
+
+/**
+ * Measure the center of mass for the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the center of mass for each geometry, i.e. [X, Y, Z]
+ * @alias module:modeling/measurements.measureCenterOfMass
+ *
+ * @example
+ * let center = measureCenterOfMass(sphere())
+ */
+const measureCenterOfMass = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    // NOTE: center of mass for geometry path2 is not possible
+    if (geom2.isA(geometry)) return measureCenterOfMassGeom2(geometry)
+    if (geom3.isA(geometry)) return measureCenterOfMassGeom3(geometry)
+    return [0, 0, 0]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureCenterOfMass

package/src/measurements/measureCenterOfMass.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { ellipsoid, line, rectangle, cuboid } = require('../primitives')
+
+const { measureCenterOfMass } = require('./index')
+
+test('measureCenterOfMass (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ center: [5, 5] })
+  const acube = cuboid({ size: [3, 3, 3], center: [-15, -5, -10] })
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lcenter = measureCenterOfMass(aline)
+  const rcenter = measureCenterOfMass(arect)
+  const ccenter = measureCenterOfMass(acube)
+
+  const p2center = measureCenterOfMass(apath2)
+  const g2center = measureCenterOfMass(ageom2)
+  const g3center = measureCenterOfMass(ageom3)
+
+  const ncenter = measureCenterOfMass(n)
+  const ocenter = measureCenterOfMass(o)
+  const xcenter = measureCenterOfMass(x)
+
+  t.deepEqual(lcenter, [0, 0, 0])
+  t.deepEqual(rcenter, [5, 5, 0])
+  t.deepEqual(ccenter, [-15, -5, -10])
+
+  t.deepEqual(p2center, [0, 0, 0])
+  t.deepEqual(g2center, [0, 0, 0])
+  t.deepEqual(g3center, [0, 0, 0])
+
+  t.deepEqual(ncenter, [0, 0, 0])
+  t.deepEqual(ocenter, [0, 0, 0])
+  t.deepEqual(xcenter, [0, 0, 0])
+})
+
+test('measureCenterOfMass (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20], center: [10, -10] })
+  const asphere = ellipsoid({ radius: [5, 10, 15], center: [5, -5, 50] })
+  const o = {}
+
+  let allcenters = measureCenterOfMass(aline, arect, asphere, o)
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+
+  allcenters = measureCenterOfMass(aline, arect, asphere, o)
+  t.deepEqual(allcenters, [[0, 0, 0], [10, -10, 0], [4.99999999999999, -5.000000000000007, 49.99999999999992], [0, 0, 0]])
+})

package/src/measurements/measureDimensions.js

@@ -0,0 +1,28 @@
+const flatten = require('../utils/flatten')
+
+const measureBoundingBox = require('./measureBoundingBox')
+
+/**
+ * Measure the dimensions of the given geometries.
+ * @param {...Object} geometries - the geometries to measure
+ * @return {Array} the dimensions for each geometry, i.e. [width, depth, height]
+ * @alias module:modeling/measurements.measureDimensions
+ *
+ * @example
+ * let dimensions = measureDimensions(sphere())
+ */
+const measureDimensions = (...geometries) => {
+  geometries = flatten(geometries)
+
+  const results = geometries.map((geometry) => {
+    const boundingBox = measureBoundingBox(geometry)
+    return [
+      boundingBox[1][0] - boundingBox[0][0],
+      boundingBox[1][1] - boundingBox[0][1],
+      boundingBox[1][2] - boundingBox[0][2]
+    ]
+  })
+  return results.length === 1 ? results[0] : results
+}
+
+module.exports = measureDimensions

package/src/measurements/measureDimensions.test.js

@@ -0,0 +1,58 @@
+const test = require('ava')
+
+const { geom2, geom3, path2 } = require('../geometries')
+
+const { line, rectangle, cuboid } = require('../primitives')
+
+const { measureDimensions } = require('./index')
+
+test('measureDimensions (single objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle()
+  const acube = cuboid()
+
+  const apath2 = path2.create()
+  const ageom2 = geom2.create()
+  const ageom3 = geom3.create()
+
+  const n = null
+  const o = {}
+  const x = 'hi'
+
+  const lbounds = measureDimensions(aline)
+  const rbounds = measureDimensions(arect)
+  const cbounds = measureDimensions(acube)
+
+  const p2bounds = measureDimensions(apath2)
+  const g2bounds = measureDimensions(ageom2)
+  const g3bounds = measureDimensions(ageom3)
+
+  const nbounds = measureDimensions(n)
+  const obounds = measureDimensions(o)
+  const xbounds = measureDimensions(x)
+
+  t.deepEqual(lbounds, [5, 5, 0])
+  t.deepEqual(rbounds, [2, 2, 0])
+  t.deepEqual(cbounds, [2, 2, 2])
+
+  t.deepEqual(p2bounds, [0, 0, 0])
+  t.deepEqual(g2bounds, [0, 0, 0])
+  t.deepEqual(g3bounds, [0, 0, 0])
+
+  t.deepEqual(nbounds, [0, 0, 0])
+  t.deepEqual(obounds, [0, 0, 0])
+  t.deepEqual(xbounds, [0, 0, 0])
+})
+
+test('measureDimensions (multiple objects)', (t) => {
+  const aline = line([[10, 10], [15, 15]])
+  const arect = rectangle({ size: [10, 20] })
+  const acube = cuboid()
+  const o = {}
+
+  let allbounds = measureDimensions(aline, arect, acube, o)
+  t.deepEqual(allbounds, [[5, 5, 0], [10, 20, 0], [2, 2, 2], [0, 0, 0]])
+
+  allbounds = measureDimensions(aline, arect, acube, o)
+  t.deepEqual(allbounds, [[5, 5, 0], [10, 20, 0], [2, 2, 2], [0, 0, 0]])
+})

package/src/measurements/measureEpsilon.js

@@ -8,25 +8,19 @@ const measureBoundingBox = require('./measureBoundingBox')
  * Measure the epsilon of the given (path2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfPath2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom3) geometry.
  * @return {Float} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom3 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
-}
+const measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
 
 /**
  * Measure the epsilon of the given geometries.

package/src/operations/booleans/reTesselateCoplanarPolygons.js

@@ -309,7 +309,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
           const polygon = poly3.fromPointsAndPlane(vertices3d, plane) // TODO support shared
 
           // if we let empty polygon out, next retesselate will crash
-          if(polygon.vertices.length) destpolygons.push(polygon)
+          if (polygon.vertices.length) destpolygons.push(polygon)
         }
       }
     } // if(yindex > 0)

package/src/operations/booleans/trees/PolygonTreeNode.js

@@ -20,7 +20,6 @@ const splitPolygonByPlane = require('./splitPolygonByPlane')
 // remove() removes a polygon from the tree. Once a polygon is removed, the parent polygons are invalidated
 // since they are no longer intact.
 class PolygonTreeNode {
-
   // constructor creates the root node
   constructor () {
     this.parent = null

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

@@ -120,7 +120,7 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = expand({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
-  t.is(pts2.length, 2059)
+  t.is(pts2.length, 2065)
 })
 
 test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {

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

@@ -107,10 +107,14 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
-     [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
-     [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]]
+    [
+      [-4.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
+      [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]
+    ],
+    [
+      [7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
+      [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]
+    ]
   ]
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -133,12 +137,16 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[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]],
-    [[-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
-     [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
-     [ 4.898587196589414e-16, 0, -8]],
-    [[0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
-     [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
-     [0, 4.898587196589411e-16, 8]]
+    [
+      [-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
+      [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
+      [4.898587196589414e-16, 0, -8]
+    ],
+    [
+      [0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
+      [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
+      [0, 4.898587196589411e-16, 8]
+    ]
   ]
   t.is(pts.length, 14)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/modifiers/generalize.js

@@ -19,7 +19,6 @@ const generalizePath2 = (options, geometry) => {
   return geometry
 }
 
-
 /*
  */
 const generalizeGeom2 = (options, geometry) => {

package/src/operations/modifiers/snapPolygons.js

@@ -3,7 +3,7 @@ const vec3 = require('../../maths/vec3')
 const poly3 = require('../../geometries/poly3')
 
 const isValidPoly3 = (epsilon, polygon) => {
-  const area = poly3.measureArea(polygon)
+  const area = Math.abs(poly3.measureArea(polygon))
   return (Number.isFinite(area) && area > epsilon)
 }
 
@@ -17,7 +17,7 @@ const snapPolygons = (epsilon, polygons) => {
     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])
+      if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
     }
     const newpolygon = poly3.create(newvertices)
     if (polygon.color) newpolygon.color = polygon.color

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

@@ -34,29 +34,37 @@ test('snapPolygons: snap of polygons produces expected results', (t) => {
       [-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],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]), // OK
     poly3.fromPoints([
       [-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],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
     poly3.fromPoints([
       [-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],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
+    // inverted polygon
+    poly3.fromPoints([
+      [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, 4)
+  t.is(results.length, 5)
 
   const exp3 = poly3.fromPoints([
     [-24.4451, 19.3468, 46.4757],
     [-24.4445, 19.3468, 46.475100000000005],
     [-23.7054, 18.7986, 39.5645]
   ])
-  t.deepEqual(results[3], exp3)
+  t.deepEqual(results[3].vertices, exp3.vertices)
 })

package/src/primitives/index.d.ts

@@ -18,5 +18,6 @@ export { default as sphere, SphereOptions } from './sphere'
 export { default as square, SquareOptions } from './square'
 export { default as star, StarOptions } from './star'
 export { default as torus, TorusOptions } from './torus'
+export { default as triangle, TriangleOptions } from './triangle'
 
 export as namespace primitives

package/src/primitives/index.js

@@ -26,5 +26,6 @@ module.exports = {
   sphere: require('./sphere'),
   square: require('./square'),
   star: require('./star'),
-  torus: require('./torus')
+  torus: require('./torus'),
+  triangle: require('./triangle')
 }

package/src/primitives/triangle.d.ts

@@ -0,0 +1,10 @@
+import Geom2 from '../geometries/geom2/type'
+
+export default triangle
+
+export interface TriangleOptions {
+  type?: 'AAA' | 'AAS' | 'ASA' | 'SAS' | 'SSA' | 'SSS'
+  values?: [number, number, number]
+}
+
+declare function triangle(options?: TriangleOptions): Geom2

package/src/primitives/triangle.js

@@ -0,0 +1,164 @@
+const vec2 = require('../maths/vec2')
+
+const geom2 = require('../geometries/geom2')
+
+const { isNumberArray } = require('./commonChecks')
+
+const NEPS = 1e-13
+
+// returns angle C
+const solveAngleFromSSS = (a, b, c) => Math.acos(((a * a) + (b * b) - (c * c)) / (2 * a * b))
+
+// returns side c
+const solveSideFromSAS = (a, C, b) => {
+  if (C > NEPS) {
+    return Math.sqrt(a * a + b * b - 2 * a * b * Math.cos(C))
+  }
+
+  // Explained in https://www.nayuki.io/page/numerically-stable-law-of-cosines
+  return Math.sqrt((a - b) * (a - b) + a * b * C * C * (1 - C * C / 12))
+}
+
+// AAA is when three angles of a triangle, but no sides
+const solveAAA = (angles) => {
+  const eps = Math.abs(angles[0] + angles[1] + angles[2] - Math.PI)
+  if (eps > NEPS) throw new Error('AAA triangles require angles that sum to PI')
+
+  const A = angles[0]
+  const B = angles[1]
+  const C = Math.PI - A - B
+
+  // Note: This is not 100% proper but...
+  // default the side c length to 1
+  // solve the other lengths
+  const c = 1
+  const a = (c / Math.sin(C)) * Math.sin(A)
+  const b = (c / Math.sin(C)) * Math.sin(B)
+  return createTriangle(A, B, C, a, b, c)
+}
+
+// AAS is when two angles and one side are known, and the side is not between the angles
+const solveAAS = (values) => {
+  const A = values[0]
+  const B = values[1]
+  const C = Math.PI + NEPS - A - B
+
+  if (C < NEPS) throw new Error('AAS triangles require angles that sum to PI')
+
+  const a = values[2]
+  const b = (a / Math.sin(A)) * Math.sin(B)
+  const c = (a / Math.sin(A)) * Math.sin(C)
+  return createTriangle(A, B, C, a, b, c)
+}
+
+// ASA is when two angles and the side between the angles are known
+const solveASA = (values) => {
+  const A = values[0]
+  const B = values[2]
+  const C = Math.PI + NEPS - A - B
+
+  if (C < NEPS) throw new Error('ASA triangles require angles that sum to PI')
+
+  const c = values[1]
+  const a = (c / Math.sin(C)) * Math.sin(A)
+  const b = (c / Math.sin(C)) * Math.sin(B)
+  return createTriangle(A, B, C, a, b, c)
+}
+
+// SAS is when two sides and the angle between them are known
+const solveSAS = (values) => {
+  const c = values[0]
+  const B = values[1]
+  const a = values[2]
+
+  const b = solveSideFromSAS(c, B, a)
+
+  const A = solveAngleFromSSS(b, c, a) // solve for A
+  const C = Math.PI - A - B
+  return createTriangle(A, B, C, a, b, c)
+}
+
+// SSA is when two sides and an angle that is not the angle between the sides are known
+const solveSSA = (values) => {
+  const c = values[0]
+  const a = values[1]
+  const C = values[2]
+
+  const A = Math.asin(a * Math.sin(C) / c)
+  const B = Math.PI - A - C
+
+  const b = (c / Math.sin(C)) * Math.sin(B)
+  return createTriangle(A, B, C, a, b, c)
+}
+
+// SSS is when we know three sides of the triangle
+const solveSSS = (lengths) => {
+  const a = lengths[1]
+  const b = lengths[2]
+  const c = lengths[0]
+  if (((a + b) <= c) || ((b + c) <= a) || ((c + a) <= b)) {
+    throw new Error('SSS triangle is incorrect, as the longest side is longer than the sum of the other sides')
+  }
+
+  const A = solveAngleFromSSS(b, c, a) // solve for A
+  const B = solveAngleFromSSS(c, a, b) // solve for B
+  const C = Math.PI - A - B
+  return createTriangle(A, B, C, a, b, c)
+}
+
+const createTriangle = (A, B, C, a, b, c) => {
+  const p0 = vec2.fromValues(0, 0) // everything starts from 0, 0
+  const p1 = vec2.fromValues(c, 0)
+  const p2 = vec2.fromValues(a, 0)
+  vec2.add(p2, vec2.rotate(p2, p2, [0, 0], Math.PI - B), p1)
+  return geom2.fromPoints([p0, p1, p2])
+}
+
+/**
+ * Construct a triangle in two dimensional space from the given options.
+ * The triangle is always constructed CCW from the origin, [0, 0, 0].
+ * @see https://www.mathsisfun.com/algebra/trig-solving-triangles.html
+ * @param {Object} [options] - options for construction
+ * @param {String} [options.type='SSS' - type of triangle to construct; A ~ angle, S ~ side
+ * @param {Array} [options.values=[1,1,1]] - angle (radians) of corners or length of sides
+ * @returns {geom2} new 2D geometry
+ * @alias module:modeling/primitives.triangle
+ *
+ * @example
+ * let myshape = triangle({type: 'AAS', values: [values: [degToRad(62), degToRad(35), 7]})
+ */
+const triangle = (options) => {
+  const defaults = {
+    type: 'SSS',
+    values: [1, 1, 1]
+  }
+  let { type, values } = Object.assign({}, defaults, options)
+
+  if (typeof (type) !== 'string') throw new Error('triangle type must be a string')
+  type = type.toUpperCase()
+  if (!((type[0] === 'A' || type[0] === 'S') &&
+        (type[1] === 'A' || type[1] === 'S') &&
+        (type[2] === 'A' || type[2] === 'S'))) throw new Error('triangle type must contain three letters; A or S')
+
+  if (!isNumberArray(values, 3)) throw new Error('triangle values must contain three values')
+  if (!values.every((n) => n > 0)) throw new Error('triangle values must be greater than zero')
+
+  switch (type) {
+    case 'AAA':
+      return solveAAA(values)
+    case 'AAS':
+      return solveAAS(values)
+    case 'ASA':
+      return solveASA(values)
+    case 'SAS':
+      return solveSAS(values)
+    case 'SSA':
+      return solveSSA(values)
+    case 'SSS':
+      return solveSSS(values)
+    default:
+      throw new Error('invalid triangle type, try again')
+  }
+}
+
+module.exports = triangle