Make methods pure

Author: JimBobSquarePants

src/PolygonClipper/Contour.cs

@@ -251,6 +251,33 @@ public void Clear()
     /// <param name="index">The index of the hole to add.</param>
     public void AddHoleIndex(int index) => this.holeIndices.Add(index);
 
+    /// <summary>
+    /// Creates a deep copy of this contour.
+    /// </summary>
+    /// <param name="contourIndexOffset">
+    /// Offset applied to parent and hole contour indices so copied topology remains valid
+    /// when inserted into another polygon.
+    /// </param>
+    /// <returns>A detached contour copy.</returns>
+    internal Contour DeepClone(int contourIndexOffset = 0)
+    {
+        Contour clone = new(this.vertices.Count)
+        {
+            ParentIndex = this.ParentIndex is int parentIndex ? parentIndex + contourIndexOffset : null,
+            Depth = this.Depth,
+            hasCachedOrientation = this.hasCachedOrientation,
+            cachedCounterClockwise = this.cachedCounterClockwise
+        };
+
+        clone.vertices.AddRange(this.vertices);
+        for (int i = 0; i < this.holeIndices.Count; i++)
+        {
+            clone.holeIndices.Add(this.holeIndices[i] + contourIndexOffset);
+        }
+
+        return clone;
+    }
+
     /// <inheritdoc/>
     public IEnumerator<Vertex> GetEnumerator()
         => ((IEnumerable<Vertex>)this.vertices).GetEnumerator();

src/PolygonClipper/Polygon.cs

@@ -76,17 +76,13 @@ public Contour this[int index]
     /// <param name="polygon">The polygon to join.</param>
     public void Join(Polygon polygon)
     {
-        int size = this.Count;
-        for (int i = 0; i < polygon.contours.Count; ++i)
-        {
-            Contour contour = polygon.contours[i];
-            this.Add(contour);
-            this.GetLastContour().ClearHoles();
+        ArgumentNullException.ThrowIfNull(polygon);
 
-            for (int j = 0; j < contour.HoleCount; ++j)
-            {
-                this.GetLastContour().AddHoleIndex(contour.GetHoleIndex(j) + size);
-            }
+        int sourceCount = polygon.contours.Count;
+        int contourIndexOffset = this.contours.Count;
+        for (int i = 0; i < sourceCount; ++i)
+        {
+            this.contours.Add(polygon.contours[i].DeepClone(contourIndexOffset));
         }
     }
 
@@ -141,6 +137,21 @@ public void Translate(double x, double y)
     /// </summary>
     public void Clear() => this.contours.Clear();
 
+    /// <summary>
+    /// Creates a deep copy of this polygon and all of its contours.
+    /// </summary>
+    /// <returns>A detached polygon copy.</returns>
+    internal Polygon DeepClone()
+    {
+        Polygon clone = new(this.contours.Count);
+        for (int i = 0; i < this.contours.Count; i++)
+        {
+            clone.contours.Add(this.contours[i].DeepClone());
+        }
+
+        return clone;
+    }
+
     /// <inheritdoc/>
     public IEnumerator<Contour> GetEnumerator()
         => ((IEnumerable<Contour>)this.contours).GetEnumerator();

src/PolygonClipper/PolygonClipper.cs

@@ -455,13 +455,13 @@ private static bool TryTrivialOperationForEmptyPolygons(
 
             if (operation == BooleanOperation.Difference)
             {
-                result = subject;
+                result = subject.DeepClone();
                 return true;
             }
 
             if (operation is BooleanOperation.Union or BooleanOperation.Xor)
             {
-                result = subject.Count == 0 ? clipping : subject;
+                result = subject.Count == 0 ? clipping.DeepClone() : subject.DeepClone();
                 return true;
             }
         }
@@ -505,13 +505,14 @@ private static bool TryTrivialOperationForNonOverlappingBoundingBoxes(
             // The bounding boxes do not overlap
             if (operation == BooleanOperation.Difference)
             {
-                result = subject;
+                result = subject.DeepClone();
                 return true;
             }
 
             if (operation is BooleanOperation.Union or BooleanOperation.Xor)
             {
-                result = subject;
+                result = new(subject.Count + clipping.Count);
+                result.Join(subject);
                 result.Join(clipping);
                 return true;
             }

src/PolygonClipper/PolygonStroker.cs

@@ -229,7 +229,12 @@ public Polygon Stroke(Polygon polygon)
             Polygon stroked = this.ProcessPathToPolygon(contour, isClosed);
             if (stroked.Count > 0)
             {
-                allContours.Join(stroked);
+                // Stroked contours are produced as fresh objects; append by reference
+                // here to avoid an unnecessary clone step in the hot path.
+                for (int j = 0; j < stroked.Count; j++)
+                {
+                    allContours.Add(stroked[j]);
+                }
             }
         }