Merge pull request #9 from SwiftUIExtensions/lines

Path quad curves

Author: ay42

Sources/Shapes/CGPoint+Extensions.swift

@@ -0,0 +1,35 @@
+import SwiftUI
+
+public extension CGPoint {
+    init(unitPoint: UnitPoint, in rect: CGRect) {
+        self.init(
+            x: rect.width * unitPoint.x,
+            y: rect.height - (rect.height * unitPoint.y)
+        )
+    }
+}
+
+public extension CGPoint {
+    func halfway(to point: CGPoint) -> CGPoint {
+        CGPoint(x: (self.x + point.x) * 0.5, y: (self.y + point.y) * 0.5)
+    }
+    
+    func quadCurveControlPoint(with point: CGPoint) -> CGPoint {
+        let halfwayPoint = self.halfway(to: point)
+        let absoluteDistance = abs(point.y - halfwayPoint.y)
+        
+        if self.y < point.y {
+            return CGPoint(x: halfwayPoint.x, y: halfwayPoint.y + absoluteDistance)
+        } else if self.y > point.y {
+            return CGPoint(x: halfwayPoint.x, y: halfwayPoint.y - absoluteDistance)
+        } else {
+            return halfwayPoint
+        }
+    }
+}
+
+public extension Collection where Element == UnitPoint {
+    func points(in rect: CGRect) -> [CGPoint] {
+        self.map { CGPoint(unitPoint: $0, in: rect) }
+    }
+}

Sources/Shapes/CGPoint+UnitPoint.swift

@@ -1,16 +1,11 @@
 import SwiftUI
 
 public struct Line: Shape {
-    var unitPoints: [UnitPoint]
+    private let unitPoints: [UnitPoint]
 
     public func path(in rect: CGRect) -> Path {
         Path { path in
-            guard self.unitPoints.count > 0 else { return }
-            path.move(to: .init(unitPoint: self.unitPoints[0], in: rect))
-            
-            (1..<self.unitPoints.count).forEach { index in
-                path.addLine(to: .init(unitPoint: self.unitPoints[index], in: rect))
-            }
+            path.addLines(self.unitPoints.points(in: rect))
         }
     }
 

Sources/Shapes/Lines/Line.swift

@@ -5,27 +5,7 @@ public struct QuadCurve: Shape {
 
     public func path(in rect: CGRect) -> Path {
         Path { path in
-            guard self.unitPoints.count > 0 else { return }
-            var lastUnitPoint = self.unitPoints[0]
-            path.move(to: CGPoint(unitPoint: lastUnitPoint, in: rect))
-            
-            (1..<self.unitPoints.count).forEach { index in
-                let nextUnitPoint = self.unitPoints[index]
-                let nextPoint = CGPoint(unitPoint: nextUnitPoint, in: rect)
-                
-                let halfwayUnitPoint = lastUnitPoint.halfway(to: nextUnitPoint)
-                let halfwayPoint = CGPoint(unitPoint: halfwayUnitPoint, in: rect)
-                
-                let firstControlUnitPoint = halfwayUnitPoint.quadCurveControlUnitPoint(with: lastUnitPoint)
-                let firstControlPoint = CGPoint(unitPoint: firstControlUnitPoint, in: rect)
-                path.addQuadCurve(to: halfwayPoint, control: firstControlPoint)
-                
-                let secondControlUnitPoint = halfwayUnitPoint.quadCurveControlUnitPoint(with: nextUnitPoint)
-                let secondControlPoint = CGPoint(unitPoint: secondControlUnitPoint, in: rect)
-                path.addQuadCurve(to: nextPoint, control: secondControlPoint)
-                
-                lastUnitPoint = nextUnitPoint
-            }
+            path.addQuadCurves(self.unitPoints.points(in: rect))
         }
     }
 

Sources/Shapes/Lines/QuadCurve.swift

@@ -0,0 +1,43 @@
+import SwiftUI
+
+
+public extension Path {
+    mutating func addQuadCurves(_ points: [CGPoint]) {
+        guard points.count > 0 else { return }
+        
+        if let currentPoint = self.currentPoint {
+            var lastPoint = currentPoint
+            
+            (0..<points.count).forEach { index in
+                let nextPoint = points[index]
+                
+                let halfwayPoint = lastPoint.halfway(to: nextPoint)
+    
+                let firstControlPoint = halfwayPoint.quadCurveControlPoint(with: lastPoint)
+                self.addQuadCurve(to: halfwayPoint, control: firstControlPoint)
+                
+                let secondControlPoint = halfwayPoint.quadCurveControlPoint(with: nextPoint)
+                self.addQuadCurve(to: nextPoint, control: secondControlPoint)
+                
+                lastPoint = nextPoint
+            }
+        } else {
+            var lastPoint = points[0]
+            self.move(to: lastPoint)
+            
+            (1..<points.count).forEach { index in
+                let nextPoint = points[index]
+                
+                let halfwayPoint = lastPoint.halfway(to: nextPoint)
+    
+                let firstControlPoint = halfwayPoint.quadCurveControlPoint(with: lastPoint)
+                self.addQuadCurve(to: halfwayPoint, control: firstControlPoint)
+                
+                let secondControlPoint = halfwayPoint.quadCurveControlPoint(with: nextPoint)
+                self.addQuadCurve(to: nextPoint, control: secondControlPoint)
+                
+                lastPoint = nextPoint
+            }
+        }
+    }
+}