@jscad/modeling 3.0.1-alpha.0 → 3.0.3-alpha.0

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

@@ -15,36 +15,40 @@ import {
 } from './edgeType.js'
 
 /**
+ * and split the segments if an intersection is detected.
  * @param {SweepEvent} se1
  * @param {SweepEvent} se2
  * @param {Queue} queue
- * @return {number}
+ * @return
+ *   0=no intersection
+ *   1=intersect point
+ *   2=overlap, left points cooinciding
+ *   3=overlap, right points cooinciding
+ *   4=segments overlap
+ *   5=segment within segment
  */
 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
+  // null = no intersection
+  // array[1] = point of intersection
+  // array[2] = line overlaps, segment of overlap, i.e. two points
   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
+  // no intersection of segments
+  if (nIntersections === 0) return 0
+
+  // single point of intersection, check the end points
   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
+  // single point of intersection, divide the segments
   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])) {
@@ -58,56 +62,63 @@ export const possibleIntersection = (se1, se2, queue) => {
     return 1
   }
 
-  // The line segments associated to se1 and se2 overlap
-  const events = []
+  // segments overlap, check for same subject/clipping
+  if (nIntersections === 2 && se1.isSubject === se2.isSubject) {
+    return 0
+  }
+
+  // segments overlap, determine the overlap, and divide segments
+  // FIXME eliminate this stack
+  const segmentEvents = []
   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)
+    segmentEvents.push(se2, se1)
   } else {
-    events.push(se1, se2)
+    segmentEvents.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)
+    segmentEvents.push(se2.otherEvent, se1.otherEvent)
   } else {
-    events.push(se1.otherEvent, se2.otherEvent)
+    segmentEvents.push(se1.otherEvent, se2.otherEvent)
   }
 
-  if ((leftCoincide && rightCoincide) || leftCoincide) {
+  if (leftCoincide) {
     // both line segments are equal or share the left endpoint
+    // FIXME: this setting of type should be done outside this function
     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]
+    if (!rightCoincide) {
+      // honestly no idea, but changing segmentEvents selection from [2, 1]
       // to [0, 1] fixes the overlapping self-intersecting polygons issue
-      divideSegment(events[1].otherEvent, events[0].point, queue)
+      divideSegment(segmentEvents[1].otherEvent, segmentEvents[0].point, queue)
     }
     return 2
   }
 
   // the line segments share the right endpoint
   if (rightCoincide) {
-    divideSegment(events[0], events[1].point, queue)
+    divideSegment(segmentEvents[0], segmentEvents[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
+  if (segmentEvents[0] !== segmentEvents[3].otherEvent) {
+    divideSegment(segmentEvents[0], segmentEvents[1].point, queue)
+    divideSegment(segmentEvents[1], segmentEvents[2].point, queue)
+    return 4
   }
 
   // one line segment includes the other one
-  divideSegment(events[0], events[1].point, queue)
-  divideSegment(events[3].otherEvent, events[2].point, queue)
+  divideSegment(segmentEvents[0], segmentEvents[1].point, queue)
+  divideSegment(segmentEvents[3].otherEvent, segmentEvents[2].point, queue)
 
-  return 3
+  return 5
 }

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

@@ -34,7 +34,7 @@ const crossProduct = (a, b) => (a[0] * b[1]) - (a[1] * b[0])
  * intersection. If they overlap, the two end points of the overlapping segment.
  * Otherwise, null.
  */
-export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
+export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch = false) => {
   // 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
@@ -51,11 +51,9 @@ export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
   ]
 
   // The rest is pretty much a straight port of the algorithm.
-  const e = [b1[0] - a1[0], b1[1] - a1[1]]
+  const v1 = [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
@@ -66,12 +64,12 @@ export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
     // 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
+    const s = crossProduct(v1, vb) / kross
     if (s < 0 || s > 1) {
       // not on line segment a
       return null
     }
-    const t = crossProduct(e, va) / kross
+    const t = crossProduct(v1, va) / kross
     if (t < 0 || t > 1) {
       // not on line segment b
       return null
@@ -93,8 +91,7 @@ export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
   // 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)
+  kross = crossProduct(v1, va)
   sqrKross = kross * kross
 
   if (sqrKross > 0 /* EPS * sqLenB * sqLenE */) {
@@ -102,7 +99,8 @@ export const segmentIntersection = (a1, a2, b1, b2, noEndpointTouch) => {
     return null
   }
 
-  const sa = dotProduct(va, e) / sqrLenA
+  const sqrLenA = dotProduct(va, va)
+  const sa = dotProduct(va, v1) / sqrLenA
   const sb = sa + dotProduct(va, vb) / sqrLenA
   const smin = Math.min(sa, sb)
   const smax = Math.max(sa, sb)