@jscad/modeling 2.9.3 → 2.9.6

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -23,14 +23,13 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
   const orthobasis = new OrthoNormalBasis(plane)
   const polygonvertices2d = [] // array of array of Vector2D
   const polygontopvertexindexes = [] // array of indexes of topmost vertex per polygon
-  const topy2polygonindexes = {}
-  const ycoordinatetopolygonindexes = {}
-
-  const ycoordinatebins = {}
+  const topy2polygonindexes = new Map()
+  const ycoordinatetopolygonindexes = new Map()
 
   // convert all polygon vertices to 2D
   // Make a list of all encountered y coordinates
   // And build a map of all polygons that have a vertex at a certain y coordinate:
+  const ycoordinatebins = new Map()
   const ycoordinateBinningFactor = 10 / EPS
   for (let polygonindex = 0; polygonindex < numpolygons; polygonindex++) {
     const poly3d = sourcepolygons[polygonindex]
@@ -46,15 +45,15 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         // close to each other, give them the same y coordinate:
         const ycoordinatebin = Math.floor(pos2d[1] * ycoordinateBinningFactor)
         let newy
-        if (ycoordinatebin in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin]
-        } else if (ycoordinatebin + 1 in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin + 1]
-        } else if (ycoordinatebin - 1 in ycoordinatebins) {
-          newy = ycoordinatebins[ycoordinatebin - 1]
+        if (ycoordinatebins.has(ycoordinatebin)) {
+          newy = ycoordinatebins.get(ycoordinatebin)
+        } else if (ycoordinatebins.has(ycoordinatebin + 1)) {
+          newy = ycoordinatebins.get(ycoordinatebin + 1)
+        } else if (ycoordinatebins.has(ycoordinatebin - 1)) {
+          newy = ycoordinatebins.get(ycoordinatebin - 1)
         } else {
           newy = pos2d[1]
-          ycoordinatebins[ycoordinatebin] = pos2d[1]
+          ycoordinatebins.set(ycoordinatebin, pos2d[1])
         }
         pos2d = vec2.fromValues(pos2d[0], newy)
         vertices2d.push(pos2d)
@@ -66,10 +65,12 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         if ((i === 0) || (y > maxy)) {
           maxy = y
         }
-        if (!(y in ycoordinatetopolygonindexes)) {
-          ycoordinatetopolygonindexes[y] = {}
+        let polygonindexes = ycoordinatetopolygonindexes.get(y)
+        if (!polygonindexes) {
+          polygonindexes = {} // PERF
+          ycoordinatetopolygonindexes.set(y, polygonindexes)
         }
-        ycoordinatetopolygonindexes[y][polygonindex] = true
+        polygonindexes[polygonindex] = true
       }
       if (miny >= maxy) {
         // degenerate polygon, all vertices have same y coordinate. Just ignore it from now:
@@ -77,10 +78,12 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         numvertices = 0
         minindex = -1
       } else {
-        if (!(miny in topy2polygonindexes)) {
-          topy2polygonindexes[miny] = []
+        let polygonindexes = topy2polygonindexes.get(miny)
+        if (!polygonindexes) {
+          polygonindexes = []
+          topy2polygonindexes.set(miny, polygonindexes)
         }
-        topy2polygonindexes[miny].push(polygonindex)
+        polygonindexes.push(polygonindex)
       }
     } // if(numvertices > 0)
     // reverse the vertex order:
@@ -89,8 +92,9 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     polygonvertices2d.push(vertices2d)
     polygontopvertexindexes.push(minindex)
   }
+
   const ycoordinates = []
-  for (const ycoordinate in ycoordinatetopolygonindexes) ycoordinates.push(ycoordinate)
+  ycoordinatetopolygonindexes.forEach((polylist, y) => ycoordinates.push(y))
   ycoordinates.sort(fnNumberSort)
 
   // Now we will iterate over all y coordinates, from lowest to highest y coordinate
@@ -108,15 +112,14 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
   let prevoutpolygonrow = []
   for (let yindex = 0; yindex < ycoordinates.length; yindex++) {
     const newoutpolygonrow = []
-    const ycoordinateasstring = ycoordinates[yindex]
-    const ycoordinate = Number(ycoordinateasstring)
+    const ycoordinate = ycoordinates[yindex]
 
     // update activepolygons for this y coordinate:
     // - Remove any polygons that end at this y coordinate
     // - update leftvertexindex and rightvertexindex (which point to the current vertex index
     //   at the the left and right side of the polygon
     // Iterate over all polygons that have a corner at this y coordinate:
-    const polygonindexeswithcorner = ycoordinatetopolygonindexes[ycoordinateasstring]
+    const polygonindexeswithcorner = ycoordinatetopolygonindexes.get(ycoordinate)
     for (let activepolygonindex = 0; activepolygonindex < activepolygons.length; ++activepolygonindex) {
       const activepolygon = activepolygons[activepolygonindex]
       const polygonindex = activepolygon.polygonindex
@@ -166,7 +169,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
       nextycoordinate = Number(ycoordinates[yindex + 1])
       const middleycoordinate = 0.5 * (ycoordinate + nextycoordinate)
       // update activepolygons by adding any polygons that start here:
-      const startingpolygonindexes = topy2polygonindexes[ycoordinateasstring]
+      const startingpolygonindexes = topy2polygonindexes.get(ycoordinate)
       for (const polygonindexKey in startingpolygonindexes) {
         const polygonindex = startingpolygonindexes[polygonindexKey]
         const vertices2d = polygonvertices2d[polygonindex]
@@ -212,8 +215,6 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
         })
       } // for(let polygonindex in startingpolygonindexes)
     } //  yindex < ycoordinates.length-1
-    // if( (yindex === ycoordinates.length-1) || (nextycoordinate - ycoordinate > EPS) )
-    // FIXME : what ???
 
     // Now activepolygons is up to date
     // Build the output polygons for the next row in newoutpolygonrow:
@@ -252,19 +253,19 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
     } // for(activepolygon in activepolygons)
     if (yindex > 0) {
       // try to match the new polygons against the previous row:
-      const prevcontinuedindexes = {}
-      const matchedindexes = {}
+      const prevcontinuedindexes = new Set()
+      const matchedindexes = new Set()
       for (let i = 0; i < newoutpolygonrow.length; i++) {
         const thispolygon = newoutpolygonrow[i]
         for (let ii = 0; ii < prevoutpolygonrow.length; ii++) {
-          if (!matchedindexes[ii]) { // not already processed?
+          if (!matchedindexes.has(ii)) { // not already processed?
             // We have a match if the sidelines are equal or if the top coordinates
             // are on the sidelines of the previous polygon
             const prevpolygon = prevoutpolygonrow[ii]
             if (vec2.distance(prevpolygon.bottomleft, thispolygon.topleft) < EPS) {
               if (vec2.distance(prevpolygon.bottomright, thispolygon.topright) < EPS) {
                 // Yes, the top of this polygon matches the bottom of the previous:
-                matchedindexes[ii] = true
+                matchedindexes.add(ii)
                 // Now check if the joined polygon would remain convex:
                 const v1 = line2.direction(thispolygon.leftline)
                 const v2 = line2.direction(prevpolygon.leftline)
@@ -284,16 +285,16 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
                   thispolygon.outpolygon = prevpolygon.outpolygon
                   thispolygon.leftlinecontinues = leftlinecontinues
                   thispolygon.rightlinecontinues = rightlinecontinues
-                  prevcontinuedindexes[ii] = true
+                  prevcontinuedindexes.add(ii)
                 }
                 break
               }
             }
-          } // if(!prevcontinuedindexes[ii])
+          } // if(!prevcontinuedindexes.has(ii))
         } // for ii
       } // for i
       for (let ii = 0; ii < prevoutpolygonrow.length; ii++) {
-        if (!prevcontinuedindexes[ii]) {
+        if (!prevcontinuedindexes.has(ii)) {
           // polygon ends here
           // Finish the polygon with the last point(s):
           const prevpolygon = prevoutpolygonrow[ii]

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/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')
 
@@ -96,7 +96,9 @@ const cylinderElliptic = (options) => {
   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')
 

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/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

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')
 

package/src/primitives/torus.test.js

@@ -15,7 +15,6 @@ test('torus (defaults)', (t) => {
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5, -5, -1], [5, 5, 1]]
-  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
@@ -27,7 +26,6 @@ test('torus (simple options)', (t) => {
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-5.5, -5.5, -0.5], [5.5, 5.5, 0.5]]
-  t.notThrows(() => geom3.validate(obs))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected: ' + JSON.stringify(bounds))
 })
 
@@ -39,10 +37,16 @@ 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 })
 

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/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