Migrate intersection code to internal API

Author: JimBobSquarePants

src/ImageSharp.Drawing/Processing/PathGradientBrush.cs

@@ -166,7 +166,7 @@ public Edge(Path path, Color startColor, Color endColor)
                 Span<PointF> intersections,
                 Span<PointOrientation> orientations)
             {
-                int pathIntersections = this.Path.FindIntersections(
+                int pathIntersections = ((IPathInternals)this.Path).FindIntersections(
                     start,
                     end,
                     intersections.Slice(0, this.Path.MaxIntersections),

src/ImageSharp.Drawing/Shapes/ComplexPolygon.cs

@@ -11,13 +11,15 @@
 namespace SixLabors.ImageSharp.Drawing
 {
     /// <summary>
-    /// Represents a complex polygon made up of one or more shapes overlayed on each other, where overlaps causes holes.
+    /// Represents a complex polygon made up of one or more shapes overlayed on each other,
+    /// where overlaps causes holes.
     /// </summary>
     /// <seealso cref="IPath" />
-    public sealed class ComplexPolygon : IPath, IInternalPathOwner
+    public sealed class ComplexPolygon : IPath, IPathInternals, IInternalPathOwner
     {
         private readonly IPath[] paths;
-        private List<InternalPath> internalPaths = null;
+        private readonly List<InternalPath> internalPaths;
+        private readonly int maxIntersections;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ComplexPolygon" /> class.
@@ -34,7 +36,10 @@ public ComplexPolygon(IEnumerable<IPath> paths)
         /// <param name="paths">The paths.</param>
         public ComplexPolygon(params IPath[] paths)
         {
-            this.paths = paths ?? throw new ArgumentNullException(nameof(paths));
+            Guard.NotNull(paths, nameof(paths));
+
+            this.paths = paths;
+            this.internalPaths = new List<InternalPath>(this.paths.Length);
 
             if (paths.Length > 0)
             {
@@ -45,39 +50,45 @@ public ComplexPolygon(params IPath[] paths)
                 float length = 0;
                 int intersections = 0;
 
-                foreach (IPath s in this.paths)
+                foreach (IPath p in this.paths)
                 {
-                    length += s.Length;
-                    if (s.Bounds.Left < minX)
+                    length += p.Length;
+                    if (p.Bounds.Left < minX)
                     {
-                        minX = s.Bounds.Left;
+                        minX = p.Bounds.Left;
                     }
 
-                    if (s.Bounds.Right > maxX)
+                    if (p.Bounds.Right > maxX)
                     {
-                        maxX = s.Bounds.Right;
+                        maxX = p.Bounds.Right;
                     }
 
-                    if (s.Bounds.Top < minY)
+                    if (p.Bounds.Top < minY)
                     {
-                        minY = s.Bounds.Top;
+                        minY = p.Bounds.Top;
                     }
 
-                    if (s.Bounds.Bottom > maxY)
+                    if (p.Bounds.Bottom > maxY)
                     {
-                        maxY = s.Bounds.Bottom;
+                        maxY = p.Bounds.Bottom;
                     }
 
-                    intersections += s.MaxIntersections;
+                    foreach (ISimplePath s in p.Flatten())
+                    {
+                        var ip = new InternalPath(s.Points, s.IsClosed);
+                        intersections += ip.PointCount;
+
+                        this.internalPaths.Add(ip);
+                    }
                 }
 
-                this.MaxIntersections = intersections;
+                this.maxIntersections = intersections;
                 this.Length = length;
                 this.Bounds = new RectangleF(minX, minY, maxX - minX, maxY - minY);
             }
             else
             {
-                this.MaxIntersections = 0;
+                this.maxIntersections = 0;
                 this.Length = 0;
                 this.Bounds = RectangleF.Empty;
             }
@@ -111,13 +122,8 @@ public ComplexPolygon(params IPath[] paths)
         /// </value>
         public RectangleF Bounds { get; }
 
-        /// <summary>
-        /// Gets the maximum number intersections that a shape can have when testing a line.
-        /// </summary>
-        /// <value>
-        /// The maximum intersections.
-        /// </value>
-        public int MaxIntersections { get; }
+        /// <inheritdoc/>
+        int IPathInternals.MaxIntersections => this.maxIntersections;
 
         /// <summary>
         /// The distance of the point from the outline of the shape, if the value is negative it is inside the polygon bounds
@@ -163,19 +169,17 @@ public PointInfo Distance(PointF point)
         }
 
         /// <inheritdoc />
-        public int FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
-            => this.FindIntersections(start, end, intersections, orientations, IntersectionRule.OddEven);
+        int IPathInternals.FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
+            => ((IPathInternals)this).FindIntersections(start, end, intersections, orientations, IntersectionRule.OddEven);
 
         /// <inheritdoc />
-        public int FindIntersections(
+        int IPathInternals.FindIntersections(
             PointF start,
             PointF end,
             Span<PointF> intersections,
             Span<PointOrientation> orientations,
             IntersectionRule intersectionRule)
         {
-            this.EnsureInternalPathsInitalized();
-
             int totalAdded = 0;
             foreach (InternalPath ip in this.internalPaths)
             {
@@ -204,29 +208,6 @@ public int FindIntersections(
             return totalAdded;
         }
 
-        private void EnsureInternalPathsInitalized()
-        {
-            if (this.internalPaths == null)
-            {
-                lock (this.paths)
-                {
-                    if (this.internalPaths == null)
-                    {
-                        this.internalPaths = new List<InternalPath>(this.paths.Length);
-
-                        foreach (IPath p in this.paths)
-                        {
-                            foreach (ISimplePath s in p.Flatten())
-                            {
-                                var ip = new InternalPath(s.Points, s.IsClosed);
-                                this.internalPaths.Add(ip);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
         /// <summary>
         /// Determines whether the <see cref="IPath" /> contains the specified point
         /// </summary>
@@ -267,7 +248,7 @@ public IPath Transform(Matrix3x2 matrix)
             int i = 0;
             foreach (IPath s in this.Paths)
             {
-                shapes[i++] = s.Transform(matrix);
+                shapes[i++] = (IPath)s.Transform(matrix);
             }
 
             return new ComplexPolygon(shapes);
@@ -307,7 +288,7 @@ public IPath AsClosedPath()
                 var paths = new IPath[this.paths.Length];
                 for (int i = 0; i < this.paths.Length; i++)
                 {
-                    paths[i] = this.paths[i].AsClosedPath();
+                    paths[i] = (IPath)this.paths[i].AsClosedPath();
                 }
 
                 return new ComplexPolygon(paths);
@@ -336,14 +317,12 @@ public SegmentInfo PointAlongPath(float distanceAlongPath)
                 distanceAlongPath -= p.Length;
             }
 
+            // TODO: Perf. Throwhelper
             throw new InvalidOperationException("Should not be possible to reach this line");
         }
 
         /// <inheritdoc/>
         IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath()
-        {
-            this.EnsureInternalPathsInitalized();
-            return this.internalPaths;
-        }
+            => this.internalPaths;
     }
 }

src/ImageSharp.Drawing/Shapes/EllipsePolygon.cs

@@ -10,7 +10,7 @@ namespace SixLabors.ImageSharp.Drawing
     /// <summary>
     /// An elliptical shape made up of a single path made up of one of more <see cref="ILineSegment"/>s.
     /// </summary>
-    public class EllipsePolygon : IPath, ISimplePath, IInternalPathOwner
+    public class EllipsePolygon : IPath, ISimplePath, IPathInternals, IInternalPathOwner
     {
         private readonly InternalPath innerPath;
         private readonly CubicBezierLineSegment segment;
@@ -85,7 +85,7 @@ private EllipsePolygon(CubicBezierLineSegment segment)
         /// <summary>
         /// Gets the maximum number intersections that a shape can have when testing a line.
         /// </summary>
-        int IPath.MaxIntersections => this.innerPath.PointCount;
+        int IPathInternals.MaxIntersections => this.innerPath.PointCount;
 
         /// <inheritdoc />
         public float Length => this.innerPath.Length;
@@ -141,11 +141,11 @@ public IEnumerable<ISimplePath> Flatten()
         }
 
         /// <inheritdoc/>
-        int IPath.FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
+        int IPathInternals.FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations)
             => this.innerPath.FindIntersections(start, end, intersections, orientations, IntersectionRule.OddEven);
 
         /// <inheritdoc/>
-        int IPath.FindIntersections(
+        int IPathInternals.FindIntersections(
             PointF start,
             PointF end,
             Span<PointF> intersections,
@@ -211,6 +211,7 @@ private static CubicBezierLineSegment CreateSegment(Vector2 location, SizeF size
         }
 
         /// <inheritdoc/>
-        IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath() => new[] { this.innerPath };
+        IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath()
+            => new[] { this.innerPath };
     }
 }

src/ImageSharp.Drawing/Shapes/IInternalPathOwner.cs

@@ -12,11 +12,9 @@ namespace SixLabors.ImageSharp.Drawing
     internal interface IInternalPathOwner
     {
         /// <summary>
-        /// Returns the rings as a list of <see cref="InternalPath"/>-s.
+        /// Returns the rings as a readonly collection of <see cref="InternalPath"/> elements.
         /// </summary>
-        /// <returns>The list</returns>
+        /// <returns>The <see cref="IReadOnlyList{T}"/>.</returns>
         IReadOnlyList<InternalPath> GetRingsAsInternalPath();
-
-        // TODO: We may want to reconfigure StyleCop rules for internals to avoid unnecessary redundant trivial code comments like in this file.
     }
 }

src/ImageSharp.Drawing/Shapes/IPath.cs

@@ -1,7 +1,6 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-using System;
 using System.Collections.Generic;
 using System.Numerics;
 
@@ -18,15 +17,10 @@ public interface IPath
         PathTypes PathType { get; }
 
         /// <summary>
-        /// Gets the bounds enclosing the path
+        /// Gets the bounds enclosing the path.
         /// </summary>
         RectangleF Bounds { get; }
 
-        /// <summary>
-        /// Gets the maximum number intersections that a shape can have when testing a line.
-        /// </summary>
-        int MaxIntersections { get; }
-
         /// <summary>
         /// Gets the length of the path.
         /// </summary>
@@ -56,44 +50,6 @@ public interface IPath
         /// <returns>Returns the current <see cref="IPath" /> as simple linear path.</returns>
         IEnumerable<ISimplePath> Flatten();
 
-        /// <summary>
-        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
-        /// populate a buffer for all points on the polygon that the line intersects.
-        /// </summary>
-        /// <param name="start">The start position.</param>
-        /// <param name="end">The end position.</param>
-        /// <param name="intersections">The buffer for storing each intersection.</param>
-        /// <param name="orientations">
-        /// The buffer for storing the orientation of each intersection.
-        /// Must be the same length as <paramref name="intersections"/>.
-        /// </param>
-        /// <returns>
-        /// The number of intersections found.
-        /// </returns>
-        int FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations);
-
-        /// <summary>
-        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
-        /// populate a buffer for all points on the polygon that the line intersects.
-        /// </summary>
-        /// <param name="start">The start position.</param>
-        /// <param name="end">The end position.</param>
-        /// <param name="intersections">The buffer for storing each intersection.</param>
-        /// <param name="orientations">
-        /// The buffer for storing the orientation of each intersection.
-        /// Must be the same length as <paramref name="intersections"/>.
-        /// </param>
-        /// <param name="intersectionRule">How intersections should be handled.</param>
-        /// <returns>
-        /// The number of intersections found.
-        /// </returns>
-        int FindIntersections(
-            PointF start,
-            PointF end,
-            Span<PointF> intersections,
-            Span<PointOrientation> orientations,
-            IntersectionRule intersectionRule);
-
         /// <summary>
         /// Determines whether the <see cref="IPath"/> contains the specified point
         /// </summary>

src/ImageSharp.Drawing/Shapes/IPathInternals.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+
+namespace SixLabors.ImageSharp.Drawing
+{
+    /// <summary>
+    /// An interface for internal operations we don't want to expose on <see cref="IPath"/>.
+    /// </summary>
+    internal interface IPathInternals : IPath
+    {
+        /// <summary>
+        /// Gets the maximum number intersections that a shape can have when testing a line.
+        /// </summary>
+        int MaxIntersections { get; }
+
+        /// <summary>
+        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
+        /// populate a buffer for all points on the polygon that the line intersects.
+        /// </summary>
+        /// <param name="start">The start position.</param>
+        /// <param name="end">The end position.</param>
+        /// <param name="intersections">The buffer for storing each intersection.</param>
+        /// <param name="orientations">
+        /// The buffer for storing the orientation of each intersection.
+        /// Must be the same length as <paramref name="intersections"/>.
+        /// </param>
+        /// <returns>
+        /// The number of intersections found.
+        /// </returns>
+        int FindIntersections(PointF start, PointF end, Span<PointF> intersections, Span<PointOrientation> orientations);
+
+        /// <summary>
+        /// Based on a line described by <paramref name="start"/> and <paramref name="end"/>
+        /// populate a buffer for all points on the polygon that the line intersects.
+        /// </summary>
+        /// <param name="start">The start position.</param>
+        /// <param name="end">The end position.</param>
+        /// <param name="intersections">The buffer for storing each intersection.</param>
+        /// <param name="orientations">
+        /// The buffer for storing the orientation of each intersection.
+        /// Must be the same length as <paramref name="intersections"/>.
+        /// </param>
+        /// <param name="intersectionRule">How intersections should be handled.</param>
+        /// <returns>
+        /// The number of intersections found.
+        /// </returns>
+        int FindIntersections(
+            PointF start,
+            PointF end,
+            Span<PointF> intersections,
+            Span<PointOrientation> orientations,
+            IntersectionRule intersectionRule);
+    }
+}