shape edges merge improvement

Sources/iOverlay/Core/Overlay.swift

@@ -191,7 +191,9 @@ public struct Overlay {
 
     private func prepareSegments(fillRule: FillRule, solver: Solver) -> [Segment] {
         var sortedEdges = edges.sorted(by: { $0.xSegment < $1.xSegment })
-
+
+        sortedEdges.mergeIfNeeded()
+
         let isList = SplitSolver(solver: solver, range: sortedEdges.yRange()).split(edges: &sortedEdges)
 
         var segments = sortedEdges.segments()

Sources/iOverlay/Split/ShapeEdge.swift

@@ -51,3 +51,44 @@ extension ShapeEdge: Comparable {
         lhs.xSegment < rhs.xSegment
     }
 }
+
+extension Array where Element == ShapeEdge {
+    mutating func mergeIfNeeded() {
+        guard self.count > 1 else {
+            return
+        }
+
+        var i = 1
+        while i < self.count {
+            if self[i - 1].xSegment == self[i].xSegment {
+                break
+            }
+            i += 1
+        }
+
+        guard i < self.count else {
+            return
+        }
+
+        var j = i - 1
+        var prev = self[j]
+
+        while i < self.count {
+            if prev.xSegment == self[i].xSegment {
+                prev.count = prev.count.add(self[i].count)
+            } else {
+                self[j] = prev
+                j += 1
+                prev = self[i]
+            }
+            i += 1
+        }
+
+        self[j] = prev
+        j += 1
+
+        if j < self.count {
+            self.removeLast(self.count - j)
+        }
+    }
+}

Sources/iOverlay/Split/SplitSolver.swift

@@ -88,31 +88,6 @@ struct SplitSolver {
 
         edges.sort(by: { $0.xSegment < $1.xSegment })
 
-        edges.merge()
-    }
-}
-
-private extension [ShapeEdge] {
-    mutating func merge() {
-        guard var prev = self.first else {
-            return
-        }
-        var isModified = false
-        var i = 1
-        while i < self.count {
-            if prev.xSegment == self[i].xSegment {
-                let c = self.remove(at: i).count
-                prev.count = prev.count.add(c)
-                isModified = true
-
-                continue
-            } else if isModified {
-                isModified = false
-                self[i - 1].count = prev.count
-                prev = self[i]
-            }
-
-            i += 1
-        }
+        edges.mergeIfNeeded()
     }
 }

Tests/iOverlayTests/DinamycTests.swift

@@ -64,26 +64,39 @@ final class DinamycTests: XCTestCase {
         var r = 0.004
         while r < 1.0 {
             for n in 5..<10 {
-                let subjPaths = self.randomPolygon(radius: r, n: n)
+                let subjPaths = self.randomPolygon(radius: r, angle: 0.0, n: n)
 
                 var overlay = Overlay(capacity: n)
                 overlay.add(path: subjPaths, type: .subject)
 
                 let graph = overlay.buildGraph(fillRule: .nonZero)
-                let result = graph.extractShapes(overlayRule: .subject)
-
-                XCTAssertTrue(!result.isEmpty)
+                _ = graph.extractShapes(overlayRule: .subject)
             }
             r += 0.001
         }
     }
 
+    func test_31() throws {
+        let n = 100
+        let subjPath = self.randomPolygon(radius: 1000.0, angle: 0.0, n: n)
+        let clipPath = self.randomPolygon(radius: 1000.0, angle: 0.5, n: n)
+
+        var overlay = Overlay(capacity: 2 * n)
+        overlay.add(path: subjPath, type: .subject)
+        overlay.add(path: clipPath, type: .clip)
+
+        let graph = overlay.buildGraph(fillRule: .nonZero, solver: .list)
+        let result = graph.extractShapes(overlayRule: .union)
+
+        XCTAssertTrue(!result.isEmpty)
+    }
+
 
-    func randomPolygon(radius: Double, n: Int) -> Path {
+    func randomPolygon(radius: Double, angle: Double, n: Int) -> Path {
         var result = Path()
         result.reserveCapacity(n)
-        let da = Double.pi * 0.7
-        var a = 0.0
+        let da = 0.005
+        var a = angle
         let r = radius * 1024
         for _ in 0..<n {
             let s = sin(a)