Fix joining

Author: JimBobSquarePants

src/PolygonClipper/Contour.cs

@@ -254,26 +254,19 @@ public void Clear()
     /// <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)
+    public Contour DeepClone()
     {
         Contour clone = new(this.vertices.Count)
         {
-            ParentIndex = this.ParentIndex is int parentIndex ? parentIndex + contourIndexOffset : null,
+            ParentIndex = this.ParentIndex,
             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);
-        }
+        clone.holeIndices.AddRange(this.holeIndices);
 
         return clone;
     }

src/PolygonClipper/Polygon.cs

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

src/PolygonClipper/PolygonClipper.cs

@@ -512,8 +512,8 @@ private static bool TryTrivialOperationForNonOverlappingBoundingBoxes(
             if (operation is BooleanOperation.Union or BooleanOperation.Xor)
             {
                 result = new(subject.Count + clipping.Count);
-                result.Join(subject);
-                result.Join(clipping);
+                result.Join(subject.DeepClone());
+                result.Join(clipping.DeepClone());
                 return true;
             }
         }

src/PolygonClipper/PolygonStroker.cs

@@ -229,12 +229,7 @@ public Polygon Stroke(Polygon polygon)
             Polygon stroked = this.ProcessPathToPolygon(contour, isClosed);
             if (stroked.Count > 0)
             {
-                // 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]);
-                }
+                allContours.Join(stroked);
             }
         }