checkIntersection method

EventNode checkIntersection(EventNode ev1, EventNode ev2)

Implementation

EventNode checkIntersection(EventNode ev1, EventNode ev2) {
  // returns the segment equal to ev1, or false if nothing equal

  var seg1 = ev1.seg;
  var seg2 = ev2.seg;
  var a1 = seg1.start;
  var a2 = seg1.end;
  var b1 = seg2.start;
  var b2 = seg2.end;

  // if (buildLog != null) buildLog.checkIntersection(seg1, seg2);

  Intersection intersect;
  Map<bool, Intersection> result =
      Epsilon().linesIntersectAsMap(a1, a2, b1, b2);
  intersect = result.values.first;
  bool resultX = result.keys.first;

  if (!resultX) {
    // segments are parallel or coincident

    // if points aren't collinear, then the segments are parallel, so no intersections
    if (!Epsilon().pointsCollinear(a1, a2, b1)) return null;

    // otherwise, segments are on top of each other somehow (aka coincident)

    if (Epsilon().pointsSame(a1, b2) || Epsilon().pointsSame(a2, b1))
      return null; // segments touch at endpoints... no intersection

    var a1_equ_b1 = Epsilon().pointsSame(a1, b1);
    var a2_equ_b2 = Epsilon().pointsSame(a2, b2);

    if (a1_equ_b1 && a2_equ_b2) return ev2; // segments are exactly equal

    var a1_between = !a1_equ_b1 && Epsilon().pointBetween(a1, b1, b2);
    var a2_between = !a2_equ_b2 && Epsilon().pointBetween(a2, b1, b2);

    // handy for debugging:
    // buildLog.log({
    //	a1_equ_b1: a1_equ_b1,
    //	a2_equ_b2: a2_equ_b2,
    //	a1_between: a1_between,
    //	a2_between: a2_between
    // });

    if (a1_equ_b1) {
      if (a2_between) {
        //  (a1)---(a2)
        //  (b1)----------(b2)
        eventDivide(ev2, a2);
      } else {
        //  (a1)----------(a2)
        //  (b1)---(b2)
        eventDivide(ev1, b2);
      }

      return ev2;
    } else if (a1_between) {
      if (!a2_equ_b2) {
        // make a2 equal to b2
        if (a2_between) {
          //         (a1)---(a2)
          //  (b1)-----------------(b2)
          eventDivide(ev2, a2);
        } else {
          //         (a1)----------(a2)
          //  (b1)----------(b2)
          eventDivide(ev1, b2);
        }
      }

      //         (a1)---(a2)
      //  (b1)----------(b2)
      eventDivide(ev2, a1);
    }
  } else {
    // otherwise, lines intersect at i.pt, which may or may not be between the endpoints

    // is A divided between its endpoints? (exclusive)
    if (intersect.alongA == 0) {
      if (intersect.alongB == -1) // yes, at exactly b1
        eventDivide(ev1, b1);
      else if (intersect.alongB == 0) // yes, somewhere between B's endpoints
        eventDivide(ev1, intersect.pt);
      else if (intersect.alongB == 1) // yes, at exactly b2
        eventDivide(ev1, b2);
    }

    // is B divided between its endpoints? (exclusive)
    if (intersect.alongB == 0) {
      if (intersect.alongA == -1) // yes, at exactly a1
        eventDivide(ev2, a1);
      else if (intersect.alongA ==
          0) // yes, somewhere between A's endpoints (exclusive)
        eventDivide(ev2, intersect.pt);
      else if (intersect.alongA == 1) // yes, at exactly a2
        eventDivide(ev2, a2);
    }
  }

  return null;
}