@jscad/modeling 2.9.2 → 2.9.5

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

@@ -7,49 +7,49 @@ const snapPolygons = require('./snapPolygons')
 test('snapPolygons: snap of polygons produces expected results', (t) => {
   const polygons = [
     // valid polygons
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]]), // OK
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]]), // OK
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10]]), // OK
+    poly3.create([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]]), // OK
     // invalid polygons
     poly3.create(),
-    poly3.fromPoints([[0, 0, 0]]),
-    poly3.fromPoints([[0, 0, 0], [0, 10, 0]]),
+    poly3.create([[0, 0, 0]]),
+    poly3.create([[0, 0, 0], [0, 10, 0]]),
     // duplicated vertices
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-24.44446933333345, 19.346837333333426, 46.47508266666689],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]), // OK
-    poly3.fromPoints([
+    poly3.create([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]),
-    poly3.fromPoints([
+    poly3.create([
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019]
     ]),
     // duplicate vertices after snap
-    poly3.fromPoints([
+    poly3.create([
       [-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]
     ]), // OK
-    poly3.fromPoints([
+    poly3.create([
       [-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]
     ]),
-    poly3.fromPoints([
+    poly3.create([
       [-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]
     ]),
     // inverted polygon
-    poly3.fromPoints([
+    poly3.create([
       [20.109133333333336, -4.894033333333335, -1.0001266666666668],
       [20.021120000000003, -5.1802133333333344, -1.0001266666666668],
       [20.020300000000002, -5.182946666666668, -1.0001266666666668],
@@ -61,7 +61,7 @@ test('snapPolygons: snap of polygons produces expected results', (t) => {
   const results = snapPolygons(0.0001, polygons)
   t.is(results.length, 5)
 
-  const exp3 = poly3.fromPoints([
+  const exp3 = poly3.create([
     [-24.4451, 19.3468, 46.4757],
     [-24.4445, 19.3468, 46.475100000000005],
     [-23.7054, 18.7986, 39.5645]

package/src/operations/modifiers/triangulatePolygons.js

@@ -10,15 +10,15 @@ const triangulatePolygon = (epsilon, polygon, triangles) => {
       polygon.vertices.forEach((vertice) => vec3.add(midpoint, midpoint, vertice))
       vec3.snap(midpoint, vec3.divide(midpoint, midpoint, [nv, nv, nv]), epsilon)
       for (let i = 0; i < nv; i++) {
-        const poly = poly3.fromPoints([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
+        const poly = poly3.create([midpoint, polygon.vertices[i], polygon.vertices[(i + 1) % nv]])
         if (polygon.color) poly.color = polygon.color
         triangles.push(poly)
       }
       return
     }
     // exactly 4 vertices, use simple triangulation
-    const poly0 = poly3.fromPoints([polygon.vertices[0], polygon.vertices[1], polygon.vertices[2]])
-    const poly1 = poly3.fromPoints([polygon.vertices[0], polygon.vertices[2], polygon.vertices[3]])
+    const poly0 = poly3.create([polygon.vertices[0], polygon.vertices[1], polygon.vertices[2]])
+    const poly1 = poly3.create([polygon.vertices[0], polygon.vertices[2], polygon.vertices[3]])
     if (polygon.color) {
       poly0.color = polygon.color
       poly1.color = polygon.color

package/src/operations/transforms/center.js

@@ -39,7 +39,7 @@ const center = (options, ...objects) => {
   const defaults = {
     axes: [true, true, true],
     relativeTo: [0, 0, 0]
-  // TODO : Add addition 'methods' of centering; midpoint, centeriod
+  // TODO: Add additional 'methods' of centering: midpoint, centroid
   }
   const { axes, relativeTo } = Object.assign({}, defaults, options)
 

package/src/primitives/circle.test.js

@@ -123,6 +123,13 @@ test('circle (options)', (t) => {
   t.deepEqual(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
+  // test full rotation with non-zero startAngle
+  geometry = circle({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  pts = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(pts.length, 32)
+
   // test segments
   geometry = circle({ radius: 3.5, segments: 5 })
   pts = geom2.toPoints(geometry)

package/src/primitives/cuboid.js

@@ -43,7 +43,7 @@ const cuboid = (options) => {
         ]
         return pos
       })
-      return poly3.fromPoints(points)
+      return poly3.create(points)
     })
   )
   return result

package/src/primitives/cylinderElliptic.js

@@ -5,7 +5,7 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
-const { sin, cos } = require('../utils/trigonometry')
+const { sin, cos } = require('../maths/utils/trigonometry')
 
 const { isGT, isGTE, isNumberArray } = require('./commonChecks')
 
@@ -90,13 +90,15 @@ const cylinderElliptic = (options) => {
   // adjust the points to center
   const fromPoints = (...points) => {
     const newpoints = points.map((point) => vec3.add(vec3.create(), point, center))
-    return poly3.fromPoints(newpoints)
+    return poly3.create(newpoints)
   }
 
   const polygons = []
   for (let i = 0; i < slices; i++) {
     const t0 = i / slices
-    const t1 = (i + 1) / slices
+    let t1 = (i + 1) / slices
+    // fix rounding error when rotating 2 * PI radians
+    if (rotation === 2 * Math.PI && i === slices - 1) t1 = 0
 
     if (endRadius[0] === startRadius[0] && endRadius[1] === startRadius[1]) {
       polygons.push(fromPoints(start, point(0, t1, endRadius), point(0, t0, endRadius)))

package/src/primitives/cylinderElliptic.test.js

@@ -137,7 +137,13 @@ test('cylinderElliptic (options)', (t) => {
 
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 28)
-  // t.true(comparePolygonsAsPoints(pts, exp))
+
+  // test startAngle and endAngle
+  obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  pts = geom3.toPoints(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 96)
 
   // test segments
   obs = cylinderElliptic({ segments: 8 })

package/src/primitives/ellipse.js

@@ -4,7 +4,7 @@ const vec2 = require('../maths/vec2')
 
 const geom2 = require('../geometries/geom2')
 
-const { sin, cos } = require('../utils/trigonometry')
+const { sin, cos } = require('../maths/utils/trigonometry')
 
 const { isGTE, isNumberArray } = require('./commonChecks')
 

package/src/primitives/ellipse.test.js

@@ -123,6 +123,13 @@ test('ellipse (options)', (t) => {
   t.deepEqual(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
+  // test full rotation with non-zero startAngle
+  geometry = ellipse({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  obs = geom2.toPoints(geometry)
+
+  t.notThrows(() => geom2.validate(geometry))
+  t.deepEqual(obs.length, 32)
+
   // test segments
   geometry = ellipse({ segments: 72 })
   obs = geom2.toPoints(geometry)

package/src/primitives/ellipsoid.js

@@ -3,7 +3,7 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
-const { sin, cos } = require('../utils/trigonometry')
+const { sin, cos } = require('../maths/utils/trigonometry')
 
 const { isGTE, isNumberArray } = require('./commonChecks')
 
@@ -66,7 +66,7 @@ const ellipsoid = (options) => {
           point = vec3.subtract(vec3.create(), vec3.scale(p1, prevcylinderpoint, cospitch), vec3.scale(p2, zvector, sinpitch))
           points.push(vec3.add(point, point, center))
 
-          polygons.push(poly3.fromPoints(points))
+          polygons.push(poly3.create(points))
 
           points = []
           point = vec3.add(vec3.create(), vec3.scale(p1, prevcylinderpoint, prevcospitch), vec3.scale(p2, zvector, prevsinpitch))
@@ -81,7 +81,7 @@ const ellipsoid = (options) => {
           points.push(vec3.add(vec3.create(), center, point))
           points.reverse()
 
-          polygons.push(poly3.fromPoints(points))
+          polygons.push(poly3.create(points))
         }
         prevcospitch = cospitch
         prevsinpitch = sinpitch

package/src/primitives/geodesicSphere.js

@@ -1,4 +1,5 @@
 const mat4 = require('../maths/mat4')
+const vec3 = require('../maths/vec3')
 
 const geom3 = require('../geometries/geom3')
 
@@ -79,7 +80,7 @@ const geodesicSphere = (options) => {
 
         // -- normalize
         for (let k = 0; k < 3; k++) {
-          const r = Math.hypot(q[k][0], q[k][1], q[k][2])
+          const r = vec3.length(q[k])
           for (let l = 0; l < 3; l++) {
             q[k][l] /= r
           }
@@ -95,7 +96,7 @@ const geodesicSphere = (options) => {
 
           // -- normalize
           for (let k = 0; k < 3; k++) {
-            const r = Math.hypot(q[k][0], q[k][1], q[k][2])
+            const r = vec3.length(q[k])
             for (let l = 0; l < 3; l++) {
               q[k][l] /= r
             }

package/src/primitives/polyhedron.js

@@ -60,7 +60,7 @@ const polyhedron = (options) => {
   }
 
   const polygons = faces.map((face, findex) => {
-    const polygon = poly3.fromPoints(face.map((pindex) => points[pindex]))
+    const polygon = poly3.create(face.map((pindex) => points[pindex]))
     if (colors && colors[findex]) polygon.color = colors[findex]
     return polygon
   })

package/src/primitives/roundedCuboid.js

@@ -6,12 +6,14 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
+const { sin, cos } = require('../maths/utils/trigonometry')
+
 const { isGT, isGTE, isNumberArray } = require('./commonChecks')
 
 const createCorners = (center, size, radius, segments, slice, positive) => {
   const pitch = (Math.PI / 2) * slice / segments
-  const cospitch = Math.cos(pitch)
-  const sinpitch = Math.sin(pitch)
+  const cospitch = cos(pitch)
+  const sinpitch = sin(pitch)
 
   const layersegments = segments - slice
   let layerradius = radius * cospitch
@@ -57,10 +59,10 @@ const stitchCorners = (previousCorners, currentCorners) => {
     const previous = previousCorners[i]
     const current = currentCorners[i]
     for (let j = 0; j < (previous.length - 1); j++) {
-      polygons.push(poly3.fromPoints([previous[j], previous[j + 1], current[j]]))
+      polygons.push(poly3.create([previous[j], previous[j + 1], current[j]]))
 
       if (j < (current.length - 1)) {
-        polygons.push(poly3.fromPoints([current[j], previous[j + 1], current[j + 1]]))
+        polygons.push(poly3.create([current[j], previous[j + 1], current[j + 1]]))
       }
     }
   }
@@ -81,7 +83,7 @@ const stitchWalls = (previousCorners, currentCorners) => {
     const p1 = previous[0]
     const c1 = current[0]
 
-    polygons.push(poly3.fromPoints([p0, p1, c1, c0]))
+    polygons.push(poly3.create([p0, p1, c1, c0]))
   }
   return polygons
 }
@@ -104,7 +106,7 @@ const stitchSides = (bottomCorners, topCorners) => {
   const polygons = []
   for (let i = 0; i < topPoints.length; i++) {
     const j = (i + 1) % topPoints.length
-    polygons.push(poly3.fromPoints([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
+    polygons.push(poly3.create([bottomPoints[i], bottomPoints[j], topPoints[j], topPoints[i]]))
   }
   return polygons
 }
@@ -168,10 +170,10 @@ const roundedCuboid = (options) => {
     if (slice === segments) {
       // add the top
       let points = cornersPos.map((corner) => corner[0])
-      polygons.push(poly3.fromPoints(points))
+      polygons.push(poly3.create(points))
       // add the bottom
       points = cornersNeg.map((corner) => corner[0])
-      polygons.push(poly3.fromPoints(points))
+      polygons.push(poly3.create(points))
     }
 
     prevCornersPos = cornersPos

package/src/primitives/roundedCylinder.js

@@ -5,7 +5,7 @@ const vec3 = require('../maths/vec3')
 const geom3 = require('../geometries/geom3')
 const poly3 = require('../geometries/poly3')
 
-const { sin, cos } = require('../utils/trigonometry')
+const { sin, cos } = require('../maths/utils/trigonometry')
 
 const { isGT, isGTE, isNumberArray } = require('./commonChecks')
 
@@ -66,7 +66,7 @@ const roundedCylinder = (options) => {
   const fromPoints = (points) => {
     // adjust the points to center
     const newpoints = points.map((point) => vec3.add(point, point, center))
-    return poly3.fromPoints(newpoints)
+    return poly3.create(newpoints)
   }
 
   const polygons = []

package/src/primitives/torus.test.js

@@ -10,24 +10,22 @@ test('torus (defaults)', (t) => {
   const obs = torus()
   const pts = geom3.toPoints(obs)
 
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 2048) // 32 * 32 * 2 (polys/segment) = 2048
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
-  t.notThrows.skip(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
-test('torus (Simple options)', (t) => {
+test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
   const pts = geom3.toPoints(obs)
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 64) // 4 * 8 * 2 (polys/segment) = 64
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5.5, -5.5, -0.5], [5.5, 5.5, 0.5]]
-  t.notThrows.skip(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
@@ -39,15 +37,21 @@ test('torus (complex options)', (t) => {
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-6, 0, -1], [0, 6, 1]]
-  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
+test('torus (startAngle)', (t) => {
+  const obs = torus({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(pts.length, 2048)
+})
+
 test('torus (square by square)', (t) => {
   const obs = torus({ innerSegments: 4, outerSegments: 4, innerRotation: Math.PI / 2 })
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
-  t.notThrows.skip(() => geom3.validate(obs))
+  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })

package/src/primitives/triangle.js

@@ -1,11 +1,10 @@
+const { NEPS } = require('../maths/constants')
 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))
 

package/src/utils/index.d.ts

@@ -5,6 +5,5 @@ export { default as fnNumberSort } from './fnNumberSort'
 export { default as insertSorted } from './insertSorted'
 export { default as radiusToSegments } from './radiusToSegments'
 export { default as radToDeg } from './radToDeg'
-export * from './trigonometry'
 
 export as namespace utils

package/src/utils/index.js

@@ -6,12 +6,10 @@
  */
 module.exports = {
   areAllShapesTheSameType: require('./areAllShapesTheSameType'),
-  cos: require('./trigonometry').cos,
   degToRad: require('./degToRad'),
   flatten: require('./flatten'),
   fnNumberSort: require('./fnNumberSort'),
   insertSorted: require('./insertSorted'),
   radiusToSegments: require('./radiusToSegments'),
-  radToDeg: require('./radToDeg'),
-  sin: require('./trigonometry').sin
+  radToDeg: require('./radToDeg')
 }

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

@@ -1,9 +0,0 @@
-import Path2 from './type'
-import Vec2 from '../../maths/vec2/type'
-
-export default eachPoint
-
-export interface EachPointOptions {}
-export type EachPointThunk = (value: Vec2, index: number, array: Array<Vec2>) => void
-
-declare function eachPoint(options: EachPointOptions, thunk: EachPointThunk, path: Path2): void

package/src/geometries/path2/eachPoint.js

@@ -1,17 +0,0 @@
-const toPoints = require('./toPoints')
-
-/**
- * Calls a function for each point in the path.
- * @param {Object} options - options
- * @param {Function} thunk - the function to call
- * @param {path2} path - the path to traverse
- * @alias module:modeling/geometries/path2.eachPoint
- *
- * @example
- * eachPoint({}, accumulate, path)
- */
-const eachPoint = (options, thunk, path) => {
-  toPoints(path).forEach(thunk)
-}
-
-module.exports = eachPoint

package/src/geometries/path2/eachPoint.test.js

@@ -1,11 +0,0 @@
-const test = require('ava')
-
-const vec2 = require('../../maths/vec2')
-
-const { eachPoint, fromPoints } = require('./index')
-
-test('eachPoint: Each point is emitted', (t) => {
-  const collector = []
-  eachPoint({}, (point) => collector.push(point), fromPoints({}, [[1, 1], [2, 2]]))
-  t.deepEqual(collector, [vec2.fromValues(1, 1), vec2.fromValues(2, 2)])
-})

package/src/maths/mat4/constants.d.ts

@@ -1 +0,0 @@
-export const EPSILON: number

package/src/maths/mat4/constants.js

@@ -1,5 +0,0 @@
-const EPSILON = 0.000001
-
-module.exports = {
-  EPSILON
-}

package/src/operations/extrusions/slice/repairSlice.js

@@ -1,47 +0,0 @@
-const vec3 = require('../../../maths/vec3')
-
-/*
- * Mend gaps in a 2D slice to make it a closed polygon
- */
-const repairSlice = (slice) => {
-  if (!slice.edges) return slice
-  const vertexMap = {} // string key to vertex map
-  const edgeCount = {} // count of (in - out) edges
-  slice.edges.forEach((edge) => {
-    const inKey = edge[0].toString()
-    const outKey = edge[1].toString()
-    vertexMap[inKey] = edge[0]
-    vertexMap[outKey] = edge[1]
-    edgeCount[inKey] = (edgeCount[inKey] || 0) + 1 // in
-    edgeCount[outKey] = (edgeCount[outKey] || 0) - 1 // out
-  })
-  // find vertices which are missing in or out edges
-  const missingIn = Object.keys(edgeCount).filter((e) => edgeCount[e] < 0)
-  const missingOut = Object.keys(edgeCount).filter((e) => edgeCount[e] > 0)
-  // pairwise distance of bad vertices
-  missingIn.forEach((key1) => {
-    const v1 = vertexMap[key1]
-    // find the closest vertex that is missing an out edge
-    let bestDistance = Infinity
-    let bestReplacement
-    missingOut.forEach((key2) => {
-      const v2 = vertexMap[key2]
-      const distance = Math.hypot(v1[0] - v2[0], v1[1] - v2[1])
-      if (distance < bestDistance) {
-        bestDistance = distance
-        bestReplacement = v2
-      }
-    })
-    console.warn(`repairSlice: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
-    // merge broken vertices
-    slice.edges.forEach((edge) => {
-      if (edge[0].toString() === key1) edge[0] = bestReplacement
-      if (edge[1].toString() === key1) edge[1] = bestReplacement
-    })
-  })
-  // Remove self-edges
-  slice.edges = slice.edges.filter((e) => !vec3.equals(e[0], e[1]))
-  return slice
-}
-
-module.exports = repairSlice