Add RoundedRectanglePolygon and PathBuilder helpers. Fix #9

Author: JimBobSquarePants

src/ImageSharp.Drawing/PathBuilder.cs

@@ -477,6 +477,75 @@ public PathBuilder AddRectangle(float x, float y, float width, float height)
             new PointF(x + width, y + height),
             new PointF(x, y + height));
 
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radius of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(RectangleF rectangle, float radius)
+        => this.AddRoundedRectangle(rectangle, new SizeF(radius, radius));
+
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radii of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(RectangleF rectangle, SizeF radius)
+    {
+        _ = this.StartFigure();
+
+        foreach (ILineSegment segment in new RoundedRectanglePolygon(rectangle, radius).LineSegments)
+        {
+            _ = this.AddSegment(segment);
+        }
+
+        return this.CloseFigure();
+    }
+
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radius of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(Rectangle rectangle, float radius)
+        => this.AddRoundedRectangle((RectangleF)rectangle, radius);
+
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radii of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(Rectangle rectangle, SizeF radius)
+        => this.AddRoundedRectangle((RectangleF)rectangle, radius);
+
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="x">The x-coordinate of the rectangle.</param>
+    /// <param name="y">The y-coordinate of the rectangle.</param>
+    /// <param name="width">The rectangle width.</param>
+    /// <param name="height">The rectangle height.</param>
+    /// <param name="radius">The x and y radius of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(float x, float y, float width, float height, float radius)
+        => this.AddRoundedRectangle(new RectangleF(x, y, width, height), radius);
+
+    /// <summary>
+    /// Adds a rounded rectangle to the current path as a closed figure.
+    /// </summary>
+    /// <param name="x">The x-coordinate of the rectangle.</param>
+    /// <param name="y">The y-coordinate of the rectangle.</param>
+    /// <param name="width">The rectangle width.</param>
+    /// <param name="height">The rectangle height.</param>
+    /// <param name="radius">The x and y radii of each corner.</param>
+    /// <returns>The <see cref="PathBuilder"/>.</returns>
+    public PathBuilder AddRoundedRectangle(float x, float y, float width, float height, SizeF radius)
+        => this.AddRoundedRectangle(new RectangleF(x, y, width, height), radius);
+
     /// <summary>
     /// Adds a polygon to the current path as a closed figure.
     /// </summary>

src/ImageSharp.Drawing/RectangularPolygon.cs

@@ -6,9 +6,8 @@
 namespace SixLabors.ImageSharp.Drawing;
 
 /// <summary>
-/// A polygon tha allows the optimized drawing of rectangles.
+/// A closed rectangular path defined by four straight edges.
 /// </summary>
-/// <seealso cref="IPath" />
 public sealed class RectangularPolygon : IPath, ISimplePath, IPathInternals
 {
     private readonly Vector2 topLeft;

src/ImageSharp.Drawing/RoundedRectanglePolygon.cs

@@ -0,0 +1,141 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Drawing;
+
+/// <summary>
+/// A rounded rectangle shape defined by rectangle bounds and corner radii.
+/// </summary>
+public sealed class RoundedRectanglePolygon : Polygon
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RoundedRectanglePolygon"/> class.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radius of each corner.</param>
+    public RoundedRectanglePolygon(RectangleF rectangle, float radius)
+        : this(rectangle, new SizeF(radius, radius))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RoundedRectanglePolygon"/> class.
+    /// </summary>
+    /// <param name="rectangle">The rectangle bounds.</param>
+    /// <param name="radius">The x and y radii of each corner.</param>
+    public RoundedRectanglePolygon(RectangleF rectangle, SizeF radius)
+        : base(CreateSegments(rectangle, radius))
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RoundedRectanglePolygon"/> class.
+    /// </summary>
+    /// <param name="x">The x-coordinate of the rectangle.</param>
+    /// <param name="y">The y-coordinate of the rectangle.</param>
+    /// <param name="width">The rectangle width.</param>
+    /// <param name="height">The rectangle height.</param>
+    /// <param name="radius">The x and y radius of each corner.</param>
+    public RoundedRectanglePolygon(float x, float y, float width, float height, float radius)
+        : this(new RectangleF(x, y, width, height), radius)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RoundedRectanglePolygon"/> class.
+    /// </summary>
+    /// <param name="x">The x-coordinate of the rectangle.</param>
+    /// <param name="y">The y-coordinate of the rectangle.</param>
+    /// <param name="width">The rectangle width.</param>
+    /// <param name="height">The rectangle height.</param>
+    /// <param name="radius">The x and y radii of each corner.</param>
+    public RoundedRectanglePolygon(float x, float y, float width, float height, SizeF radius)
+        : this(new RectangleF(x, y, width, height), radius)
+    {
+    }
+
+    private RoundedRectanglePolygon(ILineSegment[] segments)
+        : base(segments, true)
+    {
+    }
+
+    /// <inheritdoc />
+    public override IPath Transform(Matrix4x4 matrix)
+    {
+        if (matrix.IsIdentity)
+        {
+            return this;
+        }
+
+        ILineSegment[] segments = new ILineSegment[this.LineSegments.Count];
+
+        for (int i = 0; i < segments.Length; i++)
+        {
+            segments[i] = this.LineSegments[i].Transform(matrix);
+        }
+
+        return new RoundedRectanglePolygon(segments);
+    }
+
+    private static ILineSegment[] CreateSegments(RectangleF rectangle, SizeF radius)
+    {
+        float left = MathF.Min(rectangle.Left, rectangle.Right);
+        float top = MathF.Min(rectangle.Top, rectangle.Bottom);
+        float right = MathF.Max(rectangle.Left, rectangle.Right);
+        float bottom = MathF.Max(rectangle.Top, rectangle.Bottom);
+        float width = right - left;
+        float height = bottom - top;
+
+        if (width <= 0 || height <= 0)
+        {
+            return [];
+        }
+
+        float radiusX = radius.Width;
+        float radiusY = radius.Height;
+
+        if (radiusX <= 0 || radiusY <= 0)
+        {
+            return
+            [
+                new LinearLineSegment(
+                    new PointF(left, top),
+                    new PointF(right, top),
+                    new PointF(right, bottom),
+                    new PointF(left, bottom))
+            ];
+        }
+
+        float radiusScale = MathF.Min(width / (radiusX + radiusX), height / (radiusY + radiusY));
+        if (radiusScale < 1F)
+        {
+            // Preserve the supplied corner shape while shrinking it enough that opposing corners do not overlap.
+            radiusX *= radiusScale;
+            radiusY *= radiusScale;
+        }
+
+        SizeF cornerRadius = new(radiusX, radiusY);
+        PointF topLeft = new(left + radiusX, top);
+        PointF topRight = new(right - radiusX, top);
+        PointF rightTop = new(right, top + radiusY);
+        PointF rightBottom = new(right, bottom - radiusY);
+        PointF bottomRight = new(right - radiusX, bottom);
+        PointF bottomLeft = new(left + radiusX, bottom);
+        PointF leftBottom = new(left, bottom - radiusY);
+        PointF leftTop = new(left, top + radiusY);
+
+        return
+        [
+            new LinearLineSegment(topLeft, topRight),
+            new ArcLineSegment(new PointF(right - radiusX, top + radiusY), cornerRadius, 0F, -90F, 90F),
+            new LinearLineSegment(rightTop, rightBottom),
+            new ArcLineSegment(new PointF(right - radiusX, bottom - radiusY), cornerRadius, 0F, 0F, 90F),
+            new LinearLineSegment(bottomRight, bottomLeft),
+            new ArcLineSegment(new PointF(left + radiusX, bottom - radiusY), cornerRadius, 0F, 90F, 90F),
+            new LinearLineSegment(leftBottom, leftTop),
+            new ArcLineSegment(new PointF(left + radiusX, top + radiusY), cornerRadius, 0F, 180F, 90F)
+        ];
+    }
+}

tests/ImageSharp.Drawing.Tests/Processing/DrawingCanvasTests.Primitives.cs

@@ -192,6 +192,43 @@ public void FillPrimitiveHelpers_MatchesReference<TPixel>(TestImageProvider<TPix
         target.CompareToReferenceOutput(provider, appendSourceFileOrDescription: false);
     }
 
+    [Theory]
+    [WithBlankImage(360, 220, PixelTypes.Rgba32)]
+    public void RoundedRectanglePolygon_MatchesReference<TPixel>(TestImageProvider<TPixel> provider)
+        where TPixel : unmanaged, IPixel<TPixel>
+    {
+        using Image<TPixel> target = provider.GetImage();
+        using (DrawingCanvas<TPixel> canvas = CreateCanvas(provider, target, new DrawingOptions()))
+        {
+            canvas.Clear(Brushes.Solid(Color.White));
+
+            // Filled shape proves the rounded rectangle contributes a closed fill region.
+            canvas.Fill(
+                Brushes.Solid(Color.CornflowerBlue.WithAlpha(0.75F)),
+                new RoundedRectanglePolygon(18, 18, 138, 76, 18));
+
+            // Dashed stroke covers the original issue request: rounded corners must remain a normal strokable path.
+            canvas.Draw(
+                Pens.Dash(Color.DarkSlateBlue, 5F),
+                new RoundedRectanglePolygon(190, 18, 132, 76, 24));
+
+            // Elliptical radii exercise independent x/y corner curvature.
+            canvas.Fill(
+                Brushes.Solid(Color.MediumSeaGreen.WithAlpha(0.78F)),
+                new RoundedRectanglePolygon(26, 124, 118, 58, new SizeF(28, 12)));
+
+            // Oversized radii should scale down to a capsule-like shape within the supplied bounds.
+            canvas.Draw(
+                Pens.Solid(Color.OrangeRed, 6F),
+                new RoundedRectanglePolygon(188, 122, 138, 62, 90));
+
+            canvas.Draw(Pens.Solid(Color.Black.WithAlpha(0.5F), 2F), new Rectangle(8, 8, 344, 204));
+        }
+
+        target.DebugSave(provider, appendSourceFileOrDescription: false);
+        target.CompareToReferenceOutput(provider, appendSourceFileOrDescription: false);
+    }
+
     [Theory]
     [WithBlankImage(240, 160, PixelTypes.Rgba32)]
     public void DrawPieHelpers_MatchesReference<TPixel>(TestImageProvider<TPixel> provider)

tests/ImageSharp.Drawing.Tests/Shapes/PathBuilderTests.cs

@@ -85,6 +85,30 @@ public void AddRectangleMatchesRectangularPolygon()
         AssertEquivalentPaths(actual, expected);
     }
 
+    [Fact]
+    public void AddRoundedRectangleMatchesRoundedRectangleShape()
+    {
+        PathBuilder builder = new();
+        builder.AddRoundedRectangle(new RectangleF(10, 20, 30, 40), new SizeF(5, 8));
+
+        Polygon actual = Assert.IsType<Polygon>(builder.Build());
+        RoundedRectanglePolygon expected = new(10, 20, 30, 40, new SizeF(5, 8));
+
+        AssertEquivalentPaths(actual, expected);
+    }
+
+    [Fact]
+    public void AddRoundedRectangleRadiusOverloadMatchesRoundedRectangleShape()
+    {
+        PathBuilder builder = new();
+        builder.AddRoundedRectangle(10, 20, 30, 40, 6);
+
+        Polygon actual = Assert.IsType<Polygon>(builder.Build());
+        RoundedRectanglePolygon expected = new(10, 20, 30, 40, 6);
+
+        AssertEquivalentPaths(actual, expected);
+    }
+
     [Fact]
     public void AddPolygonEnumerableMatchesPolygonShape()
     {

tests/ImageSharp.Drawing.Tests/Shapes/RoundedRectangleTests.cs

@@ -0,0 +1,77 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+using System.Numerics;
+using SixLabors.ImageSharp.Drawing.Tests;
+
+namespace SixLabors.ImageSharp.Drawing.Tests.Shapes;
+
+public class RoundedRectangleTests
+{
+    [Fact]
+    public void BoundsMatchRectangle()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 12);
+
+        Assert.Equal(new RectangleF(10, 20, 100, 40), shape.Bounds);
+    }
+
+    [Fact]
+    public void ZeroRadiusMatchesRectangularPolygon()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 0);
+        RectangularPolygon rectangle = new(10, 20, 100, 40);
+        PointF[] actualPoints = shape.Flatten().Single().Points.ToArray();
+        PointF[] expectedPoints = rectangle.Flatten().Single().Points.ToArray();
+
+        Assert.Equal(expectedPoints, actualPoints);
+    }
+
+    [Fact]
+    public void RoundedRectangleUsesCurvedCorners()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 12);
+        PointF[] points = shape.Flatten().Single().Points.ToArray();
+
+        Assert.True(points.Length > 4);
+    }
+
+    [Fact]
+    public void OversizedRadiusScalesToFitBounds()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 100);
+        PointF[] points = shape.Flatten().Single().Points.ToArray();
+
+        Assert.Equal(new RectangleF(10, 20, 100, 40), shape.Bounds);
+        Assert.True(points.Length > 4);
+    }
+
+    [Fact]
+    public void ShapePaths()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 12);
+
+        Assert.Equal(shape, shape.AsClosedPath());
+    }
+
+    [Fact]
+    public void TransformIdentityReturnsShapeObject()
+    {
+        RoundedRectanglePolygon shape = new(10, 20, 100, 40, 12);
+        IPath transformedShape = shape.Transform(Matrix4x4.Identity);
+
+        Assert.Same(shape, transformedShape);
+    }
+
+    [Fact]
+    public void Transform()
+    {
+        RoundedRectanglePolygon shape = new(0, 0, 100, 40, 12);
+
+        IPath newShape = shape.Transform(new Matrix4x4(new Matrix3x2(0, 1, 1, 0, 20, 2)));
+
+        ApproximateFloatComparer comparer = new(1e-4F);
+        Assert.Equal(new PointF(20, 2), newShape.Bounds.Location, comparer);
+        Assert.Equal(new SizeF(40, 100), newShape.Bounds.Size, comparer);
+    }
+}