@jscad/modeling 2.7.2 → 2.9.1

package/src/operations/extrusions/earcut/index.js

@@ -0,0 +1,252 @@
+const eliminateHoles = require('./eliminateHoles')
+const { removeNode, sortLinked } = require('./linkedList')
+const { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, splitPolygon } = require('./linkedPolygon')
+const { area, pointInTriangle } = require('./triangle')
+
+/*
+ * An implementation of the earcut polygon triangulation algorithm.
+ *
+ * Original source from https://github.com/mapbox/earcut
+ * Copyright (c) 2016 Mapbox
+ *
+ * @param {data} A flat array of vertex coordinates.
+ * @param {holeIndices} An array of hole indices if any.
+ * @param {dim} The number of coordinates per vertex in the input array.
+ */
+const triangulate = (data, holeIndices, dim = 2) => {
+  const hasHoles = holeIndices && holeIndices.length
+  const outerLen = hasHoles ? holeIndices[0] * dim : data.length
+  let outerNode = linkedPolygon(data, 0, outerLen, dim, true)
+  const triangles = []
+
+  if (!outerNode || outerNode.next === outerNode.prev) return triangles
+
+  let minX, minY, maxX, maxY, invSize
+
+  if (hasHoles) outerNode = eliminateHoles(data, holeIndices, outerNode, dim)
+
+  // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
+  if (data.length > 80 * dim) {
+    minX = maxX = data[0]
+    minY = maxY = data[1]
+
+    for (let i = dim; i < outerLen; i += dim) {
+      const x = data[i]
+      const y = data[i + 1]
+      if (x < minX) minX = x
+      if (y < minY) minY = y
+      if (x > maxX) maxX = x
+      if (y > maxY) maxY = y
+    }
+
+    // minX, minY and invSize are later used to transform coords into integers for z-order calculation
+    invSize = Math.max(maxX - minX, maxY - minY)
+    invSize = invSize !== 0 ? 1 / invSize : 0
+  }
+
+  earcutLinked(outerNode, triangles, dim, minX, minY, invSize)
+
+  return triangles
+}
+
+/*
+ * main ear slicing loop which triangulates a polygon (given as a linked list)
+ */
+const earcutLinked = (ear, triangles, dim, minX, minY, invSize, pass) => {
+  if (!ear) return
+
+  // interlink polygon nodes in z-order
+  if (!pass && invSize) indexCurve(ear, minX, minY, invSize)
+
+  let stop = ear
+  let prev
+  let next
+
+  // iterate through ears, slicing them one by one
+  while (ear.prev !== ear.next) {
+    prev = ear.prev
+    next = ear.next
+
+    if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+      // cut off the triangle
+      triangles.push(prev.i / dim)
+      triangles.push(ear.i / dim)
+      triangles.push(next.i / dim)
+
+      removeNode(ear)
+
+      // skipping the next vertex leads to less sliver triangles
+      ear = next.next
+      stop = next.next
+
+      continue
+    }
+
+    ear = next
+
+    // if we looped through the whole remaining polygon and can't find any more ears
+    if (ear === stop) {
+      // try filtering points and slicing again
+      if (!pass) {
+        earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1)
+
+        // if this didn't work, try curing all small self-intersections locally
+      } else if (pass === 1) {
+        ear = cureLocalIntersections(filterPoints(ear), triangles, dim)
+        earcutLinked(ear, triangles, dim, minX, minY, invSize, 2)
+
+        // as a last resort, try splitting the remaining polygon into two
+      } else if (pass === 2) {
+        splitEarcut(ear, triangles, dim, minX, minY, invSize)
+      }
+
+      break
+    }
+  }
+}
+
+/*
+ * check whether a polygon node forms a valid ear with adjacent nodes
+ */
+const isEar = (ear) => {
+  const a = ear.prev
+  const b = ear
+  const c = ear.next
+
+  if (area(a, b, c) >= 0) return false // reflex, can't be an ear
+
+  // now make sure we don't have other points inside the potential ear
+  let p = ear.next.next
+
+  while (p !== ear.prev) {
+    if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0) {
+      return false
+    }
+    p = p.next
+  }
+
+  return true
+}
+
+const isEarHashed = (ear, minX, minY, invSize) => {
+  const a = ear.prev
+  const b = ear
+  const c = ear.next
+
+  if (area(a, b, c) >= 0) return false // reflex, can't be an ear
+
+  // triangle bbox; min & max are calculated like this for speed
+  const minTX = a.x < b.x ? (a.x < c.x ? a.x : c.x) : (b.x < c.x ? b.x : c.x)
+  const minTY = a.y < b.y ? (a.y < c.y ? a.y : c.y) : (b.y < c.y ? b.y : c.y)
+  const maxTX = a.x > b.x ? (a.x > c.x ? a.x : c.x) : (b.x > c.x ? b.x : c.x)
+  const maxTY = a.y > b.y ? (a.y > c.y ? a.y : c.y) : (b.y > c.y ? b.y : c.y)
+
+  // z-order range for the current triangle bbox
+  const minZ = zOrder(minTX, minTY, minX, minY, invSize)
+  const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize)
+
+  let p = ear.prevZ
+  let n = ear.nextZ
+
+  // look for points inside the triangle in both directions
+  while (p && p.z >= minZ && n && n.z <= maxZ) {
+    if (p !== ear.prev && p !== ear.next &&
+      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+      area(p.prev, p, p.next) >= 0) return false
+    p = p.prevZ
+
+    if (n !== ear.prev && n !== ear.next &&
+      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+      area(n.prev, n, n.next) >= 0) return false
+    n = n.nextZ
+  }
+
+  // look for remaining points in decreasing z-order
+  while (p && p.z >= minZ) {
+    if (p !== ear.prev && p !== ear.next &&
+      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) &&
+      area(p.prev, p, p.next) >= 0) return false
+    p = p.prevZ
+  }
+
+  // look for remaining points in increasing z-order
+  while (n && n.z <= maxZ) {
+    if (n !== ear.prev && n !== ear.next &&
+      pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) &&
+      area(n.prev, n, n.next) >= 0) return false
+    n = n.nextZ
+  }
+
+  return true
+}
+
+/*
+ * try splitting polygon into two and triangulate them independently
+ */
+const splitEarcut = (start, triangles, dim, minX, minY, invSize) => {
+  // look for a valid diagonal that divides the polygon into two
+  let a = start
+  do {
+    let b = a.next.next
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        // split the polygon in two by the diagonal
+        let c = splitPolygon(a, b)
+
+        // filter colinear points around the cuts
+        a = filterPoints(a, a.next)
+        c = filterPoints(c, c.next)
+
+        // run earcut on each half
+        earcutLinked(a, triangles, dim, minX, minY, invSize)
+        earcutLinked(c, triangles, dim, minX, minY, invSize)
+        return
+      }
+
+      b = b.next
+    }
+
+    a = a.next
+  } while (a !== start)
+}
+
+/*
+ * interlink polygon nodes in z-order
+ */
+const indexCurve = (start, minX, minY, invSize) => {
+  let p = start
+  do {
+    if (p.z === null) p.z = zOrder(p.x, p.y, minX, minY, invSize)
+    p.prevZ = p.prev
+    p.nextZ = p.next
+    p = p.next
+  } while (p !== start)
+
+  p.prevZ.nextZ = null
+  p.prevZ = null
+
+  sortLinked(p, (p) => p.z)
+}
+
+/*
+ * z-order of a point given coords and inverse of the longer side of data bbox
+ */
+const zOrder = (x, y, minX, minY, invSize) => {
+  // coords are transformed into non-negative 15-bit integer range
+  x = 32767 * (x - minX) * invSize
+  y = 32767 * (y - minY) * invSize
+
+  x = (x | (x << 8)) & 0x00FF00FF
+  x = (x | (x << 4)) & 0x0F0F0F0F
+  x = (x | (x << 2)) & 0x33333333
+  x = (x | (x << 1)) & 0x55555555
+
+  y = (y | (y << 8)) & 0x00FF00FF
+  y = (y | (y << 4)) & 0x0F0F0F0F
+  y = (y | (y << 2)) & 0x33333333
+  y = (y | (y << 1)) & 0x55555555
+
+  return x | (y << 1)
+}
+
+module.exports = triangulate

package/src/operations/extrusions/earcut/linkedList.js

@@ -0,0 +1,58 @@
+const sortLinked = require('./linkedListSort')
+
+class Node {
+  constructor (i, x, y) {
+    // vertex index in coordinates array
+    this.i = i
+
+    // vertex coordinates
+    this.x = x
+    this.y = y
+
+    // previous and next vertex nodes in a polygon ring
+    this.prev = null
+    this.next = null
+
+    // z-order curve value
+    this.z = null
+
+    // previous and next nodes in z-order
+    this.prevZ = null
+    this.nextZ = null
+
+    // indicates whether this is a steiner point
+    this.steiner = false
+  }
+}
+
+/*
+ * create a node and optionally link it with previous one (in a circular doubly linked list)
+ */
+const insertNode = (i, x, y, last) => {
+  const p = new Node(i, x, y)
+
+  if (!last) {
+    p.prev = p
+    p.next = p
+  } else {
+    p.next = last.next
+    p.prev = last
+    last.next.prev = p
+    last.next = p
+  }
+
+  return p
+}
+
+/*
+ * remove a node and join prev with next nodes
+ */
+const removeNode = (p) => {
+  p.next.prev = p.prev
+  p.prev.next = p.next
+
+  if (p.prevZ) p.prevZ.nextZ = p.nextZ
+  if (p.nextZ) p.nextZ.prevZ = p.prevZ
+}
+
+module.exports = { Node, insertNode, removeNode, sortLinked }

package/src/operations/extrusions/earcut/linkedListSort.js

@@ -0,0 +1,54 @@
+
+// Simon Tatham's linked list merge sort algorithm
+// https://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
+const sortLinked = (list, fn) => {
+  let i, p, q, e, numMerges
+  let inSize = 1
+
+  do {
+    p = list
+    list = null
+    let tail = null
+    numMerges = 0
+
+    while (p) {
+      numMerges++
+      q = p
+      let pSize = 0
+      for (i = 0; i < inSize; i++) {
+        pSize++
+        q = q.nextZ
+        if (!q) break
+      }
+
+      let qSize = inSize
+
+      while (pSize > 0 || (qSize > 0 && q)) {
+        if (pSize !== 0 && (qSize === 0 || !q || fn(p) <= fn(q))) {
+          e = p
+          p = p.nextZ
+          pSize--
+        } else {
+          e = q
+          q = q.nextZ
+          qSize--
+        }
+
+        if (tail) tail.nextZ = e
+        else list = e
+
+        e.prevZ = tail
+        tail = e
+      }
+
+      p = q
+    }
+
+    tail.nextZ = null
+    inSize *= 2
+  } while (numMerges > 1)
+
+  return list
+}
+
+module.exports = sortLinked

package/src/operations/extrusions/earcut/linkedPolygon.js

@@ -0,0 +1,197 @@
+const { Node, insertNode, removeNode } = require('./linkedList')
+const { area } = require('./triangle')
+
+/*
+ * create a circular doubly linked list from polygon points in the specified winding order
+ */
+const linkedPolygon = (data, start, end, dim, clockwise) => {
+  let last
+
+  if (clockwise === (signedArea(data, start, end, dim) > 0)) {
+    for (let i = start; i < end; i += dim) {
+      last = insertNode(i, data[i], data[i + 1], last)
+    }
+  } else {
+    for (let i = end - dim; i >= start; i -= dim) {
+      last = insertNode(i, data[i], data[i + 1], last)
+    }
+  }
+
+  if (last && equals(last, last.next)) {
+    removeNode(last)
+    last = last.next
+  }
+
+  return last
+}
+
+/*
+ * eliminate colinear or duplicate points
+ */
+const filterPoints = (start, end) => {
+  if (!start) return start
+  if (!end) end = start
+
+  let p = start
+  let again
+  do {
+    again = false
+
+    if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+      removeNode(p)
+      p = end = p.prev
+      if (p === p.next) break
+      again = true
+    } else {
+      p = p.next
+    }
+  } while (again || p !== end)
+
+  return end
+}
+
+/*
+ * go through all polygon nodes and cure small local self-intersections
+ */
+const cureLocalIntersections = (start, triangles, dim) => {
+  let p = start
+  do {
+    const a = p.prev
+    const b = p.next.next
+
+    if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      triangles.push(a.i / dim)
+      triangles.push(p.i / dim)
+      triangles.push(b.i / dim)
+
+      // remove two nodes involved
+      removeNode(p)
+      removeNode(p.next)
+
+      p = start = b
+    }
+
+    p = p.next
+  } while (p !== start)
+
+  return filterPoints(p)
+}
+
+/*
+ * check if a polygon diagonal intersects any polygon segments
+ */
+const intersectsPolygon = (a, b) => {
+  let p = a
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&
+        intersects(p, p.next, a, b)) return true
+    p = p.next
+  } while (p !== a)
+
+  return false
+}
+
+/*
+ * check if a polygon diagonal is locally inside the polygon
+ */
+const locallyInside = (a, b) => area(a.prev, a, a.next) < 0
+  ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0
+  : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0
+
+/*
+ * check if the middle point of a polygon diagonal is inside the polygon
+ */
+const middleInside = (a, b) => {
+  let p = a
+  let inside = false
+  const px = (a.x + b.x) / 2
+  const py = (a.y + b.y) / 2
+  do {
+    if (((p.y > py) !== (p.next.y > py)) && p.next.y !== p.y &&
+        (px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)) { inside = !inside }
+    p = p.next
+  } while (p !== a)
+
+  return inside
+}
+
+/*
+ * link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two
+ * if one belongs to the outer ring and another to a hole, it merges it into a single ring
+ */
+const splitPolygon = (a, b) => {
+  const a2 = new Node(a.i, a.x, a.y)
+  const b2 = new Node(b.i, b.x, b.y)
+  const an = a.next
+  const bp = b.prev
+
+  a.next = b
+  b.prev = a
+
+  a2.next = an
+  an.prev = a2
+
+  b2.next = a2
+  a2.prev = b2
+
+  bp.next = b2
+  b2.prev = bp
+
+  return b2
+}
+
+/*
+ * check if a diagonal between two polygon nodes is valid (lies in polygon interior)
+ */
+const isValidDiagonal = (a, b) => a.next.i !== b.i &&
+    a.prev.i !== b.i &&
+    !intersectsPolygon(a, b) && // doesn't intersect other edges
+    (
+      locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
+        (area(a.prev, a, b.prev) || area(a, b.prev, b)) || // does not create opposite-facing sectors
+        equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0
+    )
+
+/*
+ * check if two segments intersect
+ */
+const intersects = (p1, q1, p2, q2) => {
+  const o1 = Math.sign(area(p1, q1, p2))
+  const o2 = Math.sign(area(p1, q1, q2))
+  const o3 = Math.sign(area(p2, q2, p1))
+  const o4 = Math.sign(area(p2, q2, q1))
+
+  if (o1 !== o2 && o3 !== o4) return true // general case
+
+  if (o1 === 0 && onSegment(p1, p2, q1)) return true // p1, q1 and p2 are colinear and p2 lies on p1q1
+  if (o2 === 0 && onSegment(p1, q2, q1)) return true // p1, q1 and q2 are colinear and q2 lies on p1q1
+  if (o3 === 0 && onSegment(p2, p1, q2)) return true // p2, q2 and p1 are colinear and p1 lies on p2q2
+  if (o4 === 0 && onSegment(p2, q1, q2)) return true // p2, q2 and q1 are colinear and q1 lies on p2q2
+
+  return false
+}
+
+/*
+ * for colinear points p, q, r, check if point q lies on segment pr
+ */
+const onSegment = (p, q, r) => q.x <= Math.max(p.x, r.x) &&
+    q.x >= Math.min(p.x, r.x) &&
+    q.y <= Math.max(p.y, r.y) &&
+    q.y >= Math.min(p.y, r.y)
+
+const signedArea = (data, start, end, dim) => {
+  let sum = 0
+  for (let i = start, j = end - dim; i < end; i += dim) {
+    sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1])
+    j = i
+  }
+
+  return sum
+}
+
+/*
+ * check if two points are equal
+ */
+const equals = (p1, p2) => p1.x === p2.x && p1.y === p2.y
+
+module.exports = { cureLocalIntersections, filterPoints, isValidDiagonal, linkedPolygon, locallyInside, splitPolygon }

package/src/operations/extrusions/earcut/polygonHierarchy.js

@@ -0,0 +1,64 @@
+const geom2 = require('../../../geometries/geom2')
+const plane = require('../../../maths/plane')
+const vec2 = require('../../../maths/vec2')
+const vec3 = require('../../../maths/vec3')
+const calculatePlane = require('../slice/calculatePlane')
+const assignHoles = require('./assignHoles')
+
+/*
+ * Constructs a polygon hierarchy which associates holes with their outer solids.
+ * This class maps a 3D polygon onto a 2D space using an orthonormal basis.
+ * It tracks the mapping so that points can be reversed back to 3D losslessly.
+ */
+class PolygonHierarchy {
+  constructor (slice) {
+    this.plane = calculatePlane(slice)
+
+    // create an orthonormal basis
+    // choose an arbitrary right hand vector, making sure it is somewhat orthogonal to the plane normal
+    const rightvector = vec3.orthogonal(vec3.create(), this.plane)
+    const perp = vec3.cross(vec3.create(), this.plane, rightvector)
+    this.v = vec3.normalize(perp, perp)
+    this.u = vec3.cross(vec3.create(), this.v, this.plane)
+
+    // map from 2D to original 3D points
+    this.basisMap = new Map()
+
+    // project slice onto 2D plane
+    const projected = slice.edges.map((e) => e.map((v) => this.to2D(v)))
+
+    // compute polygon hierarchies, assign holes to solids
+    const geometry = geom2.create(projected)
+    this.roots = assignHoles(geometry)
+  }
+
+  /*
+   * project a 3D point onto the 2D plane
+   */
+  to2D (vector3) {
+    const vector2 = vec2.fromValues(vec3.dot(vector3, this.u), vec3.dot(vector3, this.v))
+    this.basisMap.set(vector2, vector3)
+    return vector2
+  }
+
+  /*
+   * un-project a 2D point back into 3D
+   */
+  to3D (vector2) {
+    // use a map to get the original 3D, no floating point error
+    const original = this.basisMap.get(vector2)
+    if (original) {
+      return original
+    } else {
+      console.log('Warning: point not in original slice')
+      const v1 = vec3.scale(vec3.create(), this.u, vector2[0])
+      const v2 = vec3.scale(vec3.create(), this.v, vector2[1])
+
+      const planeOrigin = vec3.scale(vec3.create(), plane, plane[3])
+      const v3 = vec3.add(v1, v1, planeOrigin)
+      return vec3.add(v2, v2, v3)
+    }
+  }
+}
+
+module.exports = PolygonHierarchy

package/src/operations/extrusions/earcut/triangle.js

@@ -0,0 +1,16 @@
+
+/*
+ * check if a point lies within a convex triangle
+ */
+const pointInTriangle = (ax, ay, bx, by, cx, cy, px, py) => (
+  (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
+      (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
+      (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0
+)
+
+/*
+ * signed area of a triangle
+ */
+const area = (p, q, r) => (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
+
+module.exports = { area, pointInTriangle }

package/src/operations/extrusions/extrudeFromSlices.js

@@ -5,6 +5,7 @@ const geom3 = require('../../geometries/geom3')
 const poly3 = require('../../geometries/poly3')
 
 const slice = require('./slice')
+const repairSlice = require('./slice/repairSlice')
 
 const extrudeWalls = require('./extrudeWalls')
 
@@ -25,6 +26,7 @@ const defaultCallback = (progress, index, base) => {
  * @param {Boolean} [options.capStart=true] the solid should have a cap at the start
  * @param {Boolean} [options.capEnd=true] the solid should have a cap at the end
  * @param {Boolean} [options.close=false] the solid should have a closing section between start and end
+ * @param {Boolean} [options.repair=true] - repair gaps in the geometry
  * @param {Function} [options.callback] the callback function that generates each slice
  * @param {Object} base - the base object which is used to create slices (see the example for callback information)
  * @return {geom3} the extruded shape
@@ -48,12 +50,18 @@ const extrudeFromSlices = (options, base) => {
     capStart: true,
     capEnd: true,
     close: false,
+    repair: true,
     callback: defaultCallback
   }
-  const { numberOfSlices, capStart, capEnd, close, callback: generate } = Object.assign({ }, defaults, options)
+  const { numberOfSlices, capStart, capEnd, close, repair, callback: generate } = Object.assign({ }, defaults, options)
 
   if (numberOfSlices < 2) throw new Error('numberOfSlices must be 2 or more')
 
+  // Repair gaps in the base slice
+  if (repair) {
+    repairSlice(base)
+  }
+
   const sMax = numberOfSlices - 1
 
   let startSlice = null
@@ -90,8 +98,7 @@ const extrudeFromSlices = (options, base) => {
   }
   if (capStart) {
     // create a cap at the start
-    slice.reverse(startSlice, startSlice)
-    const startPolygons = slice.toPolygons(startSlice)
+    const startPolygons = slice.toPolygons(startSlice).map(poly3.invert)
     polygons = polygons.concat(startPolygons)
   }
   if (!capStart && !capEnd) {