rfac: drawPlotLines now takes a new struct Polyline instead of an array of points.

This has the same advantage as the `Polygon` of making the user handle the fact that it needs at least 3 points, as early as possible and preserving that fact in the type itself.

Author: odmir

Sources/AGGRenderer/AGGRenderer/AGGRenderer.swift

@@ -185,21 +185,21 @@ public class AGGRenderer: Renderer{
                   agg_object)
     }
 
-    public func drawPlotLines(points p: [Point],
+    public func drawPlotLines(polyline: Polyline,
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
         var x = [Float]()
         var y = [Float]()
-
-        for index in 0..<p.count {
-            x.append(p[index].x + xOffset)
-            y.append(p[index].y + yOffset)
+        
+        for point in polyline {
+            x.append(point.x + xOffset)
+            y.append(point.y + yOffset)
         }
 
         draw_plot_lines(x,
                         y,
-                        Int32(p.count),
+                        Int32(x.count),
                         thickness,
                         strokeColor.r,
                         strokeColor.g,

Sources/QuartzRenderer/QuartzRenderer.swift

@@ -401,19 +401,20 @@ public class QuartzRenderer: Renderer {
         context.setLineDash(phase: 1, lengths: [])
     }
 
-    public func drawPlotLines(points p: [Point],
+    public func drawPlotLines(polyline: Polyline,
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
-        guard !p.isEmpty else { return }
-        let line = CGMutablePath()
-        line.move(to: CGPoint(x: CGFloat(p[0].x + xOffset), y: CGFloat(p[0].y + yOffset)))
-        for point in p[1...] {
-            line.addLine(to: CGPoint(x: CGFloat(point.x + xOffset), y: CGFloat(point.y + yOffset)))
+
+        let linePath = CGMutablePath()
+        linePath.move(to: CGPoint(x: Double(polyline.p1.x + xOffset), y: Double(polyline.p1.y + yOffset)))
+        linePath.addLine(to: CGPoint(x: Double(polyline.p2.x + xOffset), y: Double(polyline.p2.y + yOffset)))
+        for point in polyline.tail {
+            linePath.addLine(to: CGPoint(x: Double(point.x + xOffset), y: Double(point.y + yOffset)))
         }
         context.setStrokeColor(strokeColor.cgColor)
         context.setLineWidth(CGFloat(thickness))
-        context.addPath(line)
+        context.addPath(linePath)
         if(isDashed) {
             let dashes: [ CGFloat ] = [ CGFloat(thickness + 1), CGFloat(thickness + 1) ]
             context.setLineDash(phase: 1, lengths: dashes)

Sources/SVGRenderer/SVGRenderer.swift

@@ -186,13 +186,11 @@ public class SVGRenderer: Renderer{
         lines.append(line)
     }
 
-    public func drawPlotLines(points p: [Point],
+    public func drawPlotLines(polyline: Polyline,
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
-        guard p.count > 1 else { return }
-        
-        let pointsString = p.lazy.map { point in
+        let pointsString = polyline.lazy.map { point in
             let convertedPoint = self.convertToSVGCoordinates(point)
             return "\(convertedPoint.x),\(convertedPoint.y)"
         }.joined(separator: " ")

Sources/SwiftPlot/Histogram.swift

@@ -329,7 +329,9 @@ extension Histogram: HasGraphLayout {
                 for ((backRightBinHeight, frontRightBinHeight), x) in zip(zip(backHeightsSlice, frontHeightsSlice), xValues) {
 
                     func endLine() {
-                        renderer.drawPlotLines(points: line, strokeWidth: strokeWidth,
+                        // This algorithm should never produce lines with less than 2 points
+                        guard let polyline = Polyline(points: line) else { fatalError("drawData: Expecting 2 or more points, got \(line.count) instead") }
+                        renderer.drawPlotLines(polyline: polyline, strokeWidth: strokeWidth,
                                                strokeColor: series.color, isDashed: false)
                         line.removeAll(keepingCapacity: true)
                     }

Sources/SwiftPlot/LineChart.swift

@@ -419,22 +419,21 @@ extension LineGraph: HasGraphLayout {
     //functions to draw the plot
     public func drawData(markers: PlotMarkers, size: Size, renderer: Renderer) {
         for s in primaryAxis.series {
-            var points = [Point]()
-            for p in s.scaledValues {
-                points.append(Point(Float(p.x),Float(p.y)))
-            }
-            renderer.drawPlotLines(points: points,
+            let p1 = s.scaledValues[0]
+            let p2 = s.scaledValues[1]
+            let tail = s.scaledValues[2...].map { Point(Float($0.x), Float($0.y)) }
+            
+            renderer.drawPlotLines(polyline: Polyline(Point(Float(p1.x),Float(p1.y)), Point(Float(p2.x), Float(p2.y)), tail: tail),
                                    strokeWidth: plotLineThickness,
                                    strokeColor: s.color,
                                    isDashed: false)
         }
         if (secondaryAxis != nil) {
             for s in secondaryAxis!.series {
-                var points = [Point]()
-                for p in s.scaledValues {
-                    points.append(Point(Float(p.x),Float(p.y)))
-                }
-                renderer.drawPlotLines(points: points,
+                let p1 = s.scaledValues[0]
+                let p2 = s.scaledValues[1]
+                let tail = s.scaledValues[2...].map { Point(Float($0.x), Float($0.y)) }
+                renderer.drawPlotLines(polyline: Polyline(Point(Float(p1.x),Float(p1.y)), Point(Float(p2.x), Float(p2.y)), tail: tail),
                                        strokeWidth: plotLineThickness,
                                        strokeColor: s.color,
                                        isDashed: true)

Sources/SwiftPlot/Renderer.swift

@@ -67,14 +67,14 @@ public protocol Renderer: AnyObject{
                   strokeColor: Color, isDashed: Bool)
 
     /*drawPlotLines()
-    *params: points p: [Point],
+    *params: polyline: Polyline,
     *        strokeWidth thickness: Float,
     *        strokeColor: Color,
     *        isDashed: Bool
     *description: Draws all the line segments in a single data series for a Line Graph.
     *             This function always operates in the coordinate system with the shifted origin.
     */
-    func drawPlotLines(points p: [Point],
+    func drawPlotLines(polyline: Polyline,
                        strokeWidth thickness: Float,
                        strokeColor: Color, isDashed: Bool)
 
@@ -263,3 +263,70 @@ extension Polygon.Iterator: IteratorProtocol {
 }
 
 extension Polygon.Iterator: Sequence {}
+
+/// Polyline structure definition and sequence extension, along with its iterator.
+public struct Polyline {
+    public var p1: Point, p2: Point
+    public var tail: [Point]
+    
+    public init(_ p1: Point, _ p2: Point, tail: [Point] = []) {
+        (self.p1, self.p2) = (p1, p2)
+        self.tail = tail
+    }
+    
+    public init(_ p1: Point, _ p2: Point, tail: ArraySlice<Point>) {
+        self.init(p1, p2, tail: Array(tail))
+    }
+    
+    public init() {
+        self.init(.zero, .zero)
+    }
+    
+    public init?(points: [Point]) {
+        guard points.count >= 2 else { return nil }
+        
+        self = Polyline(points[0], points[1], tail: points[2...])
+    }
+}
+
+extension Polyline: Sequence {
+    public struct Iterator {
+        private var state: State
+        private var tailIterator: Array<Point>.Iterator
+        private let polyline: Polyline
+        
+        private enum State {
+            case p1, p2
+            case tail
+        }
+        
+        public init(polyline: Polyline) {
+            state = .p1
+            tailIterator = polyline.tail.makeIterator()
+            self.polyline = polyline
+        }
+    }
+    
+    public func makeIterator() -> Polyline.Iterator {
+        return Iterator(polyline: self)
+    }
+}
+
+extension Polyline.Iterator: IteratorProtocol {
+    public typealias Element = Point
+    
+    public mutating func next() -> Point? {
+        switch state {
+        case .p1:
+            state = .p2
+            return polyline.p1
+        case .p2:
+            state = .tail
+            return polyline.p2
+        case .tail:
+            return tailIterator.next()
+        }
+    }
+}
+
+extension Polyline.Iterator: Sequence {}