@jscad/modeling 2.8.0 → 2.9.0

package/src/operations/extrusions/extrudeRotate.test.js

@@ -29,21 +29,21 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[26, -4.898587196589413e-16, -8], [7.0710678118654755, 7.071067811865475, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 4.898587196589413e-16, 8], [26, -4.898587196589413e-16, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 4.898587196589413e-16, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
-    [[18.38477631085024, 18.384776310850235, 7.999999999999998], [18.38477631085024, 18.384776310850235, -8],
-      [7.071067811865478, 7.071067811865474, -8], [7.071067811865476, 7.071067811865475, 8]],
-    [[10, 4.898587196589411e-16, 8], [10, -4.898587196589413e-16, -8],
-      [26, -4.898587196589412e-16, -8], [26, 4.898587196589414e-16, 8]]
+    [[7.071067811865476, 7.0710678118654755, -8], [7.071067811865476, 7.0710678118654755, 8], [18.384776310850242, 18.384776310850235, 8]],
+    [[18.384776310850242, 18.384776310850235, 8], [18.384776310850242, 18.384776310850235, -8], [7.071067811865476, 7.0710678118654755, -8]],
+    [[26, 4.898587196589413e-16, 8], [10, 4.898587196589413e-16, 8], [10, -4.898587196589413e-16, -8]],
+    [[10, -4.898587196589413e-16, -8], [26, -4.898587196589413e-16, -8], [26, 4.898587196589413e-16, 8]]
   ]
-  t.is(pts.length, 10)
+  t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 26)
+  t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
-  t.is(pts.length, 26)
+  t.is(pts.length, 28)
 })
 
 test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom3', (t) => {
@@ -107,16 +107,12 @@ 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.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589413e-16, 2.999519565323715e-32, 8], [-6.123233995736767e-17, 7, 8]],
+    [[-6.123233995736767e-17, 7, 8], [9.184850993605148e-16, 7, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8]],
+    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8]],
+    [[0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8], [7, 4.898587196589413e-16, 8]]
   ]
-  t.is(pts.length, 6)
+  t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // overlap of Y axis; larger number of - points
@@ -137,18 +133,14 @@ 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]
-    ]
+    [[5.51091059616309e-16, 1, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
+    [[-4.898587196589415e-16, 2.9995195653237163e-32, 8], [-4.286263797015738e-16, 1, 8], [-1.2246467991473544e-16, 2, 4]],
+    [[-1.2246467991473544e-16, 2, 4], [5.51091059616309e-16, 1, -8], [-4.898587196589415e-16, 2.9995195653237163e-32, 8]],
+    [[0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8], [1, -4.898587196589413e-16, -8]],
+    [[2, 2.4492935982947064e-16, 4], [1, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8]],
+    [[0, 4.898587196589413e-16, 8], [1, -4.898587196589413e-16, -8], [2, 2.4492935982947064e-16, 4]]
   ]
-  t.is(pts.length, 14)
+  t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 

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

@@ -23,10 +23,13 @@ const calculatePlane = (slice) => {
   let farthestEdge
   let distance = 0
   edges.forEach((edge) => {
-    const d = vec3.squaredDistance(midpoint, edge[0])
-    if (d > distance) {
-      farthestEdge = edge
-      distance = d
+    // Make sure that the farthest edge is not a self-edge
+    if (!vec3.equals(edge[0], edge[1])) {
+      const d = vec3.squaredDistance(midpoint, edge[0])
+      if (d > distance) {
+        farthestEdge = edge
+        distance = d
+      }
     }
   })
   // find the before edge

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

@@ -0,0 +1,47 @@
+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

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

@@ -1,21 +1,6 @@
-const vec3 = require('../../../maths/vec3')
-
-const geom3 = require('../../../geometries/geom3')
 const poly3 = require('../../../geometries/poly3')
-
-const intersectGeom3Sub = require('../../booleans/intersectGeom3Sub')
-
-const calculatePlane = require('./calculatePlane')
-
-const toPolygon3D = (vector, edge) => {
-  const points = [
-    vec3.subtract(vec3.create(), edge[0], vector),
-    vec3.subtract(vec3.create(), edge[1], vector),
-    vec3.add(vec3.create(), edge[1], vector),
-    vec3.add(vec3.create(), edge[0], vector)
-  ]
-  return poly3.fromPoints(points)
-}
+const earcut = require('../earcut')
+const PolygonHierarchy = require('../earcut/polygonHierarchy')
 
 /**
  * Return a list of polygons which are enclosed by the slice.
@@ -24,52 +9,31 @@ const toPolygon3D = (vector, edge) => {
  * @alias module:modeling/extrusions/slice.toPolygons
  */
 const toPolygons = (slice) => {
-  const splane = calculatePlane(slice)
-
-  // find the midpoint of the slice, which will lie on the plane by definition
-  const edges = slice.edges
-  const midpoint = edges.reduce((point, edge) => vec3.add(vec3.create(), point, edge[0]), vec3.create())
-  vec3.scale(midpoint, midpoint, 1 / edges.length)
-
-  // find the farthest edge from the midpoint, which will be on an outside edge
-  let farthestEdge = [[NaN, NaN, NaN], [NaN, NaN, NaN]]
-  let distance = 0
-  edges.forEach((edge) => {
-    const d = vec3.squaredDistance(midpoint, edge[0])
-    if (d > distance) {
-      farthestEdge = edge
-      distance = d
+  const hierarchy = new PolygonHierarchy(slice)
+
+  const polygons = []
+  hierarchy.roots.forEach(({ solid, holes }) => {
+    // hole indices
+    let index = solid.length
+    const holesIndex = []
+    holes.forEach((hole, i) => {
+      holesIndex.push(index)
+      index += hole.length
+    })
+
+    // compute earcut triangulation for each solid
+    const vertices = [solid, ...holes].flat()
+    const data = vertices.flat()
+    // Get original 3D vertex by index
+    const getVertex = (i) => hierarchy.to3D(vertices[i])
+    const indices = earcut(data, holesIndex)
+    for (let i = 0; i < indices.length; i += 3) {
+      // Map back to original vertices
+      const tri = indices.slice(i, i + 3).map(getVertex)
+      polygons.push(poly3.fromPointsAndPlane(tri, hierarchy.plane))
     }
   })
 
-  // create one LARGE polygon to encompass the side, i.e. base
-  const direction = vec3.subtract(vec3.create(), farthestEdge[0], midpoint)
-  const perpendicular = vec3.cross(vec3.create(), splane, direction)
-
-  const p1 = vec3.add(vec3.create(), midpoint, direction)
-  vec3.add(p1, p1, direction)
-  const p2 = vec3.add(vec3.create(), midpoint, perpendicular)
-  vec3.add(p2, p2, perpendicular)
-  const p3 = vec3.subtract(vec3.create(), midpoint, direction)
-  vec3.subtract(p3, p3, direction)
-  const p4 = vec3.subtract(vec3.create(), midpoint, perpendicular)
-  vec3.subtract(p4, p4, perpendicular)
-  const poly1 = poly3.fromPoints([p1, p2, p3, p4])
-  const base = geom3.create([poly1])
-
-  const wallPolygons = edges.map((edge) => toPolygon3D(splane, edge))
-  const walls = geom3.create(wallPolygons)
-
-  // make an intersection of the base and the walls, creating... a set of polygons!
-  const geometry3 = intersectGeom3Sub(base, walls)
-
-  // return only those polygons from the base
-  let polygons = geom3.toPolygons(geometry3)
-  polygons = polygons.filter((polygon) => {
-    const a = vec3.angle(splane, poly3.plane(polygon))
-    // walls should be PI / 2 radians rotated from the base
-    return Math.abs(a) < (Math.PI / 90)
-  })
   return polygons
 }
 

package/src/primitives/torus.test.js

@@ -30,7 +30,7 @@ test('torus (Simple options)', (t) => {
 test('torus (complex options)', (t) => {
   const obs = torus({ innerRadius: 1, outerRadius: 5, innerSegments: 32, outerSegments: 72, startAngle: Math.PI / 2, outerRotation: Math.PI / 2 })
   const pts = geom3.toPoints(obs)
-  t.is(pts.length, 1154)
+  t.is(pts.length, 1212)
 
   const bounds = measureBoundingBox(obs)
   const expectedBounds = [[-6, 0, -1], [0, 6, 1]]