@jscad/modeling 2.5.3 → 2.7.1

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

@@ -10,6 +10,8 @@ const expandPath2 = require('./expandPath2')
 
 /**
  * Expand the given geometry using the given options.
+ * Both interal 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

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/expansions/offset.js

@@ -8,6 +8,7 @@ const offsetPath2 = require('./offsetPath2')
 
 /**
  * Create offset geometry from the given geometry using the given options.
+ * Offsets from internal and external space are created.
  * @param {Object} options - options for offset
  * @param {Float} [options.delta=1] - delta of offset (+ to exterior, - from interior)
  * @param {String} [options.corners='edge'] - type of corner to create after offseting; edge, chamfer, round

package/src/operations/extrusions/extrudeRectangular.js

@@ -17,7 +17,8 @@ const extrudeRectangularGeom2 = require('./extrudeRectangularGeom2')
  * @alias module:modeling/extrusions.extrudeRectangular
  *
  * @example
- * let mywalls = extrudeRectangular({offset: [0,0,10]}, square())
+ * let mywalls = extrudeRectangular({size: 1, height: 3}, square({size: 20}))
+ * let mywalls = extrudeRectangular({size: 1, height: 300, twistAngle: Math.PI}, square({size: 20}))
  */
 const extrudeRectangular = (options, ...objects) => {
   const defaults = {

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/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/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: [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) => {