Port Clipper to use Vector2

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/Processors/Text/RichTextGlyphRenderer.cs

@@ -536,7 +536,7 @@ private Buffer2D<float> Render(IPath path)
                 0,
                 size.Height,
                 subpixelCount,
-                IntersectionRule.Nonzero,
+                IntersectionRule.NonZero,
                 this.memoryAllocator);
 
             try

src/ImageSharp.Drawing/Processing/ShapeOptions.cs

@@ -20,9 +20,9 @@ public ShapeOptions()
         /// <summary>
         /// Gets or sets a value indicating whether antialiasing should be applied.
         /// <para/>
-        /// Defaults to <see cref="IntersectionRule.OddEven"/>.
+        /// Defaults to <see cref="IntersectionRule.EvenOdd"/>.
         /// </summary>
-        public IntersectionRule IntersectionRule { get; set; } = IntersectionRule.OddEven;
+        public IntersectionRule IntersectionRule { get; set; } = IntersectionRule.EvenOdd;
 
         /// <inheritdoc/>
         public ShapeOptions DeepClone() => new(this);

src/ImageSharp.Drawing/Shapes/EndCapStyle.cs

@@ -22,5 +22,15 @@ public enum EndCapStyle
         /// The outlines ends squared off passed the end of the path.
         /// </summary>
         Square = 2,
+
+        /// <summary>
+        /// The outline is treated as a polygon.
+        /// </summary>
+        Polygon = 3,
+
+        /// <summary>
+        /// The outlines ends are joined and the path treated as a polyline
+        /// </summary>
+        Joined = 4
     }
 }

src/ImageSharp.Drawing/Shapes/IntersectionRule.cs

@@ -4,18 +4,18 @@
 namespace SixLabors.ImageSharp.Drawing
 {
     /// <summary>
-    /// Rule for calulating intersection points,
+    /// Rule for calulating intersection points.
     /// </summary>
     public enum IntersectionRule
     {
         /// <summary>
-        /// Use odd/even intersection rules, self intersection will cause holes.
+        /// Only odd numbered sub-regions are filled.
         /// </summary>
-        OddEven = 0,
+        EvenOdd = 0,
 
         /// <summary>
-        /// Nonzero rule treats intersecting holes as inside the path thus being ignored by intersections.
+        /// Only non-zero sub-regions are filled.
         /// </summary>
-        Nonzero = 1
+        NonZero = 1
     }
 }

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

@@ -0,0 +1,95 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Numerics;
+
+namespace SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper
+{
+    internal struct BoundsF
+    {
+        public float Left;
+        public float Top;
+        public float Right;
+        public float Bottom;
+
+        public BoundsF(float l, float t, float r, float b)
+        {
+            Guard.MustBeGreaterThanOrEqualTo(r, l, nameof(r));
+            Guard.MustBeGreaterThanOrEqualTo(b, t, nameof(r));
+
+            this.Left = l;
+            this.Top = t;
+            this.Right = r;
+            this.Bottom = b;
+        }
+
+        public BoundsF(BoundsF bounds)
+        {
+            this.Left = bounds.Left;
+            this.Top = bounds.Top;
+            this.Right = bounds.Right;
+            this.Bottom = bounds.Bottom;
+        }
+
+        public BoundsF(bool isValid)
+        {
+            if (isValid)
+            {
+                this.Left = 0;
+                this.Top = 0;
+                this.Right = 0;
+                this.Bottom = 0;
+            }
+            else
+            {
+                this.Left = float.MaxValue;
+                this.Top = float.MaxValue;
+                this.Right = -float.MaxValue;
+                this.Bottom = -float.MaxValue;
+            }
+        }
+
+        public float Width
+        {
+            get => this.Right - this.Left;
+            set => this.Right = this.Left + value;
+        }
+
+        public float Height
+        {
+            get => this.Bottom - this.Top;
+            set => this.Bottom = this.Top + value;
+        }
+
+        public bool IsEmpty()
+            => this.Bottom <= this.Top || this.Right <= this.Left;
+
+        public Vector2 MidPoint()
+            => new Vector2(this.Left + this.Right, this.Top + this.Bottom) * .5F;
+
+        public bool Contains(Vector2 pt)
+            => pt.X > this.Left
+            && pt.X < this.Right
+            && pt.Y > this.Top && pt.Y < this.Bottom;
+
+        public bool Contains(BoundsF bounds)
+            => bounds.Left >= this.Left
+            && bounds.Right <= this.Right
+            && bounds.Top >= this.Top
+            && bounds.Bottom <= this.Bottom;
+
+        public bool Intersects(BoundsF bounds)
+            => (Math.Max(this.Left, bounds.Left) < Math.Min(this.Right, bounds.Right))
+            && (Math.Max(this.Top, bounds.Top) < Math.Min(this.Bottom, bounds.Bottom));
+
+        public PathF AsPath()
+            => new(4)
+            {
+                new PointF(this.Left, this.Top),
+                new PointF(this.Right, this.Top),
+                new PointF(this.Right, this.Bottom),
+                new PointF(this.Left, this.Bottom)
+            };
+    }
+}

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

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-using Clipper2Lib;
+using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing.PolygonClipper
 {
@@ -13,14 +13,15 @@ namespace SixLabors.ImageSharp.Drawing.PolygonClipper
     /// </summary>
     internal class Clipper
     {
-        private const float ScalingFactor = 1000.0f;
-        private readonly object syncRoot = new();
-        private readonly Clipper64 innerClipper;
+        // 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;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Clipper"/> class.
         /// </summary>
-        public Clipper() => this.innerClipper = new Clipper64();
+        public Clipper()
+            => this.polygonClipper = new Shapes.PolygonClipper.PolygonClipper();
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Clipper" /> class.
@@ -38,29 +39,22 @@ public Clipper(params ClippablePath[] shapes)
         /// <exception cref="ClipperException">GenerateClippedShapes: Open paths have been disabled.</exception>
         public IPath[] GenerateClippedShapes()
         {
-            Paths64 closedPaths = new();
-            Paths64 openPaths = new();
+            PathsF closedPaths = new();
+            PathsF openPaths = new();
 
-            // TODO: Why are we locking?
-            lock (this.syncRoot)
-            {
-                this.innerClipper.Execute(ClipType.Difference, FillRule.EvenOdd, closedPaths, openPaths);
-            }
+            this.polygonClipper.Execute(ClipType.Difference, FillRule.EvenOdd, closedPaths, openPaths);
 
             var shapes = new IPath[closedPaths.Count + openPaths.Count];
+            const float scale = 1F / ScalingFactor;
 
             for (int i = 0; i < closedPaths.Count; i++)
             {
                 var points = new PointF[closedPaths[i].Count];
 
                 for (int j = 0; j < closedPaths[i].Count; j++)
                 {
-                    Point64 p = closedPaths[i][j];
-
-                    // to make the floating point polygons compatable with clipper we had
-                    // to scale them up to make them ints but still retain some level of precision
-                    // thus we have to scale them back down
-                    points[j] = new Vector2(p.X / ScalingFactor, p.Y / ScalingFactor);
+                    Vector2 v = closedPaths[i][j];
+                    points[j] = v * scale;
                 }
 
                 shapes[i] = new Polygon(new LinearLineSegment(points));
@@ -72,12 +66,8 @@ public IPath[] GenerateClippedShapes()
 
                 for (int j = 0; j < closedPaths[i].Count; j++)
                 {
-                    Point64 p = closedPaths[i][j];
-
-                    // to make the floating point polygons compatable with clipper we had
-                    // to scale them up to make them ints but still retain some level of precision
-                    // thus we have to scale them back down
-                    points[j] = new Vector2(p.X / ScalingFactor, p.Y / ScalingFactor);
+                    Vector2 v = closedPaths[i][j];
+                    points[j] = v * scale;
                 }
 
                 shapes[i] = new Path(new LinearLineSegment(points));
@@ -144,20 +134,14 @@ public void AddPath(IPath path, ClippingType clippingType)
         internal void AddPath(ISimplePath path, ClippingType clippingType)
         {
             ReadOnlySpan<PointF> vectors = path.Points.Span;
-            Path64 points = new(vectors.Length);
+            PathF points = new(vectors.Length);
             for (int i = 0; i < vectors.Length; i++)
             {
-                PointF v = vectors[i];
-                points.Add(new Point64(v.X * ScalingFactor, v.Y * ScalingFactor));
+                Vector2 v = vectors[i];
+                points.Add(v * ScalingFactor);
             }
 
-            PathType type = clippingType == ClippingType.Clip ? PathType.Clip : PathType.Subject;
-
-            // TODO: Why are we locking?
-            lock (this.syncRoot)
-            {
-                this.innerClipper.AddPath(points, type, !path.IsClosed);
-            }
+            this.polygonClipper.AddPath(points, clippingType, !path.IsClosed);
         }
     }
 }

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

@@ -3,7 +3,8 @@
 
 using System;
 using System.Linq;
-using Clipper2Lib;
+using System.Numerics;
+using SixLabors.ImageSharp.Drawing.Shapes.PolygonClipper;
 
 namespace SixLabors.ImageSharp.Drawing.PolygonClipper
 {
@@ -12,43 +13,40 @@ namespace SixLabors.ImageSharp.Drawing.PolygonClipper
     /// </summary>
     internal class ClipperOffset
     {
-        private const float ScalingFactor = 1000.0f;
-
-        private readonly Clipper2Lib.ClipperOffset innerClipperOffest;
-        private readonly object syncRoot = new();
+        // To make the floating point polygons compatable with clipper we have to scale them.
+        private const float ScalingFactor = 1000F;
+        private readonly PolygonOffsetter polygonClipperOffset;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ClipperOffset"/> class.
         /// </summary>
         /// <param name="meterLimit">meter limit</param>
         /// <param name="arcTolerance">arc tolerance</param>
         public ClipperOffset(double meterLimit = 2, double arcTolerance = 0.25)
-            => this.innerClipperOffest = new Clipper2Lib.ClipperOffset(meterLimit, arcTolerance);
+            => this.polygonClipperOffset = new((float)meterLimit, (float)arcTolerance);
 
         /// <summary>
-        /// Calcualte Offset
+        /// Calculates an offset polygon based on the given path and width.
         /// </summary>
         /// <param name="width">Width</param>
         /// <returns>path offset</returns>
-        /// <exception cref="ClipperException">Calculate: Couldn't caculate Offset</exception>
+        /// <exception cref="ClipperException">Calculate: Couldn't calculate the cffset.</exception>
         public ComplexPolygon Execute(float width)
         {
-            Paths64 tree = new();
-            lock (this.syncRoot)
-            {
-                this.innerClipperOffest.Execute(width * ScalingFactor, tree);
-            }
+            PathsF solution = new();
+            this.polygonClipperOffset.Execute(width * ScalingFactor, solution);
 
-            var polygons = new Polygon[tree.Count];
-            for (int i = 0; i < tree.Count; i++)
+            var polygons = new Polygon[solution.Count];
+            const float scale = 1F / ScalingFactor;
+            for (int i = 0; i < solution.Count; i++)
             {
-                Path64 pt = tree[i];
+                PathF pt = solution[i];
 
-                PointF[] points = pt.Select(p => new PointF(p.X / ScalingFactor, p.Y / ScalingFactor)).ToArray();
+                PointF[] points = pt.Select(p => (PointF)(p * scale)).ToArray();
                 polygons[i] = new Polygon(new LinearLineSegment(points));
             }
 
-            return new ComplexPolygon(polygons.ToArray());
+            return new ComplexPolygon(polygons);
         }
 
         /// <summary>
@@ -58,8 +56,17 @@ public ComplexPolygon Execute(float width)
         /// <param name="jointStyle">Joint Style</param>
         /// <param name="endCapStyle">Endcap Style</param>
         /// <exception cref="ClipperException">AddPath: Invalid Path</exception>
-        public void AddPath(ReadOnlySpan<PointF> pathPoints, JointStyle jointStyle, EndCapStyle endCapStyle) =>
-            this.AddPath(pathPoints, jointStyle, Convert(endCapStyle));
+        public void AddPath(ReadOnlySpan<PointF> pathPoints, JointStyle jointStyle, EndCapStyle endCapStyle)
+        {
+            PathF points = new(pathPoints.Length);
+            for (int i = 0; i < pathPoints.Length; i++)
+            {
+                Vector2 v = pathPoints[i];
+                points.Add(v * ScalingFactor);
+            }
+
+            this.polygonClipperOffset.AddPath(points, jointStyle, endCapStyle);
+        }
 
         /// <summary>
         /// Adds the path.
@@ -87,46 +94,7 @@ public void AddPath(IPath path, JointStyle jointStyle, EndCapStyle endCapStyle)
         private void AddPath(ISimplePath path, JointStyle jointStyle, EndCapStyle endCapStyle)
         {
             ReadOnlySpan<PointF> vectors = path.Points.Span;
-            EndType type = path.IsClosed ? EndType.Joined : Convert(endCapStyle);
-            this.AddPath(vectors, jointStyle, type);
+            this.AddPath(vectors, jointStyle, path.IsClosed ? EndCapStyle.Joined : endCapStyle);
         }
-
-        /// <summary>
-        /// Adds the path.
-        /// </summary>
-        /// <param name="pathPoints">The path points</param>
-        /// <param name="jointStyle">Joint Style</param>
-        /// <param name="endCapStyle">Endcap Style</param>
-        /// <exception cref="ClipperException">AddPath: Invalid Path</exception>
-        private void AddPath(ReadOnlySpan<PointF> pathPoints, JointStyle jointStyle, EndType endCapStyle)
-        {
-            Path64 points = new();
-            foreach (PointF v in pathPoints)
-            {
-                points.Add(new Point64(v.X * ScalingFactor, v.Y * ScalingFactor));
-            }
-
-            // TODO: Why are we locking?
-            lock (this.syncRoot)
-            {
-                this.innerClipperOffest.AddPath(points, Convert(jointStyle), endCapStyle);
-            }
-        }
-
-        private static JoinType Convert(JointStyle style)
-            => style switch
-            {
-                JointStyle.Round => JoinType.Round,
-                JointStyle.Miter => JoinType.Miter,
-                _ => JoinType.Square,
-            };
-
-        private static EndType Convert(EndCapStyle style)
-            => style switch
-            {
-                EndCapStyle.Round => EndType.Round,
-                EndCapStyle.Square => EndType.Square,
-                _ => EndType.Butt,
-            };
     }
 }