@jscad/modeling 2.6.0 → 2.7.2

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/operations/transforms/mirror.js

@@ -64,7 +64,7 @@ const mirrorY = (...objects) => mirror({ normal: [0, 1, 0] }, objects)
 
 /**
  * Mirror the given object(s) about the Z axis.
- * @param {...Object} objects - the geometries to mirror
+ * @param {...Object} geometries - the geometries to mirror
  * @return {Object|Array} the mirrored geometry, or a list of mirrored geometry
  * @alias module:modeling/transforms.mirrorZ
  */

package/src/primitives/ellipse.js

@@ -7,7 +7,7 @@ const geom2 = require('../geometries/geom2')
 const { isGTE, isNumberArray } = require('./commonChecks')
 
 /**
- * Construct an axis-aligned ellispe in two dimensional space.
+ * Construct an axis-aligned ellipse in two dimensional space.
  * @see https://en.wikipedia.org/wiki/Ellipse
  * @param {Object} [options] - options for construction
  * @param {Array} [options.center=[0,0]] - center of ellipse

package/src/primitives/geodesicSphere.js

@@ -79,7 +79,7 @@ const geodesicSphere = (options) => {
 
         // -- normalize
         for (let k = 0; k < 3; k++) {
-          const r = Math.sqrt(q[k][0] * q[k][0] + q[k][1] * q[k][1] + q[k][2] * q[k][2])
+          const r = Math.hypot(q[k][0], q[k][1], q[k][2])
           for (let l = 0; l < 3; l++) {
             q[k][l] /= r
           }
@@ -95,7 +95,7 @@ const geodesicSphere = (options) => {
 
           // -- normalize
           for (let k = 0; k < 3; k++) {
-            const r = Math.sqrt(q[k][0] * q[k][0] + q[k][1] * q[k][1] + q[k][2] * q[k][2])
+            const r = Math.hypot(q[k][0], q[k][1], q[k][2])
             for (let l = 0; l < 3; l++) {
               q[k][l] /= r
             }

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

@@ -11,7 +11,7 @@ const { isGT, isGTE, isNumberArray } = require('./commonChecks')
  * Construct a Z axis-aligned solid cylinder in three dimensional space with rounded ends.
  * @param {Object} [options] - options for construction
  * @param {Array} [options.center=[0,0,0]] - center of cylinder
- * @param {Array} [options.height=2] - height of cylinder
+ * @param {Number} [options.height=2] - height of cylinder
  * @param {Number} [options.radius=1] - radius of cylinder
  * @param {Number} [options.roundRadius=0.2] - radius of rounded edges
  * @param {Number} [options.segments=32] - number of segments to create per full rotation

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: [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

package/src/primitives/triangle.test.js

@@ -0,0 +1,95 @@
+const test = require('ava')
+
+const { triangle } = require('./index')
+
+const degToRad = require('../utils/degToRad')
+const geom2 = require('../geometries/geom2')
+
+const comparePoints = require('../../test/helpers/comparePoints')
+
+test('triangle (defaults)', (t) => {
+  const geometry = triangle()
+  const obs = geom2.toPoints(geometry)
+  const exp = [
+    [0, 0],
+    [1, 0],
+    [0.5000000000000002, 0.8660254037844387]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+})
+
+test('triangle (options)', (t) => {
+  // test SSS
+  let geometry = triangle({ type: 'SSS', values: [7, 8, 6] })
+  let obs = geom2.toPoints(geometry)
+  let exp = [
+    [0, 0],
+    [7, 0],
+    [1.5, 5.809475019311125]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+
+  // test AAA
+  geometry = triangle({ type: 'AAA', values: [Math.PI / 2, Math.PI / 4, Math.PI / 4] })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 0],
+    [1, 0],
+    [0, 1.0000000000000002]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+
+  // test AAS
+  geometry = triangle({ type: 'AAS', values: [degToRad(62), degToRad(35), 7] })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 0],
+    [7.86889631692936, 0],
+    [2.1348320069064197, 4.015035054457325]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+
+  // test ASA
+  geometry = triangle({ type: 'ASA', values: [degToRad(76), 9, degToRad(34)] })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 0],
+    [9, 0],
+    [1.295667368233083, 5.196637976713814]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+
+  // test SAS
+  geometry = triangle({ type: 'SAS', values: [5, degToRad(49), 7] })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 0],
+    [5, 0],
+    [0.4075867970664495, 5.282967061559405]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+
+  // test SSA
+  geometry = triangle({ type: 'SSA', values: [8, 13, degToRad(31)] })
+  obs = geom2.toPoints(geometry)
+  exp = [
+    [0, 0],
+    [8, 0],
+    [8.494946725906148, 12.990574573070846]
+  ]
+
+  t.deepEqual(obs.length, 3)
+  t.true(comparePoints(obs, exp))
+})

package/src/utils/insertSorted.js

@@ -1,4 +1,5 @@
 /**
+ * Insert the given element into the give array using the compareFunction.
  * @alias module:modeling/utils.insertSorted
  */
 const insertSorted = (array, element, comparefunc) => {

package/test/helpers/comparePolygons.js

@@ -8,9 +8,7 @@ const compareVectors = require('./compareVectors')
  */
 const comparePolygons = (poly1, poly2) => {
   if (poly1.vertices.length === poly2.vertices.length) {
-    return poly1.vertices.reduce((valid, vertex, index) => {
-      return valid && compareVectors(poly1.vertices[index], poly2.vertices[index])
-    }, true)
+    return poly1.vertices.reduce((valid, vertex, index) => valid && compareVectors(poly1.vertices[index], poly2.vertices[index]), true)
   }
   return false
 }

package/test/helpers/nearlyEqual.js

@@ -1,7 +1,6 @@
 // Compare two numeric values for near equality.
 // the given test is fails if the numeric values are outside the given epsilon
 const nearlyEqual = (t, a, b, epsilon, failMessage) => {
-// console.log('nearEqual(t,'+a+','+b+','+epsilon+')')
   if (a === b) { // shortcut, also handles infinities and NaNs
     return true
   }
@@ -10,11 +9,9 @@ const nearlyEqual = (t, a, b, epsilon, failMessage) => {
   const absB = Math.abs(b)
   const diff = Math.abs(a - b)
   if (Number.isNaN(diff)) {
-    return false
+    failMessage = failMessage === undefined ? 'difference is not a number' : failMessage
+    t.fail(failMessage + '(' + a + ',' + b + ')')
   }
-  // console.log(absA)
-  // console.log(absB)
-  // console.log(diff)
   if (a === 0 || b === 0 || diff < Number.EPSILON) {
   // a or b is zero or both are extremely close to it
   // relative error is less meaningful here
@@ -25,7 +22,6 @@ const nearlyEqual = (t, a, b, epsilon, failMessage) => {
   }
   // use relative error
   const relative = (diff / Math.min((absA + absB), Number.MAX_VALUE))
-  // console.log(relative)
   if (relative > epsilon) {
     failMessage = failMessage === undefined ? 'Numbers outside of epsilon' : failMessage
     t.fail(failMessage + '(' + a + ',' + b + ')')