Integrate SixLabors.PolygonClipper

src/ImageSharp.Drawing/ImageSharp.Drawing.csproj

@@ -47,6 +47,7 @@
   <ItemGroup>
     <PackageReference Include="SixLabors.Fonts" Version="3.0.0-alpha.0.1" />
     <PackageReference Include="SixLabors.ImageSharp" Version="4.0.0-alpha.0.44" />
+    <PackageReference Include="SixLabors.PolygonClipper" Version="1.0.0-alpha.0.48" />
   </ItemGroup>
   <Import Project="..\..\shared-infrastructure\src\SharedInfrastructure\SharedInfrastructure.projitems" Label="Shared" />
 </Project>

src/ImageSharp.Drawing/Processing/ShapeOptions.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.PolygonClipper;
+
 namespace SixLabors.ImageSharp.Drawing.Processing;
 
 /// <summary>
@@ -24,9 +26,9 @@ private ShapeOptions(ShapeOptions source)
     /// <summary>
     /// Gets or sets the clipping operation.
     /// <para/>
-    /// Defaults to <see cref="ClippingOperation.Difference"/>.
+    /// Defaults to <see cref="BooleanOperation.Difference"/>.
     /// </summary>
-    public ClippingOperation ClippingOperation { get; set; } = ClippingOperation.Difference;
+    public BooleanOperation ClippingOperation { get; set; } = BooleanOperation.Difference;
 
     /// <summary>
     /// Gets or sets the rule for calculating intersection points.

src/ImageSharp.Drawing/Shapes/ClipPathExtensions.cs

@@ -63,7 +63,7 @@ public static IPath Clip(
         clipper.AddPath(subjectPath, ClippingType.Subject);
         clipper.AddPaths(clipPaths, ClippingType.Clip);
 
-        IPath[] result = clipper.GenerateClippedShapes(options.ClippingOperation, options.IntersectionRule);
+        IPath[] result = clipper.GenerateClippedShapes(options.ClippingOperation);
 
         return new ComplexPolygon(result);
     }

src/ImageSharp.Drawing/Shapes/PolygonClipper/Clipper.cs

@@ -1,59 +1,46 @@
 // Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+using SixLabors.PolygonClipper;
+
 namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 /// <summary>
 /// Library to clip polygons.
 /// </summary>
 internal class Clipper
 {
-    private readonly PolygonClipper polygonClipper;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="Clipper"/> class.
-    /// </summary>
-    public Clipper()
-        => this.polygonClipper = new PolygonClipper();
+    private SixLabors.PolygonClipper.Polygon? subject;
+    private SixLabors.PolygonClipper.Polygon? clip;
 
     /// <summary>
     /// Generates the clipped shapes from the previously provided paths.
     /// </summary>
     /// <param name="operation">The clipping operation.</param>
     /// <param name="rule">The intersection rule.</param>
     /// <returns>The <see cref="T:IPath[]"/>.</returns>
-    public IPath[] GenerateClippedShapes(ClippingOperation operation, IntersectionRule rule)
+    public IPath[] GenerateClippedShapes(BooleanOperation operation)
     {
-        PathsF closedPaths = [];
-        PathsF openPaths = [];
+        ArgumentNullException.ThrowIfNull(this.subject);
+        ArgumentNullException.ThrowIfNull(this.clip);
 
-        FillRule fillRule = rule == IntersectionRule.EvenOdd ? FillRule.EvenOdd : FillRule.NonZero;
-        this.polygonClipper.Execute(operation, fillRule, closedPaths, openPaths);
+        SixLabors.PolygonClipper.PolygonClipper polygonClipper = new(this.subject, this.clip, operation);
 
-        IPath[] shapes = new IPath[closedPaths.Count + openPaths.Count];
+        SixLabors.PolygonClipper.Polygon result = polygonClipper.Run();
 
-        int index = 0;
-        for (int i = 0; i < closedPaths.Count; i++)
-        {
-            PathF path = closedPaths[i];
-            PointF[] points = new PointF[path.Count];
 
-            for (int j = 0; j < path.Count; j++)
-            {
-                points[j] = path[j];
-            }
+        IPath[] shapes = new IPath[result.Count];
 
-            shapes[index++] = new Polygon(points);
-        }
-
-        for (int i = 0; i < openPaths.Count; i++)
+        int index = 0;
+        for (int i = 0; i < result.Count; i++)
         {
-            PathF path = openPaths[i];
-            PointF[] points = new PointF[path.Count];
+            Contour contour = result[i];
+            PointF[] points = new PointF[contour.Count];
 
-            for (int j = 0; j < path.Count; j++)
+            for (int j = 0; j < contour.Count; j++)
             {
-                points[j] = path[j];
+                Vertex vertex = contour[j];
+                points[j] = new PointF((float)vertex.X, (float)vertex.Y);
             }
 
             shapes[index++] = new Polygon(points);
@@ -100,12 +87,25 @@
     internal void AddPath(ISimplePath path, ClippingType clippingType)
     {
         ReadOnlySpan<PointF> vectors = path.Points.Span;
-        PathF points = new(vectors.Length);
-        for (int i = 0; i < vectors.Length; i++)
+        SixLabors.PolygonClipper.Polygon polygon = [];
+        Contour contour = new();
+        polygon.Add(contour);
+
+        foreach (PointF point in vectors)
         {
-            points.Add(vectors[i]);
+            contour.AddVertex(new Vertex(point.X, point.Y));
         }
 
-        this.polygonClipper.AddPath(points, clippingType, !path.IsClosed);
+        switch (clippingType)
+        {
+            case ClippingType.Clip:
+                this.clip = polygon;
+                break;
+            case ClippingType.Subject:
+                this.subject = polygon;
+                break;
+            default:
+                throw new ArgumentOutOfRangeException(nameof(clippingType), clippingType, null);
+        }
     }
 }