fix: add more edge cases

saahil-mahato · saahil-mahato · commit c2f9b32949cb · 2024-10-02T11:49:51.000+05:45
diff --git a/Geometry/PlaneSweep.js b/Geometry/PlaneSweep.js
@@ -42,7 +42,7 @@ export default class PlaneSweep {
       !segments.every((seg) => seg.start && seg.end)
     ) {
       throw new Error(
-        'segments must be a non-empty array of objects with both start and end properties.'
+        'segments must be a non-empty array of objects with start and end properties.'
       )
     }
   }
@@ -79,22 +79,35 @@ export default class PlaneSweep {
     })
   }
 
-  /**
-   * Checks if two line segments intersect.
-   * @private
-   * @param {{start: {x: number, y: number}, end: {x: number, y: number}}} seg1 - The first segment.
-   * @param {{start: {x: number, y: number}, end: {x: number, y: number}}} seg2 - The second segment.
-   * @returns {boolean} True if the segments intersect, otherwise false.
-   */
   #doSegmentsIntersect(seg1, seg2) {
-    const ccw = (A, B, C) =>
-      (C.y - A.y) * (B.x - A.x) > (B.y - A.y) * (C.x - A.x)
-    return (
-      ccw(seg1.start, seg2.start, seg2.end) !==
-        ccw(seg1.end, seg2.start, seg2.end) &&
-      ccw(seg1.start, seg1.end, seg2.start) !==
-        ccw(seg1.start, seg1.end, seg2.end)
-    )
+    const ccw = (A, B, C) => {
+      const val = (C.y - A.y) * (B.x - A.x) - (B.y - A.y) * (C.x - A.x)
+      if (Math.abs(val) < Number.EPSILON) return 0 // Collinear
+      return val > 0 ? 1 : -1 // Clockwise or counterclockwise
+    }
+
+    const onSegment = (p, q, r) => {
+      return (
+        q.x <= Math.max(p.x, r.x) &&
+        q.x >= Math.min(p.x, r.x) &&
+        q.y <= Math.max(p.y, r.y) &&
+        q.y >= Math.min(p.y, r.y)
+      )
+    }
+
+    const o1 = ccw(seg1.start, seg1.end, seg2.start)
+    const o2 = ccw(seg1.start, seg1.end, seg2.end)
+    const o3 = ccw(seg2.start, seg2.end, seg1.start)
+    const o4 = ccw(seg2.start, seg2.end, seg1.end)
+
+    // General case of intersection
+    if (o1 !== o2 && o3 !== o4) return true
+
+    // Special cases: collinear segments that may touch
+    if (o1 === 0 && onSegment(seg1.start, seg2.start, seg1.end)) return true
+    if (o2 === 0 && onSegment(seg1.start, seg2.end, seg1.end)) return true
+    if (o3 === 0 && onSegment(seg2.start, seg1.start, seg2.end)) return true
+    return o4 === 0 && onSegment(seg2.start, seg1.end, seg2.end)
   }
 
   /**
diff --git a/Geometry/Test/PlaneSweep.test.js b/Geometry/Test/PlaneSweep.test.js
@@ -1,115 +1,158 @@
 import PlaneSweep from '../PlaneSweep'
 
 describe('PlaneSweep', () => {
-  describe('Constructor', () => {
-    test('creates an instance with valid segments', () => {
+  let planeSweep
+
+  describe('constructor', () => {
+    it('should create an instance with valid segments', () => {
       const segments = [
-        { start: { x: 1, y: 1 }, end: { x: 4, y: 4 } },
-        { start: { x: 1, y: 4 }, end: { x: 4, y: 1 } }
+        { start: { x: 0, y: 0 }, end: { x: 1, y: 1 } },
+        { start: { x: 1, y: 0 }, end: { x: 0, y: 1 } }
       ]
-      const intersection = new PlaneSweep(segments)
-      expect(intersection).toBeInstanceOf(PlaneSweep)
+      expect(() => new PlaneSweep(segments)).not.toThrow()
     })
 
-    test('throws an error if segments array is invalid', () => {
+    it('should throw an error with empty segments array', () => {
       expect(() => new PlaneSweep([])).toThrow(
-        'segments must be a non-empty array of objects with both start and end properties.'
+        'segments must be a non-empty array'
       )
-      expect(() => new PlaneSweep([{ start: { x: 0, y: 0 } }])).toThrow(
-        'segments must be a non-empty array of objects with both start and end properties.'
+    })
+
+    it('should throw an error with invalid segments', () => {
+      const invalidSegments = [{ start: { x: 0, y: 0 } }]
+      expect(() => new PlaneSweep(invalidSegments)).toThrow(
+        'segments must be a non-empty array of objects with start and end properties'
       )
     })
   })
 
-  describe('Intersection Detection', () => {
-    test('detects intersections correctly', () => {
+  describe('findIntersections', () => {
+    beforeEach(() => {
       const segments = [
-        { start: { x: 1, y: 1 }, end: { x: 4, y: 4 } },
-        { start: { x: 1, y: 4 }, end: { x: 4, y: 1 } },
-        { start: { x: 5, y: 5 }, end: { x: 6, y: 6 } }
+        { start: { x: 0, y: 0 }, end: { x: 2, y: 2 } },
+        { start: { x: 0, y: 2 }, end: { x: 2, y: 0 } }
       ]
-      const intersection = new PlaneSweep(segments)
-      const result = intersection.findIntersections()
-
-      // Check if there is one intersection found
-      expect(result).toHaveLength(1) // Ensure there's one intersection
-
-      const intersectingPair = result[0]
-
-      // Check that both segments in the intersection are part of the original segments
-      const segment1 = intersectingPair.segment1
-      const segment2 = intersectingPair.segment2
+      planeSweep = new PlaneSweep(segments)
+    })
 
-      const isSegment1Valid =
-        (segment1.start.x === segments[0].start.x &&
-          segment1.start.y === segments[0].start.y &&
-          segment1.end.x === segments[0].end.x &&
-          segment1.end.y === segments[0].end.y) ||
-        (segment1.start.x === segments[1].start.x &&
-          segment1.start.y === segments[1].start.y &&
-          segment1.end.x === segments[1].end.x &&
-          segment1.end.y === segments[1].end.y)
+    it('should find intersections between crossing segments', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 2, y: 2 } },
+        { start: { x: 0, y: 2 }, end: { x: 2, y: 0 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
+      expect(intersections[0]).toEqual(
+        expect.objectContaining({
+          segment1: expect.objectContaining({
+            start: expect.objectContaining({ x: 0, y: expect.any(Number) }),
+            end: expect.objectContaining({ x: 2, y: expect.any(Number) })
+          }),
+          segment2: expect.objectContaining({
+            start: expect.objectContaining({ x: 0, y: expect.any(Number) }),
+            end: expect.objectContaining({ x: 2, y: expect.any(Number) })
+          })
+        })
+      )
+    })
 
-      const isSegment2Valid =
-        (segment2.start.x === segments[0].start.x &&
-          segment2.start.y === segments[0].start.y &&
-          segment2.end.x === segments[0].end.x &&
-          segment2.end.y === segments[0].end.y) ||
-        (segment2.start.x === segments[1].start.x &&
-          segment2.start.y === segments[1].start.y &&
-          segment2.end.x === segments[1].end.x &&
-          segment2.end.y === segments[1].end.y)
+    it('should not find intersections between non-crossing segments', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 1, y: 1 } },
+        { start: { x: 2, y: 2 }, end: { x: 3, y: 3 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(0)
+    })
 
-      expect(isSegment1Valid).toBe(true)
-      expect(isSegment2Valid).toBe(true)
+    it('should handle vertical and horizontal segments', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 0, y: 2 } }, // Vertical
+        { start: { x: -1, y: 1 }, end: { x: 2, y: 1 } } // Horizontal
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
     })
 
-    test('returns an empty array if there are no intersections', () => {
+    it('should handle segments with shared endpoints', () => {
       const segments = [
-        { start: { x: 1, y: 1 }, end: { x: 2, y: 2 } },
-        { start: { x: 3, y: 3 }, end: { x: 4, y: 4 } }
+        { start: { x: 0, y: 0 }, end: { x: 1, y: 1 } },
+        { start: { x: 1, y: 1 }, end: { x: 2, y: 0 } }
       ]
-      const intersection = new PlaneSweep(segments)
-      const result = intersection.findIntersections()
-      expect(result).toEqual([])
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1) // Shared endpoint is considered an intersection
     })
 
-    test('handles vertical and horizontal lines', () => {
+    it('should handle overlapping segments', () => {
       const segments = [
-        { start: { x: 2, y: 0 }, end: { x: 2, y: 3 } }, // Vertical line
-        { start: { x: 0, y: 2 }, end: { x: 3, y: 2 } } // Horizontal line
+        { start: { x: 0, y: 0 }, end: { x: 2, y: 2 } },
+        { start: { x: 1, y: 1 }, end: { x: 3, y: 3 } }
       ]
-      const intersection = new PlaneSweep(segments)
-      const result = intersection.findIntersections()
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
+    })
+  })
 
-      // Check if intersection contains the correct segments regardless of order
-      expect(result).toHaveLength(1) // Ensure there's one intersection
+  describe('edge cases', () => {
+    it('should handle segments with reversed start and end points', () => {
+      const segments = [
+        { start: { x: 2, y: 2 }, end: { x: 0, y: 0 } },
+        { start: { x: 0, y: 2 }, end: { x: 2, y: 0 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
+    })
 
-      const intersectingPair = result[0]
+    it('should handle segments with same x-coordinate but different y-coordinates', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 0, y: 2 } },
+        { start: { x: 0, y: 1 }, end: { x: 0, y: 3 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
+    })
 
-      // Check that both segments in the intersection are part of the original segments
-      const isSegment1Valid =
-        (intersectingPair.segment1.start.x === segments[0].start.x &&
-          intersectingPair.segment1.start.y === segments[0].start.y &&
-          intersectingPair.segment1.end.x === segments[0].end.x &&
-          intersectingPair.segment1.end.y === segments[0].end.y) ||
-        (intersectingPair.segment1.start.x === segments[1].start.x &&
-          intersectingPair.segment1.start.y === segments[1].start.y &&
-          intersectingPair.segment1.end.x === segments[1].end.x &&
-          intersectingPair.segment1.end.y === segments[1].end.y)
+    it('should handle a large number of touching segments', () => {
+      const segments = Array.from({ length: 1000 }, (_, i) => ({
+        start: { x: i, y: 0 },
+        end: { x: i + 1, y: 1 }
+      }))
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      // Check if touching points are considered intersections
+      const touchingPointsAreIntersections = intersections.length > 0
+      if (touchingPointsAreIntersections) {
+        expect(intersections).toHaveLength(999) // Each segment touches its neighbor
+      } else {
+        expect(intersections).toHaveLength(0) // Touching points are not considered intersections
+      }
+    })
 
-      const isSegment2Valid =
-        (intersectingPair.segment2.start.x === segments[0].start.x &&
-          intersectingPair.segment2.start.y === segments[0].start.y &&
-          intersectingPair.segment2.end.x === segments[0].end.x &&
-          intersectingPair.segment2.end.y === segments[0].end.y) ||
-        (intersectingPair.segment2.start.x === segments[1].start.x &&
-          intersectingPair.segment2.start.y === segments[1].start.y &&
-          intersectingPair.segment2.end.x === segments[1].end.x &&
-          intersectingPair.segment2.end.y === segments[1].end.y)
+    it('should detect touching points as intersections', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 1, y: 1 } },
+        { start: { x: 1, y: 1 }, end: { x: 2, y: 0 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
+    })
 
-      expect(isSegment1Valid).toBe(true)
-      expect(isSegment2Valid).toBe(true)
+    it('should handle collinear overlapping segments', () => {
+      const segments = [
+        { start: { x: 0, y: 0 }, end: { x: 2, y: 0 } },
+        { start: { x: 1, y: 0 }, end: { x: 3, y: 0 } }
+      ]
+      planeSweep = new PlaneSweep(segments)
+      const intersections = planeSweep.findIntersections()
+      expect(intersections).toHaveLength(1)
     })
   })
 })
