Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs
===================================================================
diff -u -r7042 -r7077
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs	(.../GeometryGenerator.cs)	(revision 7042)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryGenerator.cs	(.../GeometryGenerator.cs)	(revision 7077)
@@ -1,4 +1,4 @@
-// Copyright (C) Stichting Deltares 2025. All rights reserved.
+// Copyright (C) Stichting Deltares 2026. All rights reserved.
 // 
 // This file is part of the Dam Engine.
 // 
@@ -75,12 +75,12 @@
     /// <param name="aCurve"></param>
     public void RemoveIsUsedCurve(GeometryCurve aCurve)
     {
-        if ((geometryCurveForwardsIsUsed.ContainsKey(aCurve)))
+        if (geometryCurveForwardsIsUsed.ContainsKey(aCurve))
         {
             geometryCurveForwardsIsUsed.Remove(aCurve);
         }
 
-        if ((geometryCurveReversedIsUsed.ContainsKey(aCurve)))
+        if (geometryCurveReversedIsUsed.ContainsKey(aCurve))
         {
             geometryCurveReversedIsUsed.Remove(aCurve);
         }
@@ -110,7 +110,7 @@
         bool isKeyPresent = geometryCurveForwardsIsUsed.ContainsKey(curve);
         if (direction == CurveDirection.Forward)
         {
-            if (!isKeyPresent)    
+            if (!isKeyPresent)
             {
                 geometryCurveForwardsIsUsed.Add(curve, isUsed);
             }
@@ -571,7 +571,7 @@
                 GeometryCurve loopBeginCurve = geometryData.Curves[curveIndex];
                 CurveDirection loopBeginDirection = currentCurveDirection;
 
-                ProcessCurvesForLoopCompletion(currentCurve, currentCurveDirection, newLoop, attachedCurveList, curvesCount, 
+                ProcessCurvesForLoopCompletion(currentCurve, currentCurveDirection, newLoop, attachedCurveList, curvesCount,
                                                loopBeginCurve, loopBeginDirection);
             }
 
@@ -668,7 +668,7 @@
     {
         if (attachedCurveList.Count == 0) // no curves found
         {
-            throw new ArgumentException("DetectSurfaces: No connected Curve found"); 
+            throw new ArgumentException("DetectSurfaces: No connected Curve found");
         }
     }
 
@@ -706,7 +706,7 @@
                 return true;
             }
 
-            currentCurveDirection = CurveDirection.Forward; 
+            currentCurveDirection = CurveDirection.Forward;
         }
         else
         {
@@ -1078,7 +1078,7 @@
             innerPointCount = CheckIfNewLoopIsInnerLoopOfGivenLoop(newPointCount, loop, newPolygon, innerPointCount);
 
             // check if existing loop is an inner loop to the new loop, making the newloop an outerloop for that.
-            outerPointCount = CheckIfLoopIsInnerLoopOfNewLoop(existingLoopPointCount, newLoop, polygon, outerPointCount, 
+            outerPointCount = CheckIfLoopIsInnerLoopOfNewLoop(existingLoopPointCount, newLoop, polygon, outerPointCount,
                                                               ref hasOnPointCount);
 
             //Add New Loop as inner loop to the existing Surface
@@ -1088,8 +1088,8 @@
             }
 
             //Add Inner Loop to the New Surface 
-            if ((outerPointCount == existingLoopPointCount) || ((outerPointCount > 0) && (existingLoopPointCount == 
-                                                                                          (outerPointCount + hasOnPointCount))))
+            if ((outerPointCount == existingLoopPointCount) || ((outerPointCount > 0) && (existingLoopPointCount ==
+                                                                                          outerPointCount + hasOnPointCount)))
             {
                 newSurface.AddInnerLoop(loop);
             }
@@ -1110,7 +1110,7 @@
     {
         for (var innerIndex1 = 0; innerIndex1 < existingLoopPointCount; innerIndex1++)
         {
-            PointInPolygon location = Routines2D.CheckIfPointIsInPolygon(newLoop, polygon[innerIndex1].X, 
+            PointInPolygon location = Routines2D.CheckIfPointIsInPolygon(newLoop, polygon[innerIndex1].X,
                                                                          polygon[innerIndex1].Z);
 
             if (location == PointInPolygon.InsidePolygon)
@@ -1139,7 +1139,7 @@
     {
         for (var innerIndex = 0; innerIndex < newPointCount; innerIndex++)
         {
-            PointInPolygon location = Routines2D.CheckIfPointIsInPolygon(loop, newPolygon[innerIndex].X, 
+            PointInPolygon location = Routines2D.CheckIfPointIsInPolygon(loop, newPolygon[innerIndex].X,
                                                                          newPolygon[innerIndex].Z);
 
             if (location == PointInPolygon.InsidePolygon)
@@ -1170,10 +1170,11 @@
             {
                 foreach (GeometryCurve geometryCurve2 in geometryData.Curves.ToArray())
                 {
-                    isCurveInserted = FindAndProcessCurveIntersections(geometryCurve1, geometryCurve2, isCurveInserted, 
+                    isCurveInserted = FindAndProcessCurveIntersections(geometryCurve1, geometryCurve2, isCurveInserted,
                                                                        ref hasCurveBeenSplit);
                 }
             }
+
             EnsureCorrectGeometry();
         }
 
@@ -1199,27 +1200,27 @@
         Point2D geometryCurve2EndPoint = geometryCurve2.EndPoint;
         if (!geometryCurve1.LocationEquals(geometryCurve2) &&
             !RegenerateParallelCurves(geometryCurve2, geometryCurve1, ref isCurveInserted) &&
-            Routines2D.DetermineIf2DLinesIntersectStrickly(geometryCurve1HeadPoint, geometryCurve1EndPoint, 
-                                                           geometryCurve2HeadPoint, geometryCurve2EndPoint, 
+            Routines2D.DetermineIf2DLinesIntersectStrickly(geometryCurve1HeadPoint, geometryCurve1EndPoint,
+                                                           geometryCurve2HeadPoint, geometryCurve2EndPoint,
                                                            out Point2D intersectionPoint) == LineIntersection.Intersects)
         {
-            if (!Routines2D.DetermineIfPointsCoincide(geometryCurve1HeadPoint.X, geometryCurve1HeadPoint.Z, intersectionPoint.X, 
+            if (!Routines2D.DetermineIfPointsCoincide(geometryCurve1HeadPoint.X, geometryCurve1HeadPoint.Z, intersectionPoint.X,
                                                       intersectionPoint.Z, GeometryConstants.Tolerance)
-                && !Routines2D.DetermineIfPointsCoincide(geometryCurve1EndPoint.X, geometryCurve1EndPoint.Z, intersectionPoint.X, 
+                && !Routines2D.DetermineIfPointsCoincide(geometryCurve1EndPoint.X, geometryCurve1EndPoint.Z, intersectionPoint.X,
                                                          intersectionPoint.Z, GeometryConstants.Tolerance))
             {
-                Point2D point = geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X, 
+                Point2D point = geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X,
                                                                                                        intersectionPoint.Z));
                 SplitCurve(geometryCurve1, point);
                 hasCurveBeenSplit = true;
             }
 
-            if (!Routines2D.DetermineIfPointsCoincide(geometryCurve2HeadPoint.X, geometryCurve2HeadPoint.Z, intersectionPoint.X, 
+            if (!Routines2D.DetermineIfPointsCoincide(geometryCurve2HeadPoint.X, geometryCurve2HeadPoint.Z, intersectionPoint.X,
                                                       intersectionPoint.Z, GeometryConstants.Tolerance) &&
-                !Routines2D.DetermineIfPointsCoincide(geometryCurve2EndPoint.X, geometryCurve2EndPoint.Z, intersectionPoint.X, 
+                !Routines2D.DetermineIfPointsCoincide(geometryCurve2EndPoint.X, geometryCurve2EndPoint.Z, intersectionPoint.X,
                                                       intersectionPoint.Z, GeometryConstants.Tolerance))
             {
-                Point2D point = geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X, 
+                Point2D point = geometryData.CreatePointAndAddItToTheProperListsWhenNeeded(new Point2D(intersectionPoint.X,
                                                                                                        intersectionPoint.Z));
                 SplitCurve(geometryCurve2, point);
                 hasCurveBeenSplit = true;
@@ -1246,13 +1247,13 @@
             {
                 for (int index2 = count - 1; index2 >= 0; --index2)
                 {
-                    if ((index2 != index1) && (Routines2D.DetermineIfPointsCoincide(
-                                                      geometryData.Points[index1].X, geometryData.Points[index1].Z,
-                                                      geometryData.Points[index2].X, geometryData.Points[index2].Z, GeometryConstants.Tolerance)))
+                    if ((index2 != index1) && Routines2D.DetermineIfPointsCoincide(
+                            geometryData.Points[index1].X, geometryData.Points[index1].Z,
+                            geometryData.Points[index2].X, geometryData.Points[index2].Z, GeometryConstants.Tolerance))
                     {
                         aConnectedAtHeadCurveList.Clear();
                         aConnectedAtEndCurveList.Clear();
-                        DetermineConnectedCurves(geometryData.Points[index1], ref aConnectedAtHeadCurveList, 
+                        DetermineConnectedCurves(geometryData.Points[index1], ref aConnectedAtHeadCurveList,
                                                  ref aConnectedAtEndCurveList);
                         AssignPointToCurves(aConnectedAtHeadCurveList, geometryData.Points[index2], true);
                         AssignPointToCurves(aConnectedAtEndCurveList, geometryData.Points[index2], false);
@@ -1305,9 +1306,9 @@
         if (isPoint1OnLine2 && isPoint2OnLine2 && !isPoint1SameAsPoint3 && !isPoint2SameAsPoint4 &&
             !isPoint2SameAsPoint3 && !isPoint1SameAsPoint4)
         {
-            double distance1 = Routines2D.Compute2DDistance(line2.HeadPoint.X, line2.HeadPoint.Z, line1.HeadPoint.X, 
+            double distance1 = Routines2D.Compute2DDistance(line2.HeadPoint.X, line2.HeadPoint.Z, line1.HeadPoint.X,
                                                             line1.HeadPoint.Z);
-            double distance2 = Routines2D.Compute2DDistance(line2.HeadPoint.X, line2.HeadPoint.Z, line1.EndPoint.X, 
+            double distance2 = Routines2D.Compute2DDistance(line2.HeadPoint.X, line2.HeadPoint.Z, line1.EndPoint.X,
                                                             line1.EndPoint.Z);
 
             GeometryCurve newLine;
@@ -1632,7 +1633,7 @@
     /// </summary>
     private void DeleteInvalidAndDuplicateCurves()
     {
-        List<GeometryCurve> curvesToDelete = geometryData.Curves.Where((Func<GeometryCurve, bool>) 
+        List<GeometryCurve> curvesToDelete = geometryData.Curves.Where((Func<GeometryCurve, bool>)
                                                                        (curve => curve.HeadPoint == curve.EndPoint)).ToList();
         foreach (GeometryCurve aCurve in curvesToDelete)
         {