Merge pull request #70 from SixLabors/sw/issue-28

Offset draw line operations to draw from pixel center

Author: tocsoft

src/ImageSharp.Drawing/Processing/Processors/Drawing/DrawPathProcessor.cs

@@ -43,6 +43,10 @@ public DrawPathProcessor(ShapeGraphicsOptions options, IPen pen, IPath shape)
         /// <inheritdoc />
         public IImageProcessor<TPixel> CreatePixelSpecificProcessor<TPixel>(Configuration configuration, Image<TPixel> source, Rectangle sourceRectangle)
             where TPixel : unmanaged, IPixel<TPixel>
-            => new FillRegionProcessor(this.Options, this.Pen.StrokeFill, new ShapePath(this.Shape, this.Pen)).CreatePixelSpecificProcessor(configuration, source, sourceRectangle);
+        {
+            // offset drawlines to align drawing outlines to pixel centers
+            var shape = this.Shape.Translate(0.5f, 0.5f);
+            return new FillRegionProcessor(this.Options, this.Pen.StrokeFill, new ShapePath(shape, this.Pen)).CreatePixelSpecificProcessor(configuration, source, sourceRectangle);
+        }
     }
 }

src/ImageSharp.Drawing/Processing/Processors/Drawing/FillRegionProcessor{TPixel}.cs

@@ -61,10 +61,8 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
             // basically if the line is [1,2] => [3,2] then when outlining at 1 we end up with a region of [0.5,1.5],[1.5, 1.5],[3.5,2.5],[2.5,2.5]
             // and this can cause missed fills when not using antialiasing.so we offset the pixel grid by 0.5 in the x & y direction thus causing the#
             // region to align with the pixel grid.
-            float offset = 0.5f;
             if (graphicsOptions.Antialias)
             {
-                offset = 0f; // we are antialiasing skip offsetting as real antialiasing should take care of offset.
                 subpixelCount = graphicsOptions.AntialiasSubpixelDepth;
                 if (subpixelCount < 4)
                 {
@@ -97,7 +95,7 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                         float yPlusOne = y + 1;
                         for (float subPixel = y; subPixel < yPlusOne; subPixel += subpixelFraction)
                         {
-                            int pointsFound = region.Scan(subPixel + offset, buffer, configuration, shapeOptions.IntersectionRule);
+                            int pointsFound = region.Scan(subPixel, buffer, configuration, shapeOptions.IntersectionRule);
                             if (pointsFound == 0)
                             {
                                 // nothing on this line, skip
@@ -109,8 +107,8 @@ protected override void OnFrameApply(ImageFrame<TPixel> source)
                                 // points will be paired up
                                 float scanStart = buffer[point] - minX;
                                 float scanEnd = buffer[point + 1] - minX;
-                                int startX = (int)MathF.Floor(scanStart + offset);
-                                int endX = (int)MathF.Floor(scanEnd + offset);
+                                int startX = (int)MathF.Floor(scanStart);
+                                int endX = (int)MathF.Floor(scanEnd);
 
                                 if (startX >= 0 && startX < scanline.Length)
                                 {

src/ImageSharp.Drawing/Shapes/Outliner.cs

@@ -75,7 +75,7 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
         {
             if (pattern.Length < 2)
             {
-                return path.GenerateOutline(width);
+                return path.GenerateOutline(width, jointStyle: jointStyle);
             }
 
             JoinType style = Convert(jointStyle);
@@ -187,7 +187,7 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
         /// <param name="jointStyle">The style to render the joints.</param>
         /// <param name="endCapStyle">The style to render the end caps of open paths (ignored on closed paths).</param>
         /// <returns>A new path representing the outline.</returns>
-        public static IPath GenerateOutline(this IPath path, float width, JointStyle jointStyle = JointStyle.Square, EndCapStyle endCapStyle = EndCapStyle.Butt)
+        public static IPath GenerateOutline(this IPath path, float width, JointStyle jointStyle = JointStyle.Square, EndCapStyle endCapStyle = EndCapStyle.Square)
         {
             var offset = new ClipperOffset()
             {

tests/ImageSharp.Drawing.Tests/Issues/Issue_28.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using SixLabors.ImageSharp.ColorSpaces;
+using SixLabors.ImageSharp.Drawing.Processing;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using Xunit;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Issues
+{
+    public class Issue_28
+    {
+        private Rgba32 red = Color.Red.ToRgba32();
+
+        [Fact]
+        public void DrawingLineAtTopShouldDisplay()
+        {
+            using var image = new Image<Rgba32>(Configuration.Default, 100, 100, Color.Black);
+            image.Mutate(x => x
+                    .SetGraphicsOptions(g => g.Antialias = false)
+                    .DrawLines(
+                        this.red,
+                        1f,
+                        new PointF(0, 0),
+                        new PointF(100, 0)
+                    ));
+
+            var locations = Enumerable.Range(0, 100).Select(i => (x: i, y: 0));
+            Assert.All(locations, l =>
+            {
+                Assert.Equal(this.red, image[l.x, l.y]);
+            });
+        }
+
+        [Fact]
+        public void DrawingLineAtBottomShouldDisplay()
+        {
+            using var image = new Image<Rgba32>(Configuration.Default, 100, 100, Color.Black);
+            image.Mutate(x => x
+                    .SetGraphicsOptions(g => g.Antialias = false)
+                    .DrawLines(
+                        this.red,
+                        1f,
+                        new PointF(0, 99),
+                        new PointF(100, 99)
+                    ));
+
+            var locations = Enumerable.Range(0, 100).Select(i => (x: i, y: 99));
+            Assert.All(locations, l =>
+            {
+                Assert.Equal(this.red, image[l.x, l.y]);
+            });
+        }
+
+        [Fact]
+        public void DrawingLineAtLeftShouldDisplay()
+        {
+            using var image = new Image<Rgba32>(Configuration.Default, 100, 100, Color.Black);
+            image.Mutate(x => x
+                    .SetGraphicsOptions(g => g.Antialias = false)
+                    .DrawLines(
+                        this.red,
+                        1f,
+                        new PointF(0, 0),
+                        new PointF(0, 99)
+                    ));
+
+            var locations = Enumerable.Range(0, 100).Select(i => (x: 0, y: i));
+            Assert.All(locations, l =>
+            {
+                Assert.Equal(this.red, image[l.x, l.y]);
+            });
+        }
+
+        [Fact]
+        public void DrawingLineAtRightShouldDisplay()
+        {
+            using var image = new Image<Rgba32>(Configuration.Default, 100, 100, Color.Black);
+            image.Mutate(x => x
+                    .SetGraphicsOptions(g => g.Antialias = false)
+                    .DrawLines(
+                        this.red,
+                        1f,
+                        new PointF(99, 0),
+                        new PointF(99, 99)
+                    ));
+
+            var locations = Enumerable.Range(0, 100).Select(i => (x: 99, y: i));
+            Assert.All(locations, l =>
+            {
+                Assert.Equal(this.red, image[l.x, l.y]);
+            });
+        }
+    }
+}