@design-core/core 0.0.1 → 0.0.3

package/core/lib/intersect.js

@@ -1,6 +1,41 @@
-import {Point} from '../entities/point.js';
+import { Point } from '../entities/point.js';
+import { Constants } from './constants.js';
+import { Utils } from './utils.js';
 
+/** Intersection Class */
 export class Intersection {
+  /**
+   * Enumeration of all possible intersection status values.
+   * Use these constants instead of magic strings when comparing or setting
+   * `Intersection#status`.
+   */
+  static Status = {
+    /** The geometries do not intersect. */
+    NONE: 'None',
+    /** The geometries intersect at one or more discrete points (arc/circle/polyline aggregate). */
+    INTERSECTION: 'Intersection',
+    /** Two line segments cross in their interiors (both intersection parameters strictly inside [0,1]). */
+    CROSSING: 'Crossing',
+    /** Two line segments cross in their interiors at exactly 90°. */
+    PERPENDICULAR: 'Perpendicular',
+    /** An endpoint of one segment lies in the interior of the other segment (T-intersection). */
+    TOUCHING: 'Touching',
+    /** The segments share an endpoint exactly. */
+    ENDPOINT: 'Endpoint',
+    /** The geometries are collinear and their intervals overlap (line-line). */
+    OVERLAPPING: 'Overlapping',
+    /** The geometries are collinear / coincident (used for concentric equal-radius arcs/circles). */
+    COINCIDENT: 'Coincident',
+    /** The geometries are parallel but distinct. */
+    PARALLEL: 'Parallel',
+    /** The geometries are tangent (touch at exactly one point). */
+    TANGENT: 'Tangent',
+    /** One geometry is fully inside the other with no intersection points. */
+    INSIDE: 'Inside',
+    /** The geometries are entirely separate with one outside the other. */
+    OUTSIDE: 'Outside',
+  };
+
   /**
    * Intersection constructor
    * @param {string} status - defined status of the intersection i.e inside or outside of shape
@@ -12,26 +47,144 @@ export class Intersection {
 
   /**
    * Append point to suggested intersecting points
-   * @param {point} point
+   * @param {Point} point
    */
   appendPoint(point) {
+    // check if point already exists in the array
+    for (let i = 0; i < this.points.length; i++) {
+      if (this.points[i].isSame(point)) {
+        // point already exists - return
+        return;
+      }
+    }
+
+    // push point to points if it doesn't exist
     this.points.push(point);
   };
 
   /**
    * Append points to suggested intersecting points
-   * @param {array} points
+   * @param {Array} points
    */
   appendPoints(points) {
-    this.points = this.points.concat(points);
+    // Forward all points through appendPoint
+    points.forEach((point) => {
+      this.appendPoint(point);
+    });
   };
 
+  /**
+   * Find intersections between two polylines.
+   * Aggregates all segment-level results and collapses the status to a binary
+   * outcome: {@link Intersection.Status.NONE} or {@link Intersection.Status.INTERSECTION}.
+   * Use this method when you only need to know whether any intersection exists
+   * (e.g. selection / touch tests). For granular status detail (CROSSING, TOUCHING,
+   * ENDPOINT, OVERLAPPING, etc.) call {@link intersectSegmentSegment} directly.
+   * @param {Array} points1 - boundary points array
+   * @param {Array} points2 - selected points array
+   * @param {boolean} extend - extend the selected entity
+   * @return {Intersection}
+   */
+  static intersectPolylinePolyline(points1, points2, extend) {
+    const result = new Intersection(Intersection.Status.NONE);
+
+    for (let i = 0; i < points1.length - 1; i++) {
+      for (let j = 0; j < points2.length - 1; j++) {
+        const inter = this.intersectSegmentSegment(
+            points1[i], points1[i + 1],
+            points2[j], points2[j + 1],
+            false, extend,
+        );
+        result.appendPoints(inter.points);
+        // COINCIDENT (identical concentric circles) produces no discrete points,
+        // so it must be promoted to INTERSECTION explicitly.
+        if (inter.status === Intersection.Status.COINCIDENT) {
+          result.status = Intersection.Status.INTERSECTION;
+        }
+      }
+    }
+
+    if (result.points.length > 0) result.status = Intersection.Status.INTERSECTION;
+    return result;
+  }
+
+  /**
+   * Find intersections between two polyline segments.
+   * Returns the full granular status (CROSSING, PERPENDICULAR, TOUCHING, ENDPOINT,
+   * OVERLAPPING, TANGENT, etc.) needed by geometric operations such as trim and extend.
+   * @param {Point} b1 - segment one start point
+   * @param {Point} b2 - segment one end point
+   * @param {Point} b3 - segment two start point
+   * @param {Point} b4 - segment two end point
+   * @param {boolean} extendSegOne - extend segment one to infinite form
+   * @param {boolean} extendSegTwo - extend segment two to infinite form
+   * @return {Intersection}
+   */
+  static intersectSegmentSegment(b1, b2, b3, b4, extendSegOne, extendSegTwo) {
+    const seg1IsArc = b1.bulge !== 0 && b1.bulge !== undefined;
+    const seg2IsArc = b3.bulge !== 0 && b3.bulge !== undefined;
+
+    // line vs line
+    if (!seg1IsArc && !seg2IsArc) {
+      return this.#intersectLineLine({ start: b1, end: b2 }, { start: b3, end: b4 }, extendSegOne, extendSegTwo);
+    }
+
+    const arc1 = seg1IsArc ? this.#buildArc(b1, b2) : null;
+    const arc2 = seg2IsArc ? this.#buildArc(b3, b4) : null;
+
+    let candidatePoints;
+    let innerStatus;
+
+    if (seg1IsArc && seg2IsArc) {
+      // arc vs arc
+      const inter = this.intersectCircleCircle(arc1, arc2);
+      candidatePoints = inter.points;
+      innerStatus = inter.status;
+    } else if (seg1IsArc) {
+      // arc(seg1) vs line(seg2)
+      const inter = this.intersectCircleLine(arc1, { start: b3, end: b4 }, extendSegTwo);
+      candidatePoints = inter.points;
+      innerStatus = inter.status;
+    } else {
+      // line(seg1) vs arc(seg2)
+      const inter = this.intersectCircleLine(arc2, { start: b1, end: b2 }, extendSegOne);
+      candidatePoints = inter.points;
+      innerStatus = inter.status;
+    }
+
+    const result = new Intersection(innerStatus || Intersection.Status.NONE);
+
+    for (let i = 0; i < candidatePoints.length; i++) {
+      const pt = candidatePoints[i];
+      let valid = true;
+
+      // seg1 arc filter - skipped when extending seg1
+      if (seg1IsArc && !extendSegOne && !pt.isOnArc(arc1.startPoint, arc1.endPoint, arc1.centre, arc1.direction)) {
+        valid = false;
+      }
+
+      // seg2 arc filter - skipped when extending seg2
+      if (valid && seg2IsArc && !extendSegTwo) {
+        if (!pt.isOnArc(arc2.startPoint, arc2.endPoint, arc2.centre, arc2.direction)) {
+          valid = false;
+        }
+      }
+
+      if (valid) {
+        result.appendPoint(pt);
+      }
+    }
+
+    if (result.points.length > 0 && result.status !== Intersection.Status.TANGENT) result.status = Intersection.Status.INTERSECTION;
+    return result;
+  }
+
   /**
    * Find intersections between circle and line
-   * @param {circle} circle
-   * @param {line} line
+   * @param {Circle} circle
+   * @param {Line} line
    * @param {boolean} extend - extend the line as a ray
-   * @returns
+   * @return {Intersect}
    */
   static intersectCircleLine(circle, line, extend) {
     const c = circle.centre;
@@ -42,47 +195,49 @@ export class Intersection {
 
 
     let result;
-    const a = (a2.x - a1.x) * (a2.x - a1.x) +
-            (a2.y - a1.y) * (a2.y - a1.y);
-    const b = 2 * ((a2.x - a1.x) * (a1.x - c.x) +
-            (a2.y - a1.y) * (a1.y - c.y));
-    const cc = c.x * c.x + c.y * c.y + a1.x * a1.x + a1.y * a1.y -
-            2 * (c.x * a1.x + c.y * a1.y) - r * r;
-    const deter = b * b - 4 * a * cc;
-
-    if (deter < 0) {
-      result = new Intersection('Outside');
-    } else if (deter == 0) {
-      result = new Intersection('Tangent');
-      // NOTE: should calculate this point
+    const lineDir = a2.subtract(a1); // direction vector of the line segment
+    const centreToStart = a1.subtract(c); // vector from circle centre to line start
+    const quadA = lineDir.dot(lineDir); // squared length of the line segment
+    const quadB = 2 * lineDir.dot(centreToStart); // linear coefficient (projection term)
+    const quadC = centreToStart.dot(centreToStart) - r * r; // constant coefficient (signed distance²)
+    const discriminant = quadB * quadB - 4 * quadA * quadC;
+
+    if (discriminant < 0) {
+      result = new Intersection(Intersection.Status.OUTSIDE);
+    } else if (discriminant === 0) {
+      result = new Intersection(Intersection.Status.TANGENT);
+      const u = -quadB / (2 * quadA);
+      if (0 <= u && u <= 1 || extend) {
+        result.appendPoint(a1.lerp(a2, u));
+      }
     } else {
-      const e = Math.sqrt(deter);
-      const u1 = (-b + e) / (2 * a);
-      const u2 = (-b - e) / (2 * a);
+      const sqrtDiscriminant = Math.sqrt(discriminant); // square root of discriminant — half-spread between the two roots
+      const lineParam1 = (-quadB + sqrtDiscriminant) / (2 * quadA); // parametric t for first intersection (0 = line start, 1 = line end)
+      const lineParam2 = (-quadB - sqrtDiscriminant) / (2 * quadA); // parametric t for second intersection (0 = line start, 1 = line end)
 
-      if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
-        if ((u1 < 0 && u2 < 0) || (u1 > 1 && u2 > 1)) {
-          result = new Intersection('Outside');
+      if ((lineParam1 < 0 || lineParam1 > 1) && (lineParam2 < 0 || lineParam2 > 1)) {
+        if ((lineParam1 < 0 && lineParam2 < 0) || (lineParam1 > 1 && lineParam2 > 1)) {
+          result = new Intersection(Intersection.Status.OUTSIDE);
           if (extend) {
-            result.points.push(a1.lerp(a2, u1));
-            result.points.push(a1.lerp(a2, u2));
+            result.appendPoint(a1.lerp(a2, lineParam1));
+            result.appendPoint(a1.lerp(a2, lineParam2));
           }
         } else {
-          result = new Intersection('Inside');
+          result = new Intersection(Intersection.Status.INSIDE);
           if (extend) {
-            result.points.push(a1.lerp(a2, u1));
-            result.points.push(a1.lerp(a2, u2));
+            result.appendPoint(a1.lerp(a2, lineParam1));
+            result.appendPoint(a1.lerp(a2, lineParam2));
           }
         }
       } else {
-        result = new Intersection('Intersection');
+        result = new Intersection(Intersection.Status.INTERSECTION);
 
-        if (0 <= u1 && u1 <= 1 || extend) {
-          result.points.push(a1.lerp(a2, u1));
+        if (0 <= lineParam1 && lineParam1 <= 1 || extend) {
+          result.appendPoint(a1.lerp(a2, lineParam1));
         }
 
-        if (0 <= u2 && u2 <= 1 || extend) {
-          result.points.push(a1.lerp(a2, u2));
+        if (0 <= lineParam2 && lineParam2 <= 1 || extend) {
+          result.appendPoint(a1.lerp(a2, lineParam2));
         }
       }
     }
@@ -90,23 +245,12 @@ export class Intersection {
     return result;
   };
 
-  /**
-   * Find intersections between circle and line
-   * @param {line} line
-   * @param {circle} circle
-   * @param {boolean} extend - extend the line as a ray
-   * @returns
-   */
-  static intersectLineCircle(line, circle, extend) {
-    return this.intersectCircleLine(circle, line, extend);
-  }
-
   /**
    * Find intersections between two circles
-   * @param {circle} circle1
-   * @param {circle} circle2
+   * @param {Circle} circle1
+   * @param {Circle} circle2
    * @param {boolean} extend  - unused
-   * @returns
+   * @return {Intersect}
    */
   static intersectCircleCircle(circle1, circle2, extend) {
     const c1 = circle1.centre;
@@ -122,457 +266,186 @@ export class Intersection {
     // Determine actual distance between circle circles
     const cDist = c1.distance(c2);
 
-    if (cDist > rMax) {
-      result = new Intersection('Outside');
+    if (cDist === 0) {
+      result = new Intersection(r1 === r2 ? Intersection.Status.COINCIDENT : Intersection.Status.INSIDE);
+    } else if (cDist > rMax) {
+      result = new Intersection(Intersection.Status.OUTSIDE);
     } else if (cDist < rMin) {
-      result = new Intersection('Inside');
+      result = new Intersection(Intersection.Status.INSIDE);
     } else {
-      result = new Intersection('Intersection');
-
-      const a = (r1 * r1 - r2 * r2 + cDist * cDist) / (2 * cDist);
-      const h = Math.sqrt(r1 * r1 - a * a);
-      const p = c1.lerp(c2, a / cDist);
-      const b = h / cDist;
-
-      result.points.push(
-          new Point(
-              p.x - b * (c2.y - c1.y),
-              p.y + b * (c2.x - c1.x),
-          ),
-      );
-      result.points.push(
-          new Point(
-              p.x + b * (c2.y - c1.y),
-              p.y - b * (c2.x - c1.x),
-          ),
-      );
+      result = new Intersection(Intersection.Status.INTERSECTION);
+
+      // Distance from c1 to the radical axis along the line of centres
+      const axialDist = (r1 * r1 - r2 * r2 + cDist * cDist) / (2 * cDist);
+      // Half the length of the chord connecting the two intersection points
+      const halfChordLength = Math.sqrt(r1 * r1 - axialDist * axialDist);
+      // Point on the line of centres where the perpendicular bisector of the chord passes through
+      const chordMidpoint = c1.lerp(c2, axialDist / cDist);
+      // Normalised scale factor for the perpendicular offset
+      const perpScale = halfChordLength / cDist;
+      // Perpendicular offset vector from chordMidpoint to each intersection point
+      const perpOffset = new Point(-(c2.y - c1.y), c2.x - c1.x).scale(perpScale);
+
+      result.appendPoint(chordMidpoint.add(perpOffset));
+      result.appendPoint(chordMidpoint.subtract(perpOffset));
     }
 
     return result;
   };
 
   /**
-   * Find intersections between arc segment and rectangle
-   * @param {arc} arc
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
+   * Build arc object from two polyline points
+   * @param {Point} b1 - start point with bulge
+   * @param {Point} b2 - end point
+   * @return {Object} arc with centre, startPoint, endPoint, radius, direction
    */
-  static intersectArcRectangle(arc, rectangle, extend) {
-    const r1 = rectangle.start;
-    const r2 = rectangle.end;
-
-    const min = r1.min(r2);
-    const max = r1.max(r2);
-    const topRight = new Point(max.x, min.y);
-    const bottomLeft = new Point(min.x, max.y);
-
-
-    let rectPoints = {start: min, end: topRight};
-    const inter1 = this.intersectArcLine(arc, rectPoints, extend);
-
-    rectPoints = {start: topRight, end: max};
-    const inter2 = this.intersectArcLine(arc, rectPoints, extend);
-
-    rectPoints = {start: max, end: bottomLeft};
-    const inter3 = this.intersectArcLine(arc, rectPoints, extend);
-
-    rectPoints = {start: bottomLeft, end: min};
-    const inter4 = this.intersectArcLine(arc, rectPoints, extend);
-
-    const result = new Intersection('No Intersection');
-
-    result.appendPoints(inter1.points);
-    result.appendPoints(inter2.points);
-    result.appendPoints(inter3.points);
-    result.appendPoints(inter4.points);
-
-    if (result.points.length > 0) {
-      result.status = 'Intersection';
-    } else {
-      result.status = inter1.status;
-    }
-
-    return result;
-  }
-
-  /**
-   * Find intersections between arc segment and line
-   * @param {arc} arc
-   * @param {line} line
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectArcLine(arc, line, extend) {
-    const inter1 = this.intersectCircleLine(arc, line, extend);
-    const result = new Intersection('No Intersection');
-
-    if (!extend) {
-      for (let i = 0; i < inter1.points.length; i++) {
-        if (inter1.points[i].isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction)) {
-          result.appendPoints(inter1.points[i]);
-        }
-      }
-
-      if (result.points.length > 0) {
-        result.status = 'Intersection';
-      }
-    }
-
-    return result;
+  static #buildArc(b1, b2) {
+    const arc = {};
+    arc.centre = b1.bulgeCentrePoint(b2);
+    arc.startPoint = b1;
+    arc.endPoint = b2;
+    arc.radius = arc.centre.distance(b1);
+    arc.direction = b1.bulge;
+    return arc;
   }
 
   /**
-   * Find intersections between line and arc segment
-   * @param {line} line
-   * @param {arc} arc
-   * @param {boolean} extend
-   * @returns
+   * Find intersections between two lines
+   * @param {Line} line1
+   * @param {Line} line2
+   * @param {boolean} extendSegOne
+   * @param {boolean} extendSegTwo
+   * @return {Intersection}
    */
-  static intersectLineArc(line, arc, extend) {
-    return this.intersectArcLine(arc, line, extend);
-  }
+  static #intersectLineLine(line1, line2, extendSegOne, extendSegTwo) {
+    const aStart = line1.start;
+    const aEnd = line1.end;
+    const bStart = line2.start;
+    const bEnd = line2.end;
+    extendSegOne = extendSegOne || false;
+    extendSegTwo = extendSegTwo || false;
 
-  /**
-   * Find intersections between circle and arc segment
-   * @param {circle} circle
-   * @param {arc} arc
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectCircleArc(circle, arc, extend) {
-    const inter1 = this.intersectCircleCircle(circle, arc, extend);
-    const result = new Intersection('No Intersection');
-
-    if (!extend) {
-      for (let i = 0; i < inter1.points.length; i++) {
-        if (inter1.points[i].isOnArc(arc.startPoint, arc.endPoint, arc.centre, arc.direction)) {
-          result.points.push(inter1.points[i]);
-        }
-      }
+    let result;
 
-      if (result.points.length > 0) {
-        result.status = 'Intersection';
-      }
+    // Check if any endpoints are coincident
+    if (aStart.isSame(bStart)) {
+      result = new Intersection(Intersection.Status.ENDPOINT);
+      result.appendPoint(new Point(aStart.x, aStart.y));
+      return result;
     }
 
-    return result;
-  }
-
-  /**
-   * Find intersections between
-   * @param {arc} arc
-   * @param {circle} circle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectArcCircle(arc, circle, extend) {
-    return this.intersectCircleArc(circle, arc, extend);
-  }
-
-  /**
-   * Find intersections between circle and rectangle
-   * @param {circle} circle
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectCircleRectangle(circle, rectangle, extend) {
-    const r1 = rectangle.start;
-    const r2 = rectangle.end;
-    extend = extend || false;
-
-    const min = r1.min(r2);
-    const max = r1.max(r2);
-    const topRight = new Point(max.x, min.y);
-    const bottomLeft = new Point(min.x, max.y);
-
-    let rectPoints = {start: min, end: topRight};
-    const inter1 = this.intersectCircleLine(circle, rectPoints);
-
-    rectPoints = {start: topRight, end: max};
-    const inter2 = this.intersectCircleLine(circle, rectPoints);
-
-    rectPoints = {start: max, end: bottomLeft};
-    const inter3 = this.intersectCircleLine(circle, rectPoints);
+    if (aStart.isSame(bEnd)) {
+      result = new Intersection(Intersection.Status.ENDPOINT);
+      result.appendPoint(new Point(aStart.x, aStart.y));
+      return result;
+    }
 
-    rectPoints = {start: bottomLeft, end: min};
-    const inter4 = this.intersectCircleLine(circle, rectPoints);
+    if (aEnd.isSame(bStart)) {
+      result = new Intersection(Intersection.Status.ENDPOINT);
+      result.appendPoint(new Point(aEnd.x, aEnd.y));
+      return result;
+    }
 
-    const result = new Intersection('No Intersection');
+    if (aEnd.isSame(bEnd)) {
+      result = new Intersection(Intersection.Status.ENDPOINT);
+      result.appendPoint(new Point(aEnd.x, aEnd.y));
+      return result;
+    }
 
-    result.appendPoints(inter1.points);
-    result.appendPoints(inter2.points);
-    result.appendPoints(inter3.points);
-    result.appendPoints(inter4.points);
+    // Check if any endpoints of one line are on the other line
+    if (aStart.isOnLine(bStart, bEnd)) {
+      result = new Intersection(Intersection.Status.TOUCHING);
+      result.appendPoint(new Point(aStart.x, aStart.y));
+      return result;
+    }
 
-    if (result.points.length > 0) {
-      result.status = 'Intersection';
-    } else {
-      result.status = inter1.status;
+    if (aEnd.isOnLine(bStart, bEnd)) {
+      result = new Intersection(Intersection.Status.TOUCHING);
+      result.appendPoint(new Point(aEnd.x, aEnd.y));
+      return result;
     }
 
-    return result;
-  };
+    if (bStart.isOnLine(aStart, aEnd)) {
+      result = new Intersection(Intersection.Status.TOUCHING);
+      result.appendPoint(new Point(bStart.x, bStart.y));
+      return result;
+    }
 
-  /**
-   * Find intersections between two lines
-   * @param {line} line1
-   * @param {line} line2
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectLineLine(line1, line2, extend) {
-    const a1 = line1.start;
-    const a2 = line1.end;
-    const b1 = line2.start;
-    const b2 = line2.end;
-    extend = extend || false;
+    if (bEnd.isOnLine(aStart, aEnd)) {
+      result = new Intersection(Intersection.Status.TOUCHING);
+      result.appendPoint(new Point(bEnd.x, bEnd.y));
+      return result;
+    }
 
-    let result;
+    // Guard against zero-length (degenerate) segments.
+    // Endpoint and touching cases were already handled above; anything remaining
+    // means the point simply does not lie on the other segment.
+    if (aStart.isSame(aEnd) || bStart.isSame(bEnd)) {
+      return new Intersection(Intersection.Status.NONE);
+    }
 
-    const uaT = (b2.x - b1.x) * (a1.y - b1.y) - (b2.y - b1.y) * (a1.x - b1.x);
-    const ubT = (a2.x - a1.x) * (a1.y - b1.y) - (a2.y - a1.y) * (a1.x - b1.x);
-    const uB = (b2.y - b1.y) * (a2.x - a1.x) - (b2.x - b1.x) * (a2.y - a1.y);
-
-    if (uB != 0) {
-      const ua = uaT / uB;
-      const ub = ubT / uB;
-
-      if ((0 <= ua && ua <= 1) && (0 <= ub && ub <= 1) || (0 <= ua && ua <= 1) && extend) {
-        result = new Intersection('Intersection');
-        result.points.push(
-            new Point(
-                a1.x + ua * (a2.x - a1.x),
-                a1.y + ua * (a2.y - a1.y),
-            ),
-        );
+    // Direction vectors and offset between start points
+    const line1Dir = aEnd.subtract(aStart);
+    const line2Dir = bEnd.subtract(bStart);
+    const startDiff = aStart.subtract(bStart);
+
+    // Normalise the cross product to |sin(angle)| so the tolerance is scale-independent
+    const directionCross = line1Dir.cross(line2Dir);
+    const line1Len = line1Dir.length();
+    const line2Len = line2Dir.length();
+    const isParallel = Math.abs(directionCross) / (line1Len * line2Len) < Constants.Tolerance.EPSILON;
+
+    if (!isParallel) {
+      // Lines are not parallel
+      // lerp parameters: 0 = segment start, 1 = segment end
+      const line1Lerp = line2Dir.cross(startDiff) / directionCross;
+      const line2Lerp = line1Dir.cross(startDiff) / directionCross;
+
+      // If both lerp values are between 0 and 1, the intersection is within the line segments
+      const line1InRange = 0 <= line1Lerp && line1Lerp <= 1;
+      const line2InRange = 0 <= line2Lerp && line2Lerp <= 1;
+      const isWithinSegments = line1InRange && line2InRange;
+      const isExtended = (line1InRange || extendSegOne) && (line2InRange || extendSegTwo);
+
+      if (isWithinSegments || isExtended) {
+        const isPerpendicular = Utils.round(line1Dir.dot(line2Dir)) === 0;
+        result = new Intersection(isPerpendicular ? Intersection.Status.PERPENDICULAR : Intersection.Status.CROSSING);
+        result.appendPoint(aStart.lerp(aEnd, line1Lerp));
       } else {
-        result = new Intersection('No Intersection');
+        result = new Intersection(Intersection.Status.NONE);
       }
     } else {
-      if (uaT == 0 || ubT == 0) {
-        result = new Intersection('Coincident');
-      } else {
-        result = new Intersection('Parallel');
-      }
-    }
-
-    return result;
-  };
-
-  /**
-   * Find intersections between lwpolyline and line
-   * @param {polyline} polyline
-   * @param {line} line
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectLwpolylineLine(polyline, line, extend) {
-    return this.intersectPolylineLine(polyline, line, extend);
-  }
-
-  /**
-   * Find intersections between polyline and line
-   * @param {polyline} polyline
-   * @param {line} line
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectPolylineLine(polyline, line, extend) {
-    const result = new Intersection('No Intersection');
-    const length = polyline.points.length;
-
-    for (let i = 0; i < length - 1; i++) {
-      const b1 = polyline.points[i];
-      const b2 = polyline.points[(i + 1) % length];
-
-
-      if (b1.bulge === 0) {
-        const line2 = {start: b1, end: b2};
-        const inter = this.intersectLineLine(line2, line, extend);
-        result.appendPoints(inter.points);
+      // Lines are parallel or coincident
+      const startDiffLen = startDiff.length();
+      const isCollinear = startDiffLen < Constants.Tolerance.EPSILON ||
+          Math.abs(line2Dir.cross(startDiff)) / (line2Len * startDiffLen) < Constants.Tolerance.EPSILON;
+      if (isCollinear) {
+        // Lines are collinear — check whether the segments actually overlap
+        // Project all four endpoints onto the shared direction axis
+        const len2 = line1Dir.x * line1Dir.x + line1Dir.y * line1Dir.y;
+        const t0 = 0; // aStart projects to 0
+        const t1 = 1; // aEnd projects to 1 (parametric)
+        const t2 = (bStart.subtract(aStart).x * line1Dir.x + bStart.subtract(aStart).y * line1Dir.y) / len2;
+        const t3 = (bEnd.subtract(aStart).x * line1Dir.x + bEnd.subtract(aStart).y * line1Dir.y) / len2;
+
+        const bMin = Math.min(t2, t3);
+        const bMax = Math.max(t2, t3);
+
+        if (bMax < t0 || bMin > t1) {
+          // Segments are collinear but disjoint
+          result = new Intersection(Intersection.Status.NONE);
+        } else {
+          // Segments overlap — return the two endpoints of the shared interval
+          result = new Intersection(Intersection.Status.OVERLAPPING);
+          result.appendPoint(aStart.lerp(aEnd, Math.max(t0, bMin)));
+          result.appendPoint(aStart.lerp(aEnd, Math.min(t1, bMax)));
+        }
       } else {
-        const arc = {};
-        arc.centre = b1.bulgeCentrePoint(b2);
-        arc.startPoint = b1;
-        arc.endPoint = b2;
-        arc.radius = arc.centre.distance(b1);
-        arc.direction = b1.bulge;
-
-        const interArc = this.intersectArcLine(arc, line, extend);
-        result.appendPoints(interArc.points);
+        // Lines are parallel but not coincident
+        result = new Intersection(Intersection.Status.PARALLEL);
       }
     }
 
-    if (result.points.length > 0) result.status = 'Intersection';
-    return result;
-  };
-
-  /**
-   * Find intersections between lwpolyline and rectangle
-   * @param {polyline} polyline
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectLwpolylineRectangle(polyline, rectangle, extend) {
-    return this.intersectPolylineRectangle(polyline, rectangle, extend);
-  }
-
-  /**
-   * Find intersections between polyline and rectangle
-   * @param {polyline} polyline
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectPolylineRectangle(polyline, rectangle, extend) {
-    const r1 = rectangle.start;
-    const r2 = rectangle.end;
-    extend = extend || false;
-
-    const min = r1.min(r2);
-    const max = r1.max(r2);
-    const topRight = new Point(max.x, min.y);
-    const bottomLeft = new Point(min.x, max.y);
-
-    let rectPoints = {start: min, end: topRight};
-    const inter1 = this.intersectPolylineLine(polyline, rectPoints, extend);
-
-    rectPoints = {start: topRight, end: max};
-    const inter2 = this.intersectPolylineLine(polyline, rectPoints, extend);
-
-    rectPoints = {start: max, end: bottomLeft};
-    const inter3 = this.intersectPolylineLine(polyline, rectPoints, extend);
-
-    rectPoints = {start: bottomLeft, end: min};
-    const inter4 = this.intersectPolylineLine(polyline, rectPoints, extend);
-
-    const result = new Intersection('No Intersection');
-
-    result.appendPoints(inter1.points);
-    result.appendPoints(inter2.points);
-    result.appendPoints(inter3.points);
-    result.appendPoints(inter4.points);
-
-    if (result.points.length > 0) {
-      result.status = 'Intersection';
-    }
-
-    return result;
-  };
-
-
-  /**
-   * Find intersections between line and rectangle
-   * @param {line} line
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectLineRectangle(line, rectangle, extend) {
-    const r1 = rectangle.start;
-    const r2 = rectangle.end;
-    extend = extend || false;
-
-    const min = r1.min(r2);
-    const max = r1.max(r2);
-    const topRight = new Point(max.x, min.y);
-    const bottomLeft = new Point(min.x, max.y);
-
-    let rectPoints = {start: min, end: topRight};
-    const inter1 = this.intersectLineLine(rectPoints, line, extend);
-
-    rectPoints = {start: topRight, end: max};
-    const inter2 = this.intersectLineLine(rectPoints, line, extend);
-
-    rectPoints = {start: max, end: bottomLeft};
-    const inter3 = this.intersectLineLine(rectPoints, line, extend);
-
-    rectPoints = {start: bottomLeft, end: min};
-    const inter4 = this.intersectLineLine(rectPoints, line, extend);
-
-    const result = new Intersection('No Intersection');
-
-    result.appendPoints(inter1.points);
-    result.appendPoints(inter2.points);
-    result.appendPoints(inter3.points);
-    result.appendPoints(inter4.points);
-
-    if (result.points.length > 0) {
-      result.status = 'Intersection';
-    }
-
-    return result;
-  };
-
-  /**
-   * Find intersections between rectangle and line
-   * @param {rectangle} rectangle
-   * @param {line} line
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectRectangleLine(rectangle, line, extend) {
-    return this.intersectLineRectangle(line, rectangle, extend);
-  }
-
-  /**
-   * Find intersections between text and rectangles
-   * Text is represented by its bounding box
-   * @param {text} text
-   * @param {rectangle} rectangle
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectTextRectangle(text, rectangle, extend) {
-    return this.intersectRectangleRectangle(text, rectangle, extend);
-  }
-
-  /**
-   * Find intersections between two rectangles
-   * @param {rectangle} rectangle1
-   * @param {rectangle} rectangle2
-   * @param {boolean} extend
-   * @returns
-   */
-  static intersectRectangleRectangle(rectangle1, rectangle2, extend) {
-    const a1 = rectangle1.start;
-    const a2 = rectangle1.end;
-    // const b1 = rectangle2.start;
-    // const b2 = rectangle2.end;
-    extend = extend || false;
-
-
-    const min = a1.min(a2);
-    const max = a1.max(a2);
-    const topRight = new Point(max.x, min.y);
-    const bottomLeft = new Point(min.x, max.y);
-
-    let rectPoints = {start: min, end: topRight};
-    const inter1 = this.intersectLineRectangle(rectPoints, rectangle2);
-
-    rectPoints = {start: topRight, end: max};
-    const inter2 = this.intersectLineRectangle(rectPoints, rectangle2);
-
-    rectPoints = {start: max, end: bottomLeft};
-    const inter3 = this.intersectLineRectangle(rectPoints, rectangle2);
-
-    rectPoints = {start: bottomLeft, end: min};
-    const inter4 = this.intersectLineRectangle(rectPoints, rectangle2);
-
-    const result = new Intersection('No Intersection');
-
-    result.appendPoints(inter1.points);
-    result.appendPoints(inter2.points);
-    result.appendPoints(inter3.points);
-    result.appendPoints(inter4.points);
-
-    if (result.points.length > 0) {
-      result.status = 'Intersection';
-    }
-
     return result;
   };
 }