Fix remaining issues and cleanup

Author: JimBobSquarePants

src/ImageSharp.Drawing/Shapes/ClipPathExtensions.cs

@@ -2,42 +2,74 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System.Collections.Generic;
-using SixLabors.ImageSharp.Drawing.PolygonClipper;
+using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing
 {
     /// <summary>
-    /// Path extensions to clip paths.
+    /// Provides extension methods to <see cref="IPath"/> that allow the clipping of shapes.
     /// </summary>
     public static class ClipPathExtensions
     {
         /// <summary>
-        /// Clips the specified holes.
+        /// Clips the specified subject path with the provided clipping paths.
         /// </summary>
-        /// <param name="shape">The shape.</param>
-        /// <param name="holes">The holes.</param>
-        /// <returns>Returns a new shape with the holes clipped out of the shape.</returns>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
-        public static IPath Clip(this IPath shape, IEnumerable<IPath> holes)
+        /// <param name="subjectPath">The subject path.</param>
+        /// <param name="clipPaths">The clipping paths.</param>
+        /// <returns>The clipped <see cref="IPath"/>.</returns>
+        /// <exception cref="ClipperException">Thrown when an error occured while attempting to clip the polygon.</exception>
+        public static IPath Clip(this IPath subjectPath, params IPath[] clipPaths)
+            => subjectPath.Clip((IEnumerable<IPath>)clipPaths);
+
+        /// <summary>
+        /// Clips the specified subject path with the provided clipping paths.
+        /// </summary>
+        /// <param name="subjectPath">The subject path.</param>
+        /// <param name="operation">The clipping operation.</param>
+        /// <param name="rule">The intersection rule.</param>
+        /// <param name="clipPaths">The clipping paths.</param>
+        /// <returns>The clipped <see cref="IPath"/>.</returns>
+        /// <exception cref="ClipperException">Thrown when an error occured while attempting to clip the polygon.</exception>
+        public static IPath Clip(
+            this IPath subjectPath,
+            ClippingOperation operation,
+            IntersectionRule rule,
+            params IPath[] clipPaths)
+            => subjectPath.Clip(operation, rule, (IEnumerable<IPath>)clipPaths);
+
+        /// <summary>
+        /// Clips the specified subject path with the provided clipping paths.
+        /// </summary>
+        /// <param name="subjectPath">The subject path.</param>
+        /// <param name="clipPaths">The clipping paths.</param>
+        /// <returns>The clipped <see cref="IPath"/>.</returns>
+        /// <exception cref="ClipperException">Thrown when an error occured while attempting to clip the polygon.</exception>
+        public static IPath Clip(this IPath subjectPath, IEnumerable<IPath> clipPaths)
+            => subjectPath.Clip(ClippingOperation.Difference, IntersectionRule.EvenOdd, clipPaths);
+
+        /// <summary>
+        /// Clips the specified subject path with the provided clipping paths.
+        /// </summary>
+        /// <param name="subjectPath">The subject path.</param>
+        /// <param name="operation">The clipping operation.</param>
+        /// <param name="rule">The intersection rule.</param>
+        /// <param name="clipPaths">The clipping paths.</param>
+        /// <returns>The clipped <see cref="IPath"/>.</returns>
+        /// <exception cref="ClipperException">Thrown when an error occured while attempting to clip the polygon.</exception>
+        public static IPath Clip(
+            this IPath subjectPath,
+            ClippingOperation operation,
+            IntersectionRule rule,
+            IEnumerable<IPath> clipPaths)
         {
-            var clipper = new Clipper();
+            Clipper clipper = new();
 
-            clipper.AddPath(shape, ClippingType.Subject);
-            clipper.AddPaths(holes, ClippingType.Clip);
+            clipper.AddPath(subjectPath, ClippingType.Subject);
+            clipper.AddPaths(clipPaths, ClippingType.Clip);
 
-            IPath[] result = clipper.GenerateClippedShapes();
+            IPath[] result = clipper.GenerateClippedShapes(operation, rule);
 
             return new ComplexPolygon(result);
         }
-
-        /// <summary>
-        /// Clips the specified holes.
-        /// </summary>
-        /// <param name="shape">The shape.</param>
-        /// <param name="holes">The holes.</param>
-        /// <returns>Returns a new shape with the holes clipped out of the shape.</returns>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
-        public static IPath Clip(this IPath shape, params IPath[] holes)
-            => shape.Clip((IEnumerable<IPath>)holes);
     }
 }

src/ImageSharp.Drawing/Shapes/ClippingOperation.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Drawing
+{
+    /// <summary>
+    /// Provides options for boolean clipping operations.
+    /// </summary>
+    /// <remarks>
+    /// All clipping operations except for Difference are commutative.
+    /// </remarks>
+    public enum ClippingOperation
+    {
+        /// <summary>
+        /// No clipping is performed.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Clips regions covered by both subject and clip polygons.
+        /// </summary>
+        Intersection,
+
+        /// <summary>
+        /// Clips regions covered by subject or clip polygons, or both polygons.
+        /// </summary>
+        Union,
+
+        /// <summary>
+        /// Clips regions covered by subject, but not clip polygons.
+        /// </summary>
+        Difference,
+
+        /// <summary>
+        /// Clips regions covered by subject or clip polygons, but not both.
+        /// </summary>
+        Xor
+    }
+}

src/ImageSharp.Drawing/Shapes/IntersectionRule.cs

@@ -4,7 +4,7 @@
 namespace SixLabors.ImageSharp.Drawing
 {
     /// <summary>
-    /// Rule for calulating intersection points.
+    /// Provides options for calculating intersection points.
     /// </summary>
     public enum IntersectionRule
     {

src/ImageSharp.Drawing/Shapes/OutlinePathExtensions.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-using SixLabors.ImageSharp.Drawing.PolygonClipper;
+using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing
 {
@@ -24,7 +24,8 @@ public static class OutlinePathExtensions
         /// <param name="width">The outline width.</param>
         /// <returns>A new <see cref="IPath"/> representing the outline.</returns>
         /// <exception cref="ClipperException">Thrown when an offset cannot be calculated.</exception>
-        public static IPath GenerateOutline(this IPath path, float width) => GenerateOutline(path, width, DefaultJointStyle, DefaultEndCapStyle);
+        public static IPath GenerateOutline(this IPath path, float width)
+            => GenerateOutline(path, width, DefaultJointStyle, DefaultEndCapStyle);
 
         /// <summary>
         /// Generates an outline of the path.
@@ -183,11 +184,7 @@ public static IPath GenerateOutline(this IPath path, float width, ReadOnlySpan<f
                         offset.AddPath(new ReadOnlySpan<PointF>(buffer.ToArray()), jointStyle, endCapStyle);
                     }
 
-                    online = !online;
-
                     buffer.Clear();
-                    patternPos = (patternPos + 1) % pattern.Length;
-                    targetLength = pattern[patternPos] * width;
                 }
             }
 

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

@@ -4,9 +4,8 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
-namespace SixLabors.ImageSharp.Drawing.PolygonClipper
+namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper
 {
     /// <summary>
     /// Library to clip polygons.
@@ -15,90 +14,65 @@ internal class Clipper
     {
         // To make the floating point polygons compatable with clipper we have to scale them.
         private const float ScalingFactor = 1000F;
-        private readonly Shapes.PolygonClipper.PolygonClipper polygonClipper;
+        private readonly PolygonClipper polygonClipper;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Clipper"/> class.
         /// </summary>
         public Clipper()
-            => this.polygonClipper = new Shapes.PolygonClipper.PolygonClipper();
+            => this.polygonClipper = new PolygonClipper();
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="Clipper" /> class.
+        /// Generates the clipped shapes from the previously provided paths.
         /// </summary>
-        /// <param name="shapes">The shapes.</param>
-        public Clipper(params ClippablePath[] shapes)
-            : this() => this.AddPaths(shapes);
-
-        /// <summary>
-        /// Executes the specified clip type.
-        /// </summary>
-        /// <returns>
-        /// Returns the <see cref="IPath" /> array containing the converted polygons.
-        /// </returns>
-        /// <exception cref="ClipperException">GenerateClippedShapes: Open paths have been disabled.</exception>
-        public IPath[] GenerateClippedShapes()
+        /// <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)
         {
             PathsF closedPaths = new();
             PathsF openPaths = new();
 
-            this.polygonClipper.Execute(ClipType.Difference, FillRule.EvenOdd, closedPaths, openPaths);
+            FillRule fillRule = rule == IntersectionRule.EvenOdd ? FillRule.EvenOdd : FillRule.NonZero;
+            this.polygonClipper.Execute(operation, fillRule, closedPaths, openPaths);
 
             var shapes = new IPath[closedPaths.Count + openPaths.Count];
-            const float scale = 1F / ScalingFactor;
 
+            int index = 0;
             for (int i = 0; i < closedPaths.Count; i++)
             {
-                var points = new PointF[closedPaths[i].Count];
+                PathF path = closedPaths[i];
+                var points = new PointF[path.Count];
 
-                for (int j = 0; j < closedPaths[i].Count; j++)
+                for (int j = 0; j < path.Count; j++)
                 {
-                    Vector2 v = closedPaths[i][j];
-                    points[j] = v * scale;
+                    points[j] = path[j] / ScalingFactor;
                 }
 
-                shapes[i] = new Polygon(new LinearLineSegment(points));
+                shapes[index++] = new Polygon(new LinearLineSegment(points));
             }
 
             for (int i = 0; i < openPaths.Count; i++)
             {
-                var points = new PointF[closedPaths[i].Count];
+                PathF path = openPaths[i];
+                var points = new PointF[path.Count];
 
-                for (int j = 0; j < closedPaths[i].Count; j++)
+                for (int j = 0; j < path.Count; j++)
                 {
-                    Vector2 v = closedPaths[i][j];
-                    points[j] = v * scale;
+                    points[j] = path[j] / ScalingFactor;
                 }
 
-                shapes[i] = new Path(new LinearLineSegment(points));
+                shapes[index++] = new Polygon(new LinearLineSegment(points));
             }
 
             return shapes;
         }
 
-        /// <summary>
-        /// Adds the paths.
-        /// </summary>
-        /// <param name="paths">The paths.</param>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
-        public void AddPaths(ClippablePath[] paths)
-        {
-            Guard.NotNull(paths, nameof(paths));
-
-            for (int i = 0; i < paths.Length; i++)
-            {
-                ref ClippablePath p = ref paths[i];
-
-                this.AddPath(p.Path, p.Type);
-            }
-        }
-
         /// <summary>
         /// Adds the shapes.
         /// </summary>
         /// <param name="paths">The paths.</param>
         /// <param name="clippingType">The clipping type.</param>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
         public void AddPaths(IEnumerable<IPath> paths, ClippingType clippingType)
         {
             Guard.NotNull(paths, nameof(paths));
@@ -114,7 +88,6 @@ public void AddPaths(IEnumerable<IPath> paths, ClippingType clippingType)
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="clippingType">The clipping type.</param>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
         public void AddPath(IPath path, ClippingType clippingType)
         {
             Guard.NotNull(path, nameof(path));
@@ -130,7 +103,6 @@ public void AddPath(IPath path, ClippingType clippingType)
         /// </summary>
         /// <param name="path">The path.</param>
         /// <param name="clippingType">Type of the poly.</param>
-        /// <exception cref="ClipperException">Open paths have been disabled.</exception>
         internal void AddPath(ISimplePath path, ClippingType clippingType)
         {
             ReadOnlySpan<PointF> vectors = path.Points.Span;

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

@@ -3,13 +3,20 @@
 
 using System;
 
-namespace SixLabors.ImageSharp.Drawing.PolygonClipper
+namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper
 {
     /// <summary>
     /// The exception that is thrown when an error occurs clipping a polygon.
     /// </summary>
     public class ClipperException : Exception
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClipperException"/> class.
+        /// </summary>
+        public ClipperException()
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ClipperException"/> class.
         /// </summary>
@@ -18,5 +25,16 @@ public ClipperException(string message)
             : base(message)
         {
         }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClipperException" /> class with a specified error message and a
+        /// reference to the inner exception that is the cause of this exception.</summary>
+        /// <param name="message">The error message that explains the reason for the exception. </param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a <see langword="null"/>
+        /// reference if no inner exception is specified. </param>
+        public ClipperException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
     }
 }