Lazy-init InternalPaths and Bounds in ComplexPolygon

Author: TechPizzaDev

src/ImageSharp.Drawing/Shapes/ComplexPolygon.cs

@@ -2,6 +2,7 @@
 // Licensed under the Six Labors Split License.
 
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 
 namespace SixLabors.ImageSharp.Drawing;
@@ -14,8 +15,9 @@ namespace SixLabors.ImageSharp.Drawing;
 public sealed class ComplexPolygon : IPath, IPathInternals, IInternalPathOwner
 {
     private readonly IPath[] paths;
-    private readonly List<InternalPath> internalPaths;
-    private readonly float length;
+    private List<InternalPath>? internalPaths;
+    private float length;
+    private RectangleF? bounds;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ComplexPolygon"/> class.
@@ -45,53 +47,10 @@ public ComplexPolygon(params IPath[] paths)
         Guard.NotNull(paths, nameof(paths));
 
         this.paths = paths;
-        this.internalPaths = new List<InternalPath>(this.paths.Length);
-
-        if (paths.Length > 0)
-        {
-            float minX = float.MaxValue;
-            float maxX = float.MinValue;
-            float minY = float.MaxValue;
-            float maxY = float.MinValue;
-            float length = 0;
-
-            foreach (IPath p in this.paths)
-            {
-                if (p.Bounds.Left < minX)
-                {
-                    minX = p.Bounds.Left;
-                }
-
-                if (p.Bounds.Right > maxX)
-                {
-                    maxX = p.Bounds.Right;
-                }
-
-                if (p.Bounds.Top < minY)
-                {
-                    minY = p.Bounds.Top;
-                }
-
-                if (p.Bounds.Bottom > maxY)
-                {
-                    maxY = p.Bounds.Bottom;
-                }
-
-                foreach (ISimplePath s in p.Flatten())
-                {
-                    InternalPath ip = new(s.Points, s.IsClosed);
-                    length += ip.Length;
-                    this.internalPaths.Add(ip);
-                }
-            }
 
-            this.length = length;
-            this.Bounds = new RectangleF(minX, minY, maxX - minX, maxY - minY);
-        }
-        else
+        if (paths.Length == 0)
         {
-            this.length = 0;
-            this.Bounds = RectangleF.Empty;
+            this.bounds = RectangleF.Empty;
         }
 
         this.PathType = PathTypes.Mixed;
@@ -106,7 +65,7 @@ public ComplexPolygon(params IPath[] paths)
     public IEnumerable<IPath> Paths => this.paths;
 
     /// <inheritdoc/>
-    public RectangleF Bounds { get; }
+    public RectangleF Bounds => this.bounds ??= this.CalcBounds();
 
     /// <inheritdoc/>
     public IPath Transform(Matrix3x2 matrix)
@@ -118,10 +77,10 @@ public IPath Transform(Matrix3x2 matrix)
         }
 
         IPath[] shapes = new IPath[this.paths.Length];
-        int i = 0;
-        foreach (IPath s in this.Paths)
+
+        for (int i = 0; i < shapes.Length; i++)
         {
-            shapes[i++] = s.Transform(matrix);
+            shapes[i] = this.paths[i].Transform(matrix);
         }
 
         return new ComplexPolygon(shapes);
@@ -159,6 +118,11 @@ public IPath AsClosedPath()
     /// <inheritdoc/>
     SegmentInfo IPathInternals.PointAlongPath(float distance)
     {
+        if (this.internalPaths == null)
+        {
+            this.InitInternalPaths();
+        }
+
         distance %= this.length;
         foreach (InternalPath p in this.internalPaths)
         {
@@ -177,7 +141,49 @@ SegmentInfo IPathInternals.PointAlongPath(float distance)
 
     /// <inheritdoc/>
     IReadOnlyList<InternalPath> IInternalPathOwner.GetRingsAsInternalPath()
-        => this.internalPaths;
+    {
+        this.InitInternalPaths();
+        return this.internalPaths;
+    }
+
+    /// <summary>
+    /// Initializes <see cref="internalPaths"/> and <see cref="length"/>.
+    /// </summary>
+    [MemberNotNull(nameof(internalPaths))]
+    private void InitInternalPaths()
+    {
+        this.internalPaths = new List<InternalPath>(this.paths.Length);
+
+        foreach (IPath p in this.paths)
+        {
+            foreach (ISimplePath s in p.Flatten())
+            {
+                InternalPath ip = new(s.Points, s.IsClosed);
+                this.length += ip.Length;
+                this.internalPaths.Add(ip);
+            }
+        }
+    }
+
+    private RectangleF CalcBounds()
+    {
+        float minX = float.MaxValue;
+        float maxX = float.MinValue;
+        float minY = float.MaxValue;
+        float maxY = float.MinValue;
+
+        foreach (IPath p in this.paths)
+        {
+            RectangleF pBounds = p.Bounds;
+
+            minX = MathF.Min(minX, pBounds.Left);
+            maxX = MathF.Max(maxX, pBounds.Right);
+            minY = MathF.Min(minY, pBounds.Top);
+            maxY = MathF.Max(maxY, pBounds.Bottom);
+        }
+
+        return new RectangleF(minX, minY, maxX - minX, maxY - minY);
+    }
 
     private static InvalidOperationException ThrowOutOfRange() => new("Should not be possible to reach this line");
 }

src/ImageSharp.Drawing/Shapes/PathCollection.cs

@@ -13,6 +13,7 @@ namespace SixLabors.ImageSharp.Drawing;
 public class PathCollection : IPathCollection
 {
     private readonly IPath[] paths;
+    private RectangleF? bounds;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PathCollection"/> class.
@@ -33,28 +34,30 @@ public PathCollection(params IPath[] paths)
 
         if (this.paths.Length == 0)
         {
-            this.Bounds = new RectangleF(0, 0, 0, 0);
+            this.bounds = new RectangleF(0, 0, 0, 0);
         }
-        else
-        {
-            float minX, minY, maxX, maxY;
-            minX = minY = float.MaxValue;
-            maxX = maxY = float.MinValue;
+    }
 
-            foreach (IPath path in this.paths)
-            {
-                minX = Math.Min(path.Bounds.Left, minX);
-                minY = Math.Min(path.Bounds.Top, minY);
-                maxX = Math.Max(path.Bounds.Right, maxX);
-                maxY = Math.Max(path.Bounds.Bottom, maxY);
-            }
+    /// <inheritdoc />
+    public RectangleF Bounds => this.bounds ??= this.CalcBounds();
+
+    private RectangleF CalcBounds()
+    {
+        float minX, minY, maxX, maxY;
+        minX = minY = float.MaxValue;
+        maxX = maxY = float.MinValue;
 
-            this.Bounds = new RectangleF(minX, minY, maxX - minX, maxY - minY);
+        foreach (IPath path in this.paths)
+        {
+            RectangleF bounds = path.Bounds;
+            minX = Math.Min(bounds.Left, minX);
+            minY = Math.Min(bounds.Top, minY);
+            maxX = Math.Max(bounds.Right, maxX);
+            maxY = Math.Max(bounds.Bottom, maxY);
         }
-    }
 
-    /// <inheritdoc />
-    public RectangleF Bounds { get; }
+        return new RectangleF(minX, minY, maxX - minX, maxY - minY);
+    }
 
     /// <inheritdoc />
     public IEnumerator<IPath> GetEnumerator() => ((IEnumerable<IPath>)this.paths).GetEnumerator();