@jscad/modeling 2.11.1 → 3.0.0-alpha.0

package/src/operations/booleans/martinez/index.js

@@ -0,0 +1,154 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm.
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ *
+ * Adapted for JSCAD by @platypii
+ */
+
+import { subdivideSegments } from './subdivideSegments.js'
+import { connectEdges } from './connectEdges.js'
+import { fillQueue } from './fillQueue.js'
+import {
+  INTERSECTION,
+  DIFFERENCE,
+  UNION,
+  XOR
+} from './operation.js'
+import * as geom2 from '../../../geometries/geom2/index.js'
+import * as vec2 from '../../../maths/vec2/index.js'
+
+const EMPTY = []
+
+/*
+ * Fast path for trivial operations like intersection with empty geometry
+ * Returns null if operation is non-trivial
+ */
+const trivialOperation = (subject, clipping, operation) => {
+  let result = null
+  if (subject.length * clipping.length === 0) {
+    if (operation === INTERSECTION) {
+      return EMPTY
+    } else if (operation === DIFFERENCE) {
+      result = subject
+    } else if (operation === UNION ||
+               operation === XOR) {
+      result = (subject.length === 0) ? clipping : subject
+    }
+  }
+  if (result === EMPTY) {
+    return geom2.create()
+  } else if (result) {
+    return fromOutlines(result.flat())
+  } else {
+    return null
+  }
+}
+
+/*
+ * Fast path for non-intersecting subjects
+ * Returns null if operation is non-trivial
+ */
+const compareBBoxes = (subject, clipping, sbbox, cbbox, operation) => {
+  let result = null
+  if (sbbox[0] > cbbox[2] ||
+      cbbox[0] > sbbox[2] ||
+      sbbox[1] > cbbox[3] ||
+      cbbox[1] > sbbox[3]) {
+    if (operation === INTERSECTION) {
+      result = EMPTY
+    } else if (operation === DIFFERENCE) {
+      result = subject
+    } else if (operation === UNION ||
+               operation === XOR) {
+      result = subject.concat(clipping)
+    }
+  }
+  if (result === EMPTY) {
+    return geom2.create()
+  } else if (result) {
+    return fromOutlines(result.flat())
+  } else {
+    return null
+  }
+}
+
+/*
+ * Convert from geom2 to martinez data structure
+ */
+const toMartinez = (geometry) => {
+  const outlines = []
+  geom2.toOutlines(geometry).forEach((outline) => {
+    // Martinez expects first point == last point
+    if (vec2.equals(outline[0], outline[outline.length - 1])) {
+      outlines.push(outline)
+    } else {
+      outlines.push([...outline, outline[0]])
+    }
+  })
+  return [outlines]
+}
+
+/*
+ * Convert martinez data structure to geom2
+ */
+const fromOutlines = (outlines) => {
+  outlines.forEach((outline) => {
+    if (vec2.equals(outline[0], outline[outline.length - 1])) {
+      outline.pop() // first == last point
+    }
+  })
+  // Martinez sometime returns empty outlines, filter them out
+  outlines = outlines.filter((o) => o.length >= 3)
+  return geom2.create(outlines)
+}
+
+export const boolean = (subjectGeom, clippingGeom, operation) => {
+  // Convert from geom2 to outlines
+  const subject = toMartinez(subjectGeom)
+  const clipping = toMartinez(clippingGeom)
+
+  let trivial = trivialOperation(subject, clipping, operation)
+  if (trivial) {
+    return trivial
+  }
+  const sbbox = [Infinity, Infinity, -Infinity, -Infinity]
+  const cbbox = [Infinity, Infinity, -Infinity, -Infinity]
+
+  const eventQueue = fillQueue(subject, clipping, sbbox, cbbox, operation)
+
+  trivial = compareBBoxes(subject, clipping, sbbox, cbbox, operation)
+  if (trivial) {
+    return trivial
+  }
+  const sortedEvents = subdivideSegments(eventQueue, subject, clipping, sbbox, cbbox, operation)
+
+  const contours = connectEdges(sortedEvents, operation)
+
+  // Convert contours to geom2
+  const polygons = []
+  for (let i = 0; i < contours.length; i++) {
+    const contour = contours[i]
+    if (contour.isExterior()) {
+      // The exterior ring goes first
+      const rings = [contour.points]
+      // Followed by holes if any
+      for (let j = 0; j < contour.holeIds.length; j++) {
+        const holeId = contour.holeIds[j]
+        const holePoints = contours[holeId].points
+        const hole = []
+        for (let k = holePoints.length - 2; k >= 0; k--) {
+          hole.push(holePoints[k])
+        }
+        rings.push(hole)
+      }
+      polygons.push(rings)
+    }
+  }
+
+  if (polygons) {
+    return fromOutlines(polygons.flat())
+  } else {
+    return geom2.create()
+  }
+}

package/src/operations/booleans/martinez/operation.js

@@ -0,0 +1,4 @@
+export const INTERSECTION = 0
+export const UNION = 1
+export const DIFFERENCE = 2
+export const XOR = 3

package/src/operations/booleans/martinez/possibleIntersection.js

@@ -0,0 +1,113 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { equals } from '../../../maths/vec2/index.js'
+import { divideSegment } from './divideSegment.js'
+import { segmentIntersection } from './segmentIntersection.js'
+import { compareEvents } from './compareEvents.js'
+import {
+  NON_CONTRIBUTING,
+  SAME_TRANSITION,
+  DIFFERENT_TRANSITION
+} from './edgeType.js'
+
+/**
+ * @param {SweepEvent} se1
+ * @param {SweepEvent} se2
+ * @param {Queue} queue
+ * @return {number}
+ */
+export const possibleIntersection = (se1, se2, queue) => {
+  // that disallows self-intersecting polygons,
+  // did cost us half a day, so I'll leave it
+  // out of respect
+  // if (se1.isSubject === se2.isSubject) return
+  const inter = segmentIntersection(
+    se1.point, se1.otherEvent.point,
+    se2.point, se2.otherEvent.point
+  )
+
+  const nIntersections = inter ? inter.length : 0
+  if (nIntersections === 0) return 0 // no intersection
+
+  // the line segments intersect at an endpoint of both line segments
+  if ((nIntersections === 1) &&
+      (equals(se1.point, se2.point) ||
+       equals(se1.otherEvent.point, se2.otherEvent.point))) {
+    return 0
+  }
+
+  if (nIntersections === 2 && se1.isSubject === se2.isSubject) {
+    return 0
+  }
+
+  // The line segments associated to se1 and se2 intersect
+  if (nIntersections === 1) {
+    // if the intersection point is not an endpoint of se1
+    if (!equals(se1.point, inter[0]) && !equals(se1.otherEvent.point, inter[0])) {
+      divideSegment(se1, inter[0], queue)
+    }
+
+    // if the intersection point is not an endpoint of se2
+    if (!equals(se2.point, inter[0]) && !equals(se2.otherEvent.point, inter[0])) {
+      divideSegment(se2, inter[0], queue)
+    }
+    return 1
+  }
+
+  // The line segments associated to se1 and se2 overlap
+  const events = []
+  let leftCoincide = false
+  let rightCoincide = false
+
+  if (equals(se1.point, se2.point)) {
+    leftCoincide = true // linked
+  } else if (compareEvents(se1, se2) === 1) {
+    events.push(se2, se1)
+  } else {
+    events.push(se1, se2)
+  }
+
+  if (equals(se1.otherEvent.point, se2.otherEvent.point)) {
+    rightCoincide = true
+  } else if (compareEvents(se1.otherEvent, se2.otherEvent) === 1) {
+    events.push(se2.otherEvent, se1.otherEvent)
+  } else {
+    events.push(se1.otherEvent, se2.otherEvent)
+  }
+
+  if ((leftCoincide && rightCoincide) || leftCoincide) {
+    // both line segments are equal or share the left endpoint
+    se2.type = NON_CONTRIBUTING
+    se1.type = (se2.inOut === se1.inOut) ? SAME_TRANSITION : DIFFERENT_TRANSITION
+
+    if (leftCoincide && !rightCoincide) {
+      // honestly no idea, but changing events selection from [2, 1]
+      // to [0, 1] fixes the overlapping self-intersecting polygons issue
+      divideSegment(events[1].otherEvent, events[0].point, queue)
+    }
+    return 2
+  }
+
+  // the line segments share the right endpoint
+  if (rightCoincide) {
+    divideSegment(events[0], events[1].point, queue)
+    return 3
+  }
+
+  // no line segment includes totally the other one
+  if (events[0] !== events[3].otherEvent) {
+    divideSegment(events[0], events[1].point, queue)
+    divideSegment(events[1], events[2].point, queue)
+    return 3
+  }
+
+  // one line segment includes the other one
+  divideSegment(events[0], events[1].point, queue)
+  divideSegment(events[3].otherEvent, events[2].point, queue)
+
+  return 3
+}

package/src/operations/booleans/martinez/segmentIntersection.js

@@ -0,0 +1,132 @@
+/*
+ * Implementation of the Martinez 2D polygon clipping algorithm
+ * Copyright (c) 2018 Alexander Milevski
+ * https://github.com/w8r/martinez
+ */
+
+import { dot as dotProduct } from '../../../maths/vec2/index.js'
+
+/**
+ * Finds the magnitude of the cross product of two vectors (if we pretend
+ * they're in three dimensions)
+ *
+ * @param {object} a First vector
+ * @param {object} b Second vector
+ * @private
+ * @returns {number} The magnitude of the cross product
+ */
+const crossProduct = (a, b) => (a[0] * b[1]) - (a[1] * b[0])
+
+/**
+ * Finds the intersection (if any) between two line segments a and b, given the
+ * line segments' end points a1, a2 and b1, b2.
+ *
+ * This algorithm is based on Schneider and Eberly.
+ * http://www.cimec.org.ar/~ncalvo/Schneider_Eberly.pdf
+ * Page 244.
+ *
+ * @param {Array.<Number>} a1 point of first line
+ * @param {Array.<Number>} a2 point of first line
+ * @param {Array.<Number>} b1 point of second line
+ * @param {Array.<Number>} b2 point of second line
+ * @param {boolean=} noEndpointTouch whether to skip single touchpoints (meaning connected segments) as intersections
+ * @returns {Array.<Array.<Number>>|Null} If the lines intersect, the point of
+ * intersection. If they overlap, the two end points of the overlapping segment.
+ * Otherwise, null.
+ */
+export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
+  // The algorithm expects our lines in the form P + sd, where P is a point,
+  // s is on the interval [0, 1], and d is a vector.
+  // We are passed two points. P can be the first point of each pair. The
+  // vector, then, could be thought of as the distance (in x and y components)
+  // from the first point to the second point.
+  // So first, let's make our vectors:
+  const va = [a2[0] - a1[0], a2[1] - a1[1]]
+  const vb = [b2[0] - b1[0], b2[1] - b1[1]]
+  // We also define a function to convert back to regular point form:
+
+  const toPoint = (p, s, d) => [
+    p[0] + s * d[0],
+    p[1] + s * d[1]
+  ]
+
+  // The rest is pretty much a straight port of the algorithm.
+  const e = [b1[0] - a1[0], b1[1] - a1[1]]
+  let kross = crossProduct(va, vb)
+  let sqrKross = kross * kross
+  const sqrLenA = dotProduct(va, va)
+  // const sqrLenB  = dotProduct(vb, vb)
+
+  // Check for line intersection. This works because of the properties of the
+  // cross product -- specifically, two vectors are parallel if and only if the
+  // cross product is the 0 vector. The full calculation involves relative error
+  // to account for possible very small line segments. See Schneider & Eberly
+  // for details.
+  if (sqrKross > 0/* EPS * sqrLenB * sqLenA */) {
+    // If they're not parallel, then (because these are line segments) they
+    // still might not actually intersect. This code checks that the
+    // intersection point of the lines is actually on both line segments.
+    const s = crossProduct(e, vb) / kross
+    if (s < 0 || s > 1) {
+      // not on line segment a
+      return null
+    }
+    const t = crossProduct(e, va) / kross
+    if (t < 0 || t > 1) {
+      // not on line segment b
+      return null
+    }
+    if (s === 0 || s === 1) {
+      // on an endpoint of line segment a
+      return noEndpointTouch ? null : [toPoint(a1, s, va)]
+    }
+    if (t === 0 || t === 1) {
+      // on an endpoint of line segment b
+      return noEndpointTouch ? null : [toPoint(b1, t, vb)]
+    }
+    return [toPoint(a1, s, va)]
+  }
+
+  // If we've reached this point, then the lines are either parallel or the
+  // same, but the segments could overlap partially or fully, or not at all.
+  // So we need to find the overlap, if any. To do that, we can use e, which is
+  // the (vector) difference between the two initial points. If this is parallel
+  // with the line itself, then the two lines are the same line, and there will
+  // be overlap.
+  // const sqrLenE = dotProduct(e, e)
+  kross = crossProduct(e, va)
+  sqrKross = kross * kross
+
+  if (sqrKross > 0 /* EPS * sqLenB * sqLenE */) {
+  // Lines are just parallel, not the same. No overlap.
+    return null
+  }
+
+  const sa = dotProduct(va, e) / sqrLenA
+  const sb = sa + dotProduct(va, vb) / sqrLenA
+  const smin = Math.min(sa, sb)
+  const smax = Math.max(sa, sb)
+
+  // this is, essentially, the FindIntersection acting on floats from
+  // Schneider & Eberly, just inlined into this function.
+  if (smin <= 1 && smax >= 0) {
+    // overlap on an end point
+    if (smin === 1) {
+      return noEndpointTouch ? null : [toPoint(a1, smin > 0 ? smin : 0, va)]
+    }
+
+    if (smax === 0) {
+      return noEndpointTouch ? null : [toPoint(a1, smax < 1 ? smax : 1, va)]
+    }
+
+    if (noEndpointTouch && smin === 0 && smax === 1) return null
+
+    // There's overlap on a segment -- two points of intersection. Return both.
+    return [
+      toPoint(a1, smin > 0 ? smin : 0, va),
+      toPoint(a1, smax < 1 ? smax : 1, va)
+    ]
+  }
+
+  return null
+}

package/src/operations/booleans/martinez/signedArea.js

@@ -0,0 +1,16 @@
+
+const orient2d = (ax, ay, bx, by, cx, cy) => (ay - cy) * (bx - cx) - (ax - cx) * (by - cy)
+
+/**
+ * Signed area of the triangle (p0, p1, p2)
+ * @param {Array.<Number>} p0
+ * @param {Array.<Number>} p1
+ * @param {Array.<Number>} p2
+ * @return {number}
+ */
+export const signedArea = (p0, p1, p2) => {
+  const res = orient2d(p0[0], p0[1], p1[0], p1[1], p2[0], p2[1])
+  if (res > 0) return -1
+  if (res < 0) return 1
+  return 0
+}