@jscad/modeling 2.9.4 → 2.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.4",
+  "version": "2.9.5",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "662965f40a1ce628aa97f30b814586e72a3acb36"
+  "gitHead": "225b034db0d94f748992da72b269833954a2e212"
 }

package/src/colors/colorize.d.ts

@@ -5,9 +5,10 @@ import { RGB, RGBA } from './types'
 
 export default colorize
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T
-declare function colorize<T>(color: RGB | RGBA, object: T): T & Colored
+// Single Geom3 returns Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T & Colored
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T>
-declare function colorize<T>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
-declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<any>): Array<any & Colored>
+// List of Geom3 returns list of Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
+// List of mixed geometries returns list of colored geometries
+declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<Geometry>): Array<Geometry & Colored>

package/src/geometries/geom2/type.d.ts

@@ -1,10 +1,11 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom2
 
-declare interface Geom2 extends Colored {
+declare interface Geom2 {
   sides: Array<[Vec2, Vec2]>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/geom3/type.d.ts

@@ -1,10 +1,11 @@
 import Poly3 from '../poly3/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom3
 
-declare interface Geom3 extends Colored {
+declare interface Geom3 {
   polygons: Array<Poly3>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/path2/type.d.ts

@@ -1,11 +1,12 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Path2
 
-declare interface Path2 extends Colored {
+declare interface Path2 {
   points: Array<Vec2>
   isClosed: boolean
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/poly3/measureBoundingSphere.d.ts

@@ -1,6 +1,6 @@
 import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import Vec4 from '../../maths/vec4/type'
 
 export default measureBoundingSphere
 
-declare function measureBoundingSphere(polygon: Poly3): [Vec3, Vec3]
+declare function measureBoundingSphere(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,19 +1,57 @@
 const vec3 = require('../../maths/vec3')
-const measureBoundingBox = require('./measureBoundingBox')
+const vec4 = require('../../maths/vec4')
+
+const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
  * @param {poly3} polygon - the polygon to measure
- * @returns {Array} the computed bounding sphere; center point (3D) and radius
+ * @returns {vec4} the computed bounding sphere; center point (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
 const measureBoundingSphere = (polygon) => {
-  const box = measureBoundingBox(polygon)
-  const center = box[0]
-  vec3.add(center, box[0], box[1])
-  vec3.scale(center, center, 0.5)
-  const radius = vec3.distance(center, box[1])
-  return [center, radius]
+  let boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
+
+  const vertices = polygon.vertices
+  const out = vec4.create()
+
+  if (vertices.length === 0) {
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
+    out[3] = 0
+    return out
+  }
+
+  // keep a list of min/max vertices by axis
+  let minx = vertices[0]
+  let miny = minx
+  let minz = minx
+  let maxx = minx
+  let maxy = minx
+  let maxz = minx
+
+  vertices.forEach((v) => {
+    if (minx[0] > v[0]) minx = v
+    if (miny[1] > v[1]) miny = v
+    if (minz[2] > v[2]) minz = v
+    if (maxx[0] < v[0]) maxx = v
+    if (maxy[1] < v[1]) maxy = v
+    if (maxz[2] < v[2]) maxz = v
+  })
+
+  out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
+  out[1] = (miny[1] + maxy[1]) * 0.5
+  out[2] = (minz[2] + maxz[2]) * 0.5
+  const x = out[0] - maxx[0]
+  const y = out[1] - maxy[1]
+  const z = out[2] - maxz[2]
+  out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
+
+  cache.set(polygon, out)
+
+  return out
 }
 
 module.exports = measureBoundingSphere

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -3,28 +3,23 @@ const { measureBoundingSphere, create, fromPoints, transform } = require('./inde
 
 const mat4 = require('../../maths/mat4')
 
-const { compareVectors, nearlyEqual } = require('../../../test/helpers/index')
-
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
-  let exp1 = [[0, 0, 0], 0]
+  let exp1 = [0, 0, 0, 0]
   let ret1 = measureBoundingSphere(ply1)
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
+  t.deepEqual(ret1, exp1)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
-  let exp2 = [[0, 5, 5], 7.0710678118654755]
+  let exp2 = [0, 5, 5, 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
+  t.deepEqual(ret2, exp2)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
-  let exp3 = [[0, 5, 5], 7.0710678118654755]
+  let exp3 = [0, 5, 5, 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
+  t.deepEqual(ret3, exp3)
 
   // V-shape
   const points = [
@@ -40,10 +35,9 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
     [0, 3, 3]
   ]
   let ply4 = fromPoints(points)
-  let exp4 = [[0, 4.5, 3], 4.6097722286464435]
+  let exp4 = [0, 4.5, 3, 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  t.deepEqual(ret4, exp4)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -55,16 +49,12 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret2 = measureBoundingSphere(ply2)
   ret3 = measureBoundingSphere(ply3)
   ret4 = measureBoundingSphere(ply4)
-  exp1 = [[0, 0, 0], 0]
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
-  exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
-  exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
-  exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  exp1 = [0, 0, 0, 0]
+  t.deepEqual(ret1, exp1)
+  exp2 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret2, exp2)
+  exp3 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret3, exp3)
+  exp4 = [-3.181980515339464, 3.1819805153394642, 3, 4.6097722286464435]
+  t.deepEqual(ret4, exp4)
 })

package/src/geometries/poly3/type.d.ts

@@ -1,8 +1,9 @@
 import Vec3 from '../../maths/vec3/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Poly3
 
-declare interface Poly3 extends Colored {
+declare interface Poly3 {
   vertices: Array<Vec3>
+  color?: Color
 }

package/src/geometries/types.d.ts

@@ -8,8 +8,10 @@ import { RGB, RGBA } from '../colors'
 // see https://github.com/jscad/OpenJSCAD.org/pull/726#issuecomment-724575265
 export type Geometry = Geom2 | Geom3 | Poly3 | Path2
 
-export type Colored = {
-  color?: RGB | RGBA
+export type Color = RGB | RGBA
+
+export interface Colored {
+  color: Color
 }
 
 export { default as Geom2 } from './geom2/type'

package/src/maths/mat4/fromRotation.js

@@ -1,6 +1,8 @@
-const identity = require('./identity')
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
 
-const { EPSILON } = require('./constants')
+const identity = require('./identity')
 
 /**
  * Creates a matrix from a given angle around a given axis
@@ -19,20 +21,20 @@ const { EPSILON } = require('./constants')
  */
 const fromRotation = (out, rad, axis) => {
   let [x, y, z] = axis
-  let len = Math.hypot(x, y, z)
+  const lengthSquared = x * x + y * y + z * z
 
-  if (Math.abs(len) < EPSILON) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return identity(out)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(rad)
-  const c = Math.cos(rad)
+  const s = sin(rad)
+  const c = cos(rad)
   const t = 1 - c
 
   // Perform rotation-specific matrix multiplication

package/src/maths/mat4/fromTaitBryanRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given Tait–Bryan angles.
  *
@@ -15,12 +17,12 @@
  */
 const fromTaitBryanRotation = (out, yaw, pitch, roll) => {
   // precompute sines and cosines of Euler angles
-  const sy = Math.sin(yaw)
-  const cy = Math.cos(yaw)
-  const sp = Math.sin(pitch)
-  const cp = Math.cos(pitch)
-  const sr = Math.sin(roll)
-  const cr = Math.cos(roll)
+  const sy = sin(yaw)
+  const cy = cos(yaw)
+  const sp = sin(pitch)
+  const cp = cos(pitch)
+  const sr = sin(roll)
+  const cr = cos(roll)
 
   // create and populate rotation matrix
   // left-hand-rule rotation

package/src/maths/mat4/fromXRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the X axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromXRotation(create(), Math.PI / 2)
  */
 const fromXRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = 1

package/src/maths/mat4/fromYRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Y axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromYRotation(create(), Math.PI / 2)
  */
 const fromYRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = c

package/src/maths/mat4/fromZRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Z axis.
  * This is equivalent to (but much faster than):
@@ -13,8 +15,8 @@
  * let matrix = fromZRotation(create(), Math.PI / 2)
  */
 const fromZRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = c

package/src/maths/mat4/rotate.js

@@ -1,3 +1,7 @@
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
+
 const copy = require('./copy')
 
 /**
@@ -12,20 +16,20 @@ const copy = require('./copy')
  */
 const rotate = (out, matrix, radians, axis) => {
   let [x, y, z] = axis
-  let len = Math.hypot(x, y, z)
+  const lengthSquared = x * x + y * y + z * z
 
-  if (Math.abs(len) < 0.000001) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return copy(out, matrix)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const t = 1 - c
 
   const a00 = matrix[0]

package/src/maths/mat4/rotateX.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the X axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateX
  */
 const rotateX = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a10 = matrix[4]
   const a11 = matrix[5]
   const a12 = matrix[6]

package/src/maths/mat4/rotateY.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Y axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateY
  */
 const rotateY = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

package/src/maths/mat4/rotateZ.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Z axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateZ
  */
 const rotateZ = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

package/src/maths/mat4/translate.test.js

@@ -52,10 +52,9 @@ test('mat4: translate() called with three parameters should update a mat4 with c
   t.true(compareVectors(obs4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
   t.true(compareVectors(ret4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
 
-  const r = (90 * 0.017453292519943295)
   const rotateZMatrix = [
-    Math.cos(r), -Math.sin(r), 0, 0,
-    Math.sin(r), Math.cos(r), 0, 0,
+    0, -1, 0, 0,
+    1, 0, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1
   ]

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

@@ -3,5 +3,6 @@ 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

@@ -7,7 +7,9 @@
 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/{utils → maths/utils}/trigonometry.js

@@ -1,4 +1,4 @@
-const { NEPS } = require('../maths/constants')
+const { NEPS } = require('../constants')
 
 /*
  * Returns zero if n is within epsilon of zero, otherwise return n

package/src/maths/vec2/distance.js

@@ -9,7 +9,7 @@
 const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
-  return Math.hypot(x, y)
+  return Math.sqrt(x * x + y * y)
 }
 
 module.exports = distance

package/src/maths/vec2/fromAngleRadians.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Create a new vector in the direction of the given angle.
  *
@@ -7,8 +9,8 @@
  * @alias module:modeling/maths/vec2.fromAngleRadians
  */
 const fromAngleRadians = (out, radians) => {
-  out[0] = Math.cos(radians)
-  out[1] = Math.sin(radians)
+  out[0] = cos(radians)
+  out[1] = sin(radians)
   return out
 }
 

package/src/maths/vec2/length.js

@@ -5,6 +5,6 @@
  * @returns {Number} length
  * @alias module:modeling/maths/vec2.length
  */
-const length = (vector) => Math.hypot(vector[0], vector[1])
+const length = (vector) => Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1])
 
 module.exports = length

package/src/maths/vec2/length.test.js

@@ -25,15 +25,5 @@ test('vec2: length() should return correct values', (t) => {
   const length5 = length(vec5)
   nearlyEqual(t, length5, 2.23606, EPS)
 
-  // huge vector
-  const vec6 = fromValues(1e200, 1e200)
-  const length6 = length(vec6)
-  nearlyEqual(t, length6, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec7 = fromValues(1e-200, 1e-200)
-  const length7 = length(vec7)
-  nearlyEqual(t, length7, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/angle.js

@@ -15,8 +15,8 @@ const angle = (a, b) => {
   const bx = b[0]
   const by = b[1]
   const bz = b[2]
-  const mag1 = Math.hypot(ax, ay, az)
-  const mag2 = Math.hypot(bx, by, bz)
+  const mag1 = Math.sqrt(ax * ax + ay * ay + az * az)
+  const mag2 = Math.sqrt(bx * bx + by * by + bz * bz)
   const mag = mag1 * mag2
   const cosine = mag && dot(a, b) / mag
   return Math.acos(Math.min(Math.max(cosine, -1), 1))

package/src/maths/vec3/angle.test.js

@@ -30,17 +30,5 @@ test('vec3: angle() should return correct values', (t) => {
   const angle5 = angle(vec5a, vec5b)
   nearlyEqual(t, angle5, 0.785398, EPS)
 
-  // tiny values
-  const vec6a = fromValues(1, 0, 0)
-  const vec6b = fromValues(1e-200, 1e-200, 0)
-  const angle6 = angle(vec6a, vec6b)
-  nearlyEqual(t, angle6, 0.785398, EPS)
-
-  // huge values
-  const vec7a = fromValues(1, 0, 0)
-  const vec7b = fromValues(1e200, 1e200, 0)
-  const angle7 = angle(vec7a, vec7b)
-  nearlyEqual(t, angle7, 0.785398, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/distance.js

@@ -10,7 +10,7 @@ const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
   const z = b[2] - a[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = distance

package/src/maths/vec3/length.js

@@ -9,7 +9,7 @@ const length = (vector) => {
   const x = vector[0]
   const y = vector[1]
   const z = vector[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = length

package/src/maths/vec3/length.test.js

@@ -41,15 +41,5 @@ test('vec3: length() should return correct values', (t) => {
   const length9 = length(vec9)
   nearlyEqual(t, length9, 3.74165, EPS)
 
-  // huge vector
-  const vec10 = fromValues(1e200, 0, 1e200)
-  const length10 = length(vec10)
-  nearlyEqual(t, length10, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec11 = fromValues(1e-200, 0, 1e-200)
-  const length11 = length(vec11)
-  nearlyEqual(t, length11, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

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

@@ -132,8 +132,8 @@ class PolygonTreeNode {
     const polygon = this.polygon
     if (polygon) {
       const bound = poly3.measureBoundingSphere(polygon)
-      const sphereradius = bound[1] + EPS // ensure radius is LARGER then polygon
-      const spherecenter = bound[0]
+      const sphereradius = bound[3] + EPS // ensure radius is LARGER then polygon
+      const spherecenter = bound
       const d = vec3.dot(splane, spherecenter) - splane[3]
       if (d > sphereradius) {
         frontnodes.push(this)