Make PointAlongPath internal

Author: JimBobSquarePants

src/ImageSharp.Drawing/Shapes/ComplexPolygon.cs

@@ -190,7 +190,17 @@ int IPathInternals.FindIntersections(
                 totalAdded += position;
             }
 
-            Span<float> distances = stackalloc float[totalAdded];
+            // Avoid pool overhead for short runs.
+            // This method can be called in high volume.
+            const int MaxStackSize = 1024 / sizeof(float);
+            float[] rentedFromPool = null;
+            Span<float> buffer =
+                totalAdded > MaxStackSize
+                ? (rentedFromPool = ArrayPool<float>.Shared.Rent(totalAdded))
+                : stackalloc float[MaxStackSize];
+
+            Span<float> distances = buffer.Slice(0, totalAdded);
+
             for (int i = 0; i < totalAdded; i++)
             {
                 distances[i] = Vector2.DistanceSquared(start, intersections[i]);
@@ -205,6 +215,11 @@ int IPathInternals.FindIntersections(
                 totalAdded = InternalPath.ApplyNonZeroIntersectionRules(activeIntersections, activeOrientations);
             }
 
+            if (rentedFromPool != null)
+            {
+                ArrayPool<float>.Shared.Return(rentedFromPool);
+            }
+
             return totalAdded;
         }
 
@@ -248,7 +263,7 @@ public IPath Transform(Matrix3x2 matrix)
             int i = 0;
             foreach (IPath s in this.Paths)
             {
-                shapes[i++] = (IPath)s.Transform(matrix);
+                shapes[i++] = s.Transform(matrix);
             }
 
             return new ComplexPolygon(shapes);
@@ -288,7 +303,7 @@ public IPath AsClosedPath()
                 var paths = new IPath[this.paths.Length];
                 for (int i = 0; i < this.paths.Length; i++)
                 {
-                    paths[i] = (IPath)this.paths[i].AsClosedPath();
+                    paths[i] = this.paths[i].AsClosedPath();
                 }
 
                 return new ComplexPolygon(paths);
@@ -298,23 +313,22 @@ public IPath AsClosedPath()
         /// <summary>
         /// Calculates the point a certain distance a path.
         /// </summary>
-        /// <param name="distanceAlongPath">The distance along the path to find details of.</param>
+        /// <param name="distance">The distance along the path to find details of.</param>
         /// <returns>
         /// Returns details about a point along a path.
         /// </returns>
-        public SegmentInfo PointAlongPath(float distanceAlongPath)
+        SegmentInfo IPathInternals.PointAlongPath(float distance)
         {
-            distanceAlongPath %= this.Length;
-
-            foreach (IPath p in this.Paths)
+            distance %= this.Length;
+            foreach (InternalPath p in this.internalPaths)
             {
-                if (p.Length >= distanceAlongPath)
+                if (p.Length >= distance)
                 {
-                    return p.PointAlongPath(distanceAlongPath);
+                    return p.PointAlongPath(distance);
                 }
 
-                // reduce it before trying the next path
-                distanceAlongPath -= p.Length;
+                // Reduce it before trying the next path
+                distance -= p.Length;
             }
 
             // TODO: Perf. Throwhelper

src/ImageSharp.Drawing/Shapes/EllipsePolygon.cs

@@ -163,10 +163,9 @@ int IPathInternals.FindIntersections(
         public bool Contains(PointF point) => this.innerPath.PointInPolygon(point);
 
         /// <inheritdoc />
-        public SegmentInfo PointAlongPath(float distanceAlongPath) =>
-
-            // TODO switch this out to a calculated algorithm
-            this.innerPath.PointAlongPath(distanceAlongPath);
+        // TODO switch this out to a calculated algorithm
+        SegmentInfo IPathInternals.PointAlongPath(float distance)
+            => this.innerPath.PointAlongPath(distance);
 
         private static CubicBezierLineSegment CreateSegment(Vector2 location, SizeF size)
         {

src/ImageSharp.Drawing/Shapes/IPath.cs

@@ -26,15 +26,6 @@ public interface IPath
         /// </summary>
         float Length { get; }
 
-        /// <summary>
-        /// Calculates the point a certain distance along a path.
-        /// </summary>
-        /// <param name="distanceAlongPath">The distance along the path to find details of.</param>
-        /// <returns>
-        /// Returns details about a point along a path.
-        /// </returns>
-        SegmentInfo PointAlongPath(float distanceAlongPath);
-
         /// <summary>
         /// Calculates the distance along and away from the path for a specified point.
         /// </summary>

src/ImageSharp.Drawing/Shapes/IPathInternals.cs

@@ -52,5 +52,14 @@ int FindIntersections(
             Span<PointF> intersections,
             Span<PointOrientation> orientations,
             IntersectionRule intersectionRule);
+
+        /// <summary>
+        /// Returns information about a point at a given distance along a path.
+        /// </summary>
+        /// <param name="distance">The distance along the path to return details for.</param>
+        /// <returns>
+        /// The segment information.
+        /// </returns>
+        SegmentInfo PointAlongPath(float distance);
     }
 }

src/ImageSharp.Drawing/Shapes/InternalPath.cs

@@ -245,164 +245,151 @@ public int FindIntersectionsWithOrientation(
             int position = 0;
             Vector2 lastPoint = MaxVector;
 
-            int max = this.points.Length;
-            Span<PassPointData> precaclulateSpan;
-            PassPointData[] precaclulate = null;
-
-            // Avoid pool overhead for short numbers.
+            // Avoid pool overhead for short runs.
             // This method can be called in high volume.
-            unsafe
-            {
-                if (max < (1024 / sizeof(PassPointData)))
+            int pointsLength = this.points.Length;
+            int maxStackSize = 1024 / Unsafe.SizeOf<PassPointData>();
+            PassPointData[] rentedFromPool = null;
+            Span<PassPointData> buffer =
+                pointsLength > maxStackSize
+                ? (rentedFromPool = ArrayPool<PassPointData>.Shared.Rent(pointsLength))
+                : stackalloc PassPointData[maxStackSize];
+
+            Span<PassPointData> precalculate = buffer.Slice(0, pointsLength);
+
+            // Pre calculate relative orientations X places ahead and behind
+            Vector2 startToEnd = end - start;
+            PointOrientation prevOrientation = CalulateOrientation(startToEnd, this.points[polyCorners - 1].Point - end);
+            PointOrientation nextOrientation = CalulateOrientation(startToEnd, this.points[0].Point - end);
+            PointOrientation nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[1].Point - end);
+
+            // iterate over all points and precalculate data about each, pre cacluating it relative orientation
+            for (int i = 0; i < polyCorners && count > 0; i++)
+            {
+                ref Segment edge = ref this.points[i].Segment;
+
+                // shift all orientations along but one place and fill in the last one
+                PointOrientation pointOrientation = nextOrientation;
+                nextOrientation = nextPlus1Orientation;
+                nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[WrapArrayIndex(i + 2, this.points.Length)].Point - end);
+
+                // should this point cause the last matched point to be excluded
+                bool removeLastIntersection = nextOrientation == PointOrientation.Collinear &&
+                                              pointOrientation == PointOrientation.Collinear &&
+                                              nextPlus1Orientation != prevOrientation &&
+                                              (this.closedPath || i > 0) &&
+                                              (IsOnSegment(target, edge.Start) || IsOnSegment(target, edge.End));
+
+                // is there any chance the segments will intersection (do their bounding boxes touch)
+                bool doIntersect = false;
+                if (pointOrientation == PointOrientation.Collinear || pointOrientation != nextOrientation)
                 {
-                    PassPointData* points = stackalloc PassPointData[max];
-                    precaclulateSpan = new Span<PassPointData>(points, max);
+                    doIntersect = (edge.Min.X - Epsilon) <= target.Max.X &&
+                                  (edge.Max.X + Epsilon) >= target.Min.X &&
+                                  (edge.Min.Y - Epsilon) <= target.Max.Y &&
+                                  (edge.Max.Y + Epsilon) >= target.Min.Y;
                 }
-                else
+
+                precalculate[i] = new PassPointData
                 {
-                    precaclulate = ArrayPool<PassPointData>.Shared.Rent(max);
-                    precaclulateSpan = precaclulate.AsSpan(0, this.points.Length);
-                }
+                    RemoveLastIntersectionAndSkip = removeLastIntersection,
+                    RelativeOrientation = pointOrientation,
+                    DoIntersect = doIntersect
+                };
+
+                prevOrientation = pointOrientation;
             }
 
-            try
+            // seed the last point for deduping at begining of closed line
+            if (this.closedPath)
             {
-                // Pre calculate relative orientations X places ahead and behind
-                Vector2 startToEnd = end - start;
-                PointOrientation prevOrientation = CalulateOrientation(startToEnd, this.points[polyCorners - 1].Point - end);
-                PointOrientation nextOrientation = CalulateOrientation(startToEnd, this.points[0].Point - end);
-                PointOrientation nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[1].Point - end);
+                int prev = polyCorners - 1;
 
-                // iterate over all points and precalculate data about each, pre cacluating it relative orientation
-                for (int i = 0; i < polyCorners && count > 0; i++)
+                if (precalculate[prev].DoIntersect)
                 {
-                    ref Segment edge = ref this.points[i].Segment;
-
-                    // shift all orientations along but one place and fill in the last one
-                    PointOrientation pointOrientation = nextOrientation;
-                    nextOrientation = nextPlus1Orientation;
-                    nextPlus1Orientation = CalulateOrientation(startToEnd, this.points[WrapArrayIndex(i + 2, this.points.Length)].Point - end);
-
-                    // should this point cause the last matched point to be excluded
-                    bool removeLastIntersection = nextOrientation == PointOrientation.Collinear &&
-                                                  pointOrientation == PointOrientation.Collinear &&
-                                                  nextPlus1Orientation != prevOrientation &&
-                                                  (this.closedPath || i > 0) &&
-                                                  (IsOnSegment(target, edge.Start) || IsOnSegment(target, edge.End));
-
-                    // is there any chance the segments will intersection (do their bounding boxes touch)
-                    bool doIntersect = false;
-                    if (pointOrientation == PointOrientation.Collinear || pointOrientation != nextOrientation)
-                    {
-                        doIntersect = (edge.Min.X - Epsilon) <= target.Max.X &&
-                                      (edge.Max.X + Epsilon) >= target.Min.X &&
-                                      (edge.Min.Y - Epsilon) <= target.Max.Y &&
-                                      (edge.Max.Y + Epsilon) >= target.Min.Y;
-                    }
-
-                    precaclulateSpan[i] = new PassPointData
-                    {
-                        RemoveLastIntersectionAndSkip = removeLastIntersection,
-                        RelativeOrientation = pointOrientation,
-                        DoIntersect = doIntersect
-                    };
-
-                    prevOrientation = pointOrientation;
+                    lastPoint = FindIntersection(this.points[prev].Segment, target);
                 }
+            }
 
-                // seed the last point for deduping at begining of closed line
-                if (this.closedPath)
-                {
-                    int prev = polyCorners - 1;
+            for (int i = 0; i < polyCorners && count > 0; i++)
+            {
+                int next = WrapArrayIndex(i + 1, this.points.Length);
 
-                    if (precaclulateSpan[prev].DoIntersect)
+                if (precalculate[i].RemoveLastIntersectionAndSkip)
+                {
+                    if (position > 0)
                     {
-                        lastPoint = FindIntersection(this.points[prev].Segment, target);
+                        position--;
+                        count++;
                     }
+
+                    continue;
                 }
 
-                for (int i = 0; i < polyCorners && count > 0; i++)
+                if (precalculate[i].DoIntersect)
                 {
-                    int next = WrapArrayIndex(i + 1, this.points.Length);
-
-                    if (precaclulateSpan[i].RemoveLastIntersectionAndSkip)
+                    Vector2 point = FindIntersection(this.points[i].Segment, target);
+                    if (point != MaxVector)
                     {
-                        if (position > 0)
+                        if (lastPoint.Equivalent(point, Epsilon2))
                         {
-                            position--;
-                            count++;
-                        }
+                            lastPoint = MaxVector;
 
-                        continue;
-                    }
+                            int last = WrapArrayIndex(i - 1 + polyCorners, polyCorners);
 
-                    if (precaclulateSpan[i].DoIntersect)
-                    {
-                        Vector2 point = FindIntersection(this.points[i].Segment, target);
-                        if (point != MaxVector)
-                        {
-                            if (lastPoint.Equivalent(point, Epsilon2))
+                            // hit the same point a second time do we need to remove the old one if just clipping
+                            if (this.points[next].Point.Equivalent(point, Epsilon))
                             {
-                                lastPoint = MaxVector;
-
-                                int last = WrapArrayIndex(i - 1 + polyCorners, polyCorners);
-
-                                // hit the same point a second time do we need to remove the old one if just clipping
-                                if (this.points[next].Point.Equivalent(point, Epsilon))
-                                {
-                                    next = i;
-                                }
+                                next = i;
+                            }
 
-                                if (this.points[last].Point.Equivalent(point, Epsilon))
-                                {
-                                    last = i;
-                                }
+                            if (this.points[last].Point.Equivalent(point, Epsilon))
+                            {
+                                last = i;
+                            }
 
-                                PointOrientation side = precaclulateSpan[next].RelativeOrientation;
-                                PointOrientation side2 = precaclulateSpan[last].RelativeOrientation;
+                            PointOrientation side = precalculate[next].RelativeOrientation;
+                            PointOrientation side2 = precalculate[last].RelativeOrientation;
 
-                                if (side != side2)
-                                {
-                                    // differnet side we skip adding as we are passing through it
-                                    continue;
-                                }
+                            if (side != side2)
+                            {
+                                // differnet side we skip adding as we are passing through it
+                                continue;
                             }
-
-                            // only need to track this during odd non zero rulings
-                            orientations[position] = precaclulateSpan[i].RelativeOrientation;
-                            intersections[position] = point;
-                            position++;
-                            count--;
                         }
 
-                        lastPoint = point;
-                    }
-                    else
-                    {
-                        lastPoint = MaxVector;
+                        // only need to track this during odd non zero rulings
+                        orientations[position] = precalculate[i].RelativeOrientation;
+                        intersections[position] = point;
+                        position++;
+                        count--;
                     }
-                }
 
-                Vector2 startVector = start;
-                Span<float> distances = stackalloc float[position];
-                for (int i = 0; i < position; i++)
+                    lastPoint = point;
+                }
+                else
                 {
-                    distances[i] = Vector2.DistanceSquared(startVector, intersections[i]);
+                    lastPoint = MaxVector;
                 }
+            }
 
-                Span<PointF> activeBuffer = intersections.Slice(0, position);
-                Span<PointOrientation> activeOrientationsSpan = orientations.Slice(0, position);
-                SortUtility.Sort(distances, activeBuffer, activeOrientationsSpan);
-
-                return position;
+            Vector2 startVector = start;
+            Span<float> distances = stackalloc float[position];
+            for (int i = 0; i < distances.Length; i++)
+            {
+                distances[i] = Vector2.DistanceSquared(startVector, intersections[i]);
             }
-            finally
+
+            Span<PointF> activeBuffer = intersections.Slice(0, position);
+            Span<PointOrientation> activeOrientationsSpan = orientations.Slice(0, position);
+            SortUtility.Sort(distances, activeBuffer, activeOrientationsSpan);
+
+            if (rentedFromPool != null)
             {
-                if (precaclulate != null)
-                {
-                    ArrayPool<PassPointData>.Shared.Return(precaclulate);
-                }
+                ArrayPool<PassPointData>.Shared.Return(rentedFromPool);
             }
+
+            return position;
         }
 
         internal static int ApplyNonZeroIntersectionRules(Span<PointF> intersections, Span<PointOrientation> orientations)