@jscad/modeling 2.12.5 → 3.0.1-alpha.0

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
+}