Make requested changes and corrections from review

odmir · odmir · commit 94583ed2a44f · 2020-01-27T03:11:29.000Z
- Correct precondition check
- Remove label from `drawSolidPolygon`
- Make a variadic version of the initialiser for `Polyline` and `Polygon`
diff --git a/Sources/AGGRenderer/AGGRenderer/AGGRenderer.swift b/Sources/AGGRenderer/AGGRenderer/AGGRenderer.swift
@@ -140,7 +140,7 @@ public class AGGRenderer: Renderer{
                           agg_object);
     }
 
-    public func drawSolidPolygon(polygon: SwiftPlot.Polygon,
+    public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,
                                  fillColor: Color) {
         var x = [Float]()
         var y = [Float]()
diff --git a/Sources/QuartzRenderer/QuartzRenderer.swift b/Sources/QuartzRenderer/QuartzRenderer.swift
@@ -369,7 +369,7 @@ public class QuartzRenderer: Renderer {
         context.fillPath()
     }
 
-    public func drawSolidPolygon(polygon: SwiftPlot.Polygon,
+    public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,
                                  fillColor: Color) {
         let polygonPath = CGMutablePath()
         polygonPath.addLines(between: polygon.points.map { CGPoint(x: CGFloat($0.x), y: CGFloat($0.y)) },
diff --git a/Sources/SVGRenderer/SVGRenderer.swift b/Sources/SVGRenderer/SVGRenderer.swift
@@ -156,7 +156,7 @@ public class SVGRenderer: Renderer{
         lines.append(triangle)
     }
     
-    public func drawSolidPolygon(polygon: SwiftPlot.Polygon,
+    public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,
                                  fillColor: Color) {
         var pointsString = ""
         for point in polygon.points {
diff --git a/Sources/SwiftPlot/PlotStyleHelpers.swift b/Sources/SwiftPlot/PlotStyleHelpers.swift
@@ -184,11 +184,11 @@ struct Arrow : Annotation {
                 let wedgeRotateAngle = -atan2(end.x - start.x, end.y - start.y)
                 p1 = rotatePoint(point: p1, center: start, angleRadians: wedgeRotateAngle + 0.5 * Float.pi)
                 p2 = rotatePoint(point: p2, center: start, angleRadians: wedgeRotateAngle + 0.5 * Float.pi)
-                let head = Polygon([p1, p2, end])!
-                renderer.drawSolidPolygon(polygon: head,
+                let head = Polygon(p1, p2, end)!
+                renderer.drawSolidPolygon(head,
                                           fillColor: color)
             default:
-                renderer.drawPolyline(Polyline([start, end])!,
+                renderer.drawPolyline(Polyline(start, end)!,
                                       strokeWidth: strokeWidth,
                                       strokeColor: color,
                                       isDashed: isDashed)
@@ -205,20 +205,20 @@ struct Arrow : Annotation {
         // Draws arrow head points.
         switch headStyle {
             case .skeletal:
-                let head = Polyline([p1, b, p2])!
+                let head = Polyline(p1, b, p2)!
                 renderer.drawPolyline(head,
                                       strokeWidth: strokeWidth,
                                       strokeColor: color,
                                       isDashed: isDashed)
             case .filled:
-                let head = Polygon([p1, b, p2])!
-                renderer.drawSolidPolygon(polygon: head,
+                let head = Polygon(p1, b, p2)!
+                renderer.drawSolidPolygon(head,
                                           fillColor: color)
             case .dart:
                 var p3 = end + Point(-headLength/2, 0.0)
                 p3 = rotatePoint(point: p3, center: b, angleRadians: rotateAngle + 0.5 * Float.pi)
-                let head = Polygon([p1, p3, p2, b])!
-                renderer.drawSolidPolygon(polygon: head,
+                let head = Polygon(p1, p3, p2, b)!
+                renderer.drawSolidPolygon(head,
                                           fillColor: color)
             default:
                 break
diff --git a/Sources/SwiftPlot/Renderer.swift b/Sources/SwiftPlot/Renderer.swift
@@ -154,7 +154,7 @@ public protocol Renderer: AnyObject{
     *             without shifted origin.
     *             This is decided by the boolean parameter isOriginShifted.
     */
-    func drawSolidPolygon(polygon: Polygon,
+    func drawSolidPolygon(_ polygon: Polygon,
                           fillColor: Color)
 
     /*getTextWidth()
@@ -200,7 +200,8 @@ public struct Polygon {
     public var points: [Point] {
         didSet {
             let count = points.count
-            precondition(count >= 2, "Polygon: points array should always contain at least 3 points, it now has \(count).")
+            precondition(count >= 3,
+                         "Polygon: points array should always contain at least 3 points, it now has \(count).")
         }
     }
 
@@ -209,14 +210,17 @@ public struct Polygon {
         
         self.points = points
     }
+    
+    public init?(_ points: Point...) { self.init(points) }
 }
 
 /// Polyline structure definition
 public struct Polyline {
     public var points: [Point] {
         didSet {
             let count = points.count
-            precondition(count >= 2, "Polyline: points array should always contain at least 2 points, it now has \(count).")
+            precondition(count >= 2,
+                         "Polyline: points array should always contain at least 2 points, it now has \(count).")
         }
     }
 
@@ -225,4 +229,6 @@ public struct Polyline {
         
         self.points = points
     }
+    
+    public init?(_ points: Point...) { self.init(points) }
 }
diff --git a/Sources/SwiftPlot/ScatterChart.swift b/Sources/SwiftPlot/ScatterChart.swift
@@ -368,8 +368,8 @@ extension ScatterPlot: HasGraphLayout {
                     tR = rotatePoint(point: tR, center: p, angleDegrees: 45.0)
                     bL = rotatePoint(point: bL, center: p, angleDegrees: 45.0)
                     bR = rotatePoint(point: bR, center: p, angleDegrees: 45.0)
-                    let diamond = Polygon([tL, tR, bR, bL])!
-                    renderer.drawSolidPolygon(polygon: diamond,
+                    let diamond = Polygon(tL, tR, bR, bL)!
+                    renderer.drawSolidPolygon(diamond,
                                               fillColor: color)
                 case .hexagon:
                     var hexagonPoint = Point(p.x + 0.0,
@@ -382,7 +382,7 @@ extension ScatterPlot: HasGraphLayout {
                         hexagonPoints.append(hexagonPoint)
                     }
                     let hexagon = Polygon(hexagonPoints)!
-                    renderer.drawSolidPolygon(polygon: hexagon,
+                    renderer.drawSolidPolygon(hexagon,
                                               fillColor: color)
                 case .pentagon:
                     var pentagonPoint = Point(p.x + 0.0,
@@ -395,7 +395,7 @@ extension ScatterPlot: HasGraphLayout {
                         pentagonPoints.append(pentagonPoint)
                     }
                     let pentagon = Polygon(pentagonPoints)!
-                    renderer.drawSolidPolygon(polygon: pentagon,
+                    renderer.drawSolidPolygon(pentagon,
                                               fillColor: color)
 
                 case .star:
@@ -417,7 +417,7 @@ extension ScatterPlot: HasGraphLayout {
                         starPoints.append(starInnerPoint)
                     }
                     let star = Polygon(starPoints)!
-                    renderer.drawSolidPolygon(polygon: star,
+                    renderer.drawSolidPolygon(star,
                                               fillColor: color)
                 }
             }
@@ -465,8 +465,8 @@ extension ScatterPlotSeriesOptions.ScatterPattern {
             let p2 = rotatePoint(point: tR, center: c, angleDegrees: 45.0)
             let p3 = rotatePoint(point: bR, center: c, angleDegrees: 45.0)
             let p4 = rotatePoint(point: bL, center: c, angleDegrees: 45.0)
-            let diamond = Polygon([p1, p2, p3, p4])!
-            renderer.drawSolidPolygon(polygon: diamond,
+            let diamond = Polygon(p1, p2, p3, p4)!
+            renderer.drawSolidPolygon(diamond,
                                       fillColor: color)
         case .hexagon:
             let c = Point((tL.x+bR.x)*Float(0.5),
@@ -481,7 +481,7 @@ extension ScatterPlotSeriesOptions.ScatterPattern {
                 hexagonPoints.append(hexagonPoint)
             }
             let hexagon = Polygon(hexagonPoints)!
-            renderer.drawSolidPolygon(polygon: hexagon,
+            renderer.drawSolidPolygon(hexagon,
                                       fillColor: color)
         case .pentagon:
             let c = Point((tL.x+bR.x)*Float(0.5),
@@ -496,7 +496,7 @@ extension ScatterPlotSeriesOptions.ScatterPattern {
                 pentagonPoints.append(pentagonPoint)
             }
             let pentagon = Polygon(pentagonPoints)!
-            renderer.drawSolidPolygon(polygon: pentagon,
+            renderer.drawSolidPolygon(pentagon,
                                       fillColor: color)
         case .star:
             let c = Point((tL.x+bR.x)*Float(0.5),
@@ -519,7 +519,7 @@ extension ScatterPlotSeriesOptions.ScatterPattern {
                 starPoints.append(starInnerPoint)
             }
             let star = Polygon(starPoints)!
-            renderer.drawSolidPolygon(polygon: star,
+            renderer.drawSolidPolygon(star,
                                       fillColor: color)
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -140,7 +140,7 @@ public class AGGRenderer: Renderer{`
`140`	`140`	`agg_object);`
`141`	`141`	`}`
`142`	`142`
`143`		`- public func drawSolidPolygon(polygon: SwiftPlot.Polygon,`
	`143`	`+ public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,`
`144`	`144`	`fillColor: Color) {`
`145`	`145`	`var x = [Float]()`
`146`	`146`	`var y = [Float]()`
Original file line number	Diff line number	Diff line change
`@@ -369,7 +369,7 @@ public class QuartzRenderer: Renderer {`
`369`	`369`	`context.fillPath()`
`370`	`370`	`}`
`371`	`371`
`372`		`- public func drawSolidPolygon(polygon: SwiftPlot.Polygon,`
	`372`	`+ public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,`
`373`	`373`	`fillColor: Color) {`
`374`	`374`	`let polygonPath = CGMutablePath()`
`375`	`375`	`polygonPath.addLines(between: polygon.points.map { CGPoint(x: CGFloat($0.x), y: CGFloat($0.y)) },`
Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ public class SVGRenderer: Renderer{`
`156`	`156`	`lines.append(triangle)`
`157`	`157`	`}`
`158`	`158`
`159`		`- public func drawSolidPolygon(polygon: SwiftPlot.Polygon,`
	`159`	`+ public func drawSolidPolygon(_ polygon: SwiftPlot.Polygon,`
`160`	`160`	`fillColor: Color) {`
`161`	`161`	`var pointsString = ""`
`162`	`162`	`for point in polygon.points {`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ public protocol Renderer: AnyObject{`
`154`	`154`	`* without shifted origin.`
`155`	`155`	`* This is decided by the boolean parameter isOriginShifted.`
`156`	`156`	`*/`
`157`		`- func drawSolidPolygon(polygon: Polygon,`
	`157`	`+ func drawSolidPolygon(_ polygon: Polygon,`
`158`	`158`	`fillColor: Color)`
`159`	`159`
`160`	`160`	`/*getTextWidth()`
`@@ -200,7 +200,8 @@ public struct Polygon {`
`200`	`200`	`public var points: [Point] {`
`201`	`201`	`didSet {`
`202`	`202`	`let count = points.count`
`203`		`- precondition(count >= 2, "Polygon: points array should always contain at least 3 points, it now has \(count).")`
	`203`	`+ precondition(count >= 3,`
	`204`	`+ "Polygon: points array should always contain at least 3 points, it now has \(count).")`
`204`	`205`	`}`
`205`	`206`	`}`
`206`	`207`
`@@ -209,14 +210,17 @@ public struct Polygon {`
`209`	`210`
`210`	`211`	`self.points = points`
`211`	`212`	`}`
	`213`	`+`
	`214`	`+ public init?(_ points: Point...) { self.init(points) }`
`212`	`215`	`}`
`213`	`216`
`214`	`217`	`/// Polyline structure definition`
`215`	`218`	`public struct Polyline {`
`216`	`219`	`public var points: [Point] {`
`217`	`220`	`didSet {`
`218`	`221`	`let count = points.count`
`219`		`- precondition(count >= 2, "Polyline: points array should always contain at least 2 points, it now has \(count).")`
	`222`	`+ precondition(count >= 2,`
	`223`	`+ "Polyline: points array should always contain at least 2 points, it now has \(count).")`
`220`	`224`	`}`
`221`	`225`	`}`
`222`	`226`
`@@ -225,4 +229,6 @@ public struct Polyline {`
`225`	`229`
`226`	`230`	`self.points = points`
`227`	`231`	`}`
	`232`	`+`
	`233`	`+ public init?(_ points: Point...) { self.init(points) }`
`228`	`234`	`}`