Histogram bug fixes (#64)

* bfix: Check the amount of points passed in to `drawSolidPolygon` and `drawPlotLines` for the various renderers before rendering anything and add missing image verification to tests.

* bfix: "fix" bug where in some cases and some renderers the x labels showed values with too many decimal places due to numeric error.

In reality this just decreases the possibility of this happening again by reducing an extra division followed by a multiplication by the same value, which in some cases would result in loss of precision to the point where the string representation also had to change and show more decimal places.
We should in the future round the number to a certain number of decimal places by default and give the user control over it.

* bfix: Fix bug where the histogram bin edges were drawn slightly misaligned with the grid/markers

And at the same time reveal a bug with drawing rectangles that touch each other where the x coordinate is not a whole number.
When rendering with raster renderers this results in white lines with differing widths.

* [bfix][rfac]: Fix bug where white lines appear through histogram bin edges due to previous commit.

This is the easy approach, in the case of multiple series the colour of the series in the back might/will bleed through the edges of the one in the front, even when/if there are no columns of the back series nearby.
Also refactored the code inside `drawData` slightly for better code reuse between `.bar` and `.step` cases.

* Rename test numbers to make space for a new one.

* Add new test for colour bleeding.

6 series, all the ways to pair 6 different colours side by side.

* bfix: Colour from some series in the background were bleeding through some edges due to the last commit, this fixes that with an improved algorithm.

This is the same idea as with the `.step` case, using conditions and rules to decide what points to add to form a polygon. In this case "tucking" the background series a little behind the foreground one by `floor`ing or `ceil`ing the right points.
Also improved the algorithm for `.step` by removing one "instruction" and reducing the cases some of the instructions were being emitted redundantly to the minimum possible, while preserving the same output.

* Change `floor`/`ceil` to `.rounded(.up)`/`.rounded(.down)`.

* Change guard statements to preconditions.

* Revert back to using rectangles for `.bar`.

* Revert `barWidth` to being rounded, update the test images and run `swift test --generate-linuxmain`.

Author: odmir

Sources/AGGRenderer/AGGRenderer/AGGRenderer.swift

@@ -142,6 +142,8 @@ public class AGGRenderer: Renderer{
 
     public func drawSolidPolygon(points: [Point],
                                  fillColor: Color) {
+        precondition(points.count > 2, "drawSolidPolygon: Cannot draw a polygon with \(points.count) points.")
+        
         var x = [Float]()
         var y = [Float]()
         for index in 0..<points.count {
@@ -186,6 +188,8 @@ public class AGGRenderer: Renderer{
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
+        precondition(p.count > 1, "drawPlotLines: Cannot draw lines with \(p.count) points.")
+        
         var x = [Float]()
         var y = [Float]()
 

Sources/QuartzRenderer/QuartzRenderer.swift

@@ -371,6 +371,8 @@ public class QuartzRenderer: Renderer {
 
     public func drawSolidPolygon(points: [Point],
                                  fillColor: Color) {
+        precondition(points.count > 2, "drawSolidPolygon: Cannot draw a polygon with \(points.count) points.")
+        
         let polygonPath = CGMutablePath()
         polygonPath.move(to: CGPoint(x: Double(points[0].x + xOffset), y: Double(points[0].y + yOffset)))
         for index in 1..<points.count {
@@ -405,7 +407,8 @@ public class QuartzRenderer: Renderer {
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
-        guard !p.isEmpty else { return }
+        precondition(p.count > 1, "drawPlotLines: Cannot draw lines with \(p.count) points.")
+        
         for i in 0..<p.count-1 {
             drawLine(startPoint: p[i],
                      endPoint: p[i+1],

Sources/SVGRenderer/SVGRenderer.swift

@@ -159,6 +159,8 @@ public class SVGRenderer: Renderer{
 
     public func drawSolidPolygon(points: [Point],
                                  fillColor: Color) {
+        precondition(points.count > 2, "drawSolidPolygon: Cannot draw a polygon with \(points.count) points.")
+        
         let pts = points.map { convertToSVGCoordinates($0) }
         var pointsString = ""
         for index in 0..<pts.count {
@@ -189,8 +191,8 @@ public class SVGRenderer: Renderer{
                               strokeWidth thickness: Float,
                               strokeColor: Color,
                               isDashed: Bool) {
-        guard p.count > 1 else { return }
-
+        precondition(p.count > 1, "drawPlotLines: Cannot draw lines with \(p.count) points.")
+        
         let pointsString = p.lazy.map { point in
             let convertedPoint = self.convertToSVGCoordinates(point)
             return "\(convertedPoint.x),\(convertedPoint.y)"

Sources/SwiftPlot/Histogram.swift

@@ -200,13 +200,13 @@ extension Histogram: HasGraphLayout {
         }
 
         let nX: Float = v2/scaleX
-        var inc2: Float = nX
+        var inc2: Float = v2
         if(size.width/nX > MAX_DIV){
-            inc2 = (size.height/nX)*inc1/MAX_DIV
+            inc2 = (size.height/v2)*inc1/MAX_DIV
         }
         let xM: Float = results.xMargin
         let scaleXInv = 1.0/scaleX
-        let xIncrement = inc2*scaleX
+        let xIncrement = inc2
         for i in stride(from: Float(minimumX), through: Float(maximumX), by: xIncrement)  {
             markers.xMarkers.append((i-Float(minimumX))*scaleXInv + xM)
             markers.xMarkersText.append("\(i)")
@@ -221,37 +221,38 @@ extension Histogram: HasGraphLayout {
 
         return (results, markers)
     }
-    //functions to draw the plot
+    
+    /// Draw with rectangles if `histogramType` is `.bar` or with lines if `histogramType` is `.step`.
     public func drawData(_ data: DrawingData, size: Size, renderer: Renderer) {
         let binCount = histogramSeries.bins
         let allSeries = [data.series_scaledBinFrequency] + data.stack_scaledBinFrequency
         let allSeriesInfo = [histogramSeries] + histogramStackSeries
+        
         switch histogramSeries.histogramSeriesOptions.histogramType {
         case .bar:
             let xStart = Float(data.xMargin)
             let xValues = stride(from: xStart, to: xStart + Float(binCount) * data.barWidth, by: data.barWidth)
 
-            // Get a `Slice` of frequencies for each series so we can take one element from each series for each x value
-            var frequencySlices = allSeries.map { $0[...] }
-            for x in xValues {
+            // Iterate through each bar stacking the corresponding bar of each series.
+            for (x, binIdx) in zip(xValues, 0..<binCount) {
                 var currentHeight: Float = 0.0
-                for (series, index) in zip(allSeries, frequencySlices.indices) {
-                    let height = frequencySlices[index].removeFirst()
+                for seriesIdx in allSeriesInfo.indices {
+                    let height = allSeries[seriesIdx][binIdx]
                     let rect = Rect(origin: Point(x, currentHeight), size: Size(width: data.barWidth, height: height))
-                    renderer.drawSolidRect(rect, fillColor: allSeriesInfo[index].color,
-                                           hatchPattern: .none)
+                    renderer.drawSolidRect(rect, fillColor: allSeriesInfo[seriesIdx].color, hatchPattern: .none)
                     currentHeight += height
                 }
-                currentHeight = 0.0
             }
         case .step:
+            /// Accumulate the frequencies of each series.
+            // One heights array for each series.
             let xStart = Float(data.xMargin)
             let xValues = stride(from: xStart, through: xStart + Float(binCount) * data.barWidth, by: data.barWidth)
-            
+
             // One heights array for each series
             var seriesHeights: [[Float]] = [[Float](repeating: 0.0, count: binCount + 2)]
 
-            // Update `currentHeights` with the height from the series and add ìt to `heights`
+            // Sum the bin frequencies from two series together and append to `seriesHeights`.
             var currentHeights = seriesHeights[seriesHeights.startIndex]
             for series in allSeries {
                 for (newHeight, index) in zip(series, currentHeights.indices.dropFirst().dropLast()) {
@@ -260,40 +261,37 @@ extension Histogram: HasGraphLayout {
                 seriesHeights.append(currentHeights)
             }
 
-            // Draw only the line segments that will actually be visible, unobstructed from other lines that will be on top
-            // We iterate over the series in reverse to draw them from back to front
+            // Iterate over the series in reverse to draw from back to front.
             var seriesHeightsSlice = seriesHeights.reversed()[...]
             var backHeightsSlice = seriesHeightsSlice.removeFirst()[...]
             for (frontHeights, seriesIdx) in zip(seriesHeightsSlice, allSeries.indices.reversed()) {
                 var frontHeightsSlice = frontHeights[...]
                 let series = allSeries[seriesIdx]
 
-                // Iterate over bin edges focusing on the height of the left and right bins of the series on the back and in front
+                /// Iterate over bin edges focusing on the height of the left and right bins of the series on the back and in front.
+                var line = [Point]()
                 var backLeftBinHeight = backHeightsSlice.removeFirst()
                 var frontLeftBinHeight = frontHeightsSlice.removeFirst()
-                var line = [Point]()
                 for ((backRightBinHeight, frontRightBinHeight), x) in zip(zip(backHeightsSlice, frontHeightsSlice), xValues) {
-                    
                     func endLine() {
                         renderer.drawPlotLines(points: line, strokeWidth: strokeWidth,
                                                strokeColor: allSeriesInfo[seriesIdx].color,
                                                isDashed: false)
                         line.removeAll(keepingCapacity: true)
                     }
 
-                    // Conditions for appending specific points or ending the line at different places based on the relative heights (4 measures)
+                    // Conditions for appending specific points or ending the line at different places based on the relative heights.
                     let c1 = backLeftBinHeight  > frontLeftBinHeight
                     let c2 = backRightBinHeight > frontRightBinHeight
                     let c3 = backLeftBinHeight  > frontRightBinHeight
                     let c4 = backRightBinHeight > frontLeftBinHeight
 
-                    if  c1 ||  c3 && c4 { line.append(Point(x, backLeftBinHeight)) }
-                    if !c3              { endLine() }
-                    if  c1 && !c4       { line.append(Point(x, frontLeftBinHeight)) }
-                    if !c4              { endLine() }
-                    if  c2 && !c3       { line.append(Point(x, frontRightBinHeight)) }
-                    if  c2 ||  c3 && c4 { line.append(Point(x, backRightBinHeight)) }
-                    if !c2              { endLine() }
+                    if  c1 ||   c3 &&  c4  { line.append(Point(x, backLeftBinHeight)) }
+                    if  c1 &&  !c4         { line.append(Point(x, frontLeftBinHeight)) }
+                    if  c1 && (!c3 || !c4) { endLine() }
+                    if  c2 &&  !c3         { line.append(Point(x, frontRightBinHeight)) }
+                    if  c2 ||   c3 &&  c4  { line.append(Point(x, backRightBinHeight)) }
+                    if !c2 &&   c3 &&  c4  { endLine() }
 
                     backLeftBinHeight  = backRightBinHeight
                     frontLeftBinHeight = frontRightBinHeight

Tests/SwiftPlotTests/Histogram/histogram-stacked-step.swift

@@ -24,7 +24,7 @@ extension HistogramTests {
   }
 
   func testHistogramStackedStepLineJoins() throws {
-    let fileName = "_27_histogram_stacked_step_line_joins"
+    let fileName = "_28_histogram_stacked_step_line_joins"
 
     var histogram = Histogram<Float>(isNormalized: false, enableGrid: true)
     histogram.addSeries(data: [0, 13, 17, 17, 21, 25, 30, 34, 34, 38, 42, 45], bins: 49, label: "Plot 1", color: .blue, histogramType: .step)
@@ -36,7 +36,7 @@ extension HistogramTests {
   }
 
   func testHistogramMultiStackedStep() throws {
-    let fileName = "_26_histogram_multi_stacked_step"
+    let fileName = "_27_histogram_multi_stacked_step"
 
     let x: StrideTo<Float> = stride(from: 0, to: 2 * .pi, by: (2 * .pi)/100)
     let data1: [Float] = x.flatMap { [Float](repeating: $0, count: Int((sin($0) + 1)*10)) }

Tests/SwiftPlotTests/Histogram/histogram-stacked.swift

@@ -22,9 +22,42 @@ extension HistogramTests {
 
     try renderAndVerify(histogram, fileName: fileName)
   }
-
+    
+  func testHistogramMultiStackedColorBleed() throws {
+      let fileName = "_25_histogram_multi_stacked_color_bleed"
+      
+      var histogram = Histogram<Float>(isNormalized: false, enableGrid: true)
+      histogram.addSeries(data: [5, 6, 7, 8, 9, 10, 15, 18], bins: 21, label: "Plot 1", color: .yellow, histogramType: .bar)
+      histogram.addStackSeries(data: [4, 5, 6, 7, 8, 9, 15, 18], label: "Plot 2", color: .orange)
+      histogram.addStackSeries(data: [3, 4, 5, 6, 7, 8, 15, 16], label: "Plot 3", color: .green)
+      histogram.addStackSeries(data: [2, 3, 4, 5, 6, 7, 14, 15, 16], label: "Plot 4", color: .red)
+      histogram.addStackSeries(data: [1, 2, 3, 4, 5, 6, 14, 16, 19], label: "Plot 5", color: .blue)
+      histogram.addStackSeries(data: [0, 1, 2, 3, 4, 5, 14, 16, 17, 19], label: "Plot 6", color: .purple)
+      
+      histogram.plotTitle = PlotTitle("HISTOGRAM MULTI STACKED")
+      histogram.plotLabel = PlotLabel(xLabel: "X", yLabel: "Frequency")
+      
+      
+      let svg_renderer = SVGRenderer()
+      try histogram.drawGraphAndOutput(fileName: svgOutputDirectory+fileName,
+                                       renderer: svg_renderer)
+      verifyImage(name: fileName, renderer: .svg)
+      #if canImport(AGGRenderer)
+      let agg_renderer = AGGRenderer()
+      try histogram.drawGraphAndOutput(fileName: aggOutputDirectory+fileName,
+                                       renderer: agg_renderer)
+      verifyImage(name: fileName, renderer: .agg)
+      #endif
+      #if canImport(QuartzRenderer)
+      let quartz_renderer = QuartzRenderer()
+      try histogram.drawGraphAndOutput(fileName: coreGraphicsOutputDirectory+fileName,
+                                       renderer: quartz_renderer)
+      verifyImage(name: fileName, renderer: .coreGraphics)
+      #endif
+    }
+    
   func testHistogramMultiStacked() throws {
-    let fileName = "_25_histogram_multi_stacked"
+    let fileName = "_26_histogram_multi_stacked"
 
     let x: StrideTo<Float> = stride(from: 0, to: 2 * .pi, by: (2 * .pi)/100)
     let data1: [Float] = x.flatMap { [Float](repeating: $0, count: Int((sin($0) + 1)*10)) }