Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs
===================================================================
diff -u -r5460 -r5494
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 5460)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 5494)
@@ -51,7 +51,7 @@
     /// <summary>
     /// Ordered list of all geometry points at the surface
     /// </summary>
-    public virtual GeometryPointString SurfaceLine
+    public GeometryPointString SurfaceLine
     {
         get
         {
@@ -142,11 +142,13 @@
     {
         foreach (Point2D geometryPoint in Points.ToArray<Point2D>())
         {
-            if (this.GetDependentCurveCount(geometryPoint) == 0)
-                this.Remove((IGeometryObject) geometryPoint, true);
+            if (GetDependentCurveCount(geometryPoint) == 0)
+            {
+                Remove(geometryPoint, true);
+            }
         }
     }
-    
+
     /// <summary>
     /// Deletes all the loose curves.
     /// Returns true when the loose curve is inside publisherEventArgs surface.
@@ -159,16 +161,17 @@
         {
             geometryGenerator = new GeometryGenerator(this);
         }
+
         geometryGenerator.SetupCurveSurfaceAssociations();
         var regenerateGeometry = false;
         var curvesToDelete = new List<GeometryCurve>();
         foreach (GeometryCurve curve in Curves)
         {
-            if ((curve.SurfaceAtLeft == null && curve.SurfaceAtRight == null))
+            if (curve.SurfaceAtLeft == null && curve.SurfaceAtRight == null)
             {
                 curvesToDelete.Add(curve);
             }
-            else if ((curve.SurfaceAtLeft != null && curve.SurfaceAtRight != null) &&
+            else if (curve.SurfaceAtLeft != null && curve.SurfaceAtRight != null &&
                      (curve.SurfaceAtLeft == curve.SurfaceAtRight))
             {
                 regenerateGeometry = true;
@@ -287,6 +290,264 @@
     }
 
     /// <summary>
+    /// Updates the line at the top of the geometry
+    /// </summary>
+    public void UpdateSurfaceLine()
+    {
+        if (updatingSurfaceLine)
+        {
+            return;
+        }
+
+        updatingSurfaceLine = true;
+
+        List<GeometryCurve> bCurves = GetBoundaryCurves();
+        if (bCurves.Count == 0)
+        {
+            surfaceLine.CalcPoints.Clear();
+        }
+
+        List<GeometryCurve> curvesCopy = GetCurvesCopy(bCurves);
+        List<GeometryCurve> curves = GetTopCurves(curvesCopy);
+        CreateSurfaceLinePointString(curves);
+
+        updatingSurfaceLine = false;
+        surfaceLine.SyncPoints();
+    }
+
+    public Point2D CreatePoint(Point2D requestedPoint, bool snapToExistingPoint)
+    {
+        Point2D newPoint = DetermineNewPointAndFlags(requestedPoint, out bool flag1, out bool flag2);
+        if (!flag2 && snapToExistingPoint)
+        {
+            int count = Curves.Count;
+            for (var index = 0; index < count; ++index)
+            {
+                GeometryCurve curve = Curves[index];
+                if (Routines2D.DoesPointExistInLine(curve.HeadPoint, curve.EndPoint, newPoint, GeometryConstants.Accuracy))
+                {
+                    Routines2D.GetPointOnLineClosestTo(newPoint.X, newPoint.Z, curve.HeadPoint.X, curve.HeadPoint.Z,
+                                                       curve.EndPoint.X, curve.EndPoint.Z, out Point2D aResultPoint);
+
+                    newPoint.X = aResultPoint.X;
+                    newPoint.Z = aResultPoint.Z;
+                    break;
+                }
+            }
+        }
+
+        if (!NewlyEffectedPoints.Contains(newPoint) && !flag1)
+        {
+            NewlyEffectedPoints.Add(newPoint);
+        }
+
+        return newPoint;
+    }
+
+    public bool DeletePoint(Point2D aPoint)
+    {
+        var flag = false;
+        var source = new List<GeometryCurve>();
+        if (Curves.Count > 0)
+        {
+            source.AddRange(Curves.Where((Func<GeometryCurve, bool>) (c => c.HeadPoint == aPoint || c.EndPoint == aPoint)));
+            if (source.Count == 2)
+            {
+                CheckForCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(aPoint, source);
+            }
+
+            Remove(aPoint, false);
+            if (source.Exists(curve => curve.SurfaceAtLeft != null || curve.SurfaceAtRight != null))
+            {
+                flag = true;
+            }
+
+            foreach (GeometryCurve aCurve in source)
+            {
+                DeleteCurve(aCurve, true);
+            }
+
+            return flag;
+        }
+
+        Remove(aPoint, false);
+        return false;
+    }
+
+    public GeometryCurve CreateCurve(Point2D aPoint1, Point2D aPoint2)
+    {
+        foreach (GeometryCurve curve in Curves)
+        {
+            if (curve.HeadPoint == aPoint1 && curve.EndPoint == aPoint2 || curve.HeadPoint == aPoint2 && curve.EndPoint == aPoint1)
+            {
+                return curve;
+            }
+        }
+
+        var curve1 = new GeometryCurve();
+        geometryGenerator.SetIsUsed(curve1, CurveDirection.Forward, false);
+        geometryGenerator.SetIsUsed(curve1, CurveDirection.Reverse, false);
+        curve1.HeadPoint = aPoint1;
+        curve1.EndPoint = aPoint2;
+        Create(curve1);
+        NewlyEffectedCurves.Add(curve1);
+        return curve1;
+    }
+
+    /// <summary>
+    /// Clones the geometry data.
+    /// </summary>
+    /// <returns>Returns a clone</returns>
+    public GeometryData Clone()
+    {
+        var clonedGeometryData = new GeometryData
+        {
+            Left = Left,
+            Right = Right,
+            Bottom = Bottom
+        };
+        foreach (Point2D point in Points)
+        {
+            clonedGeometryData.Points.Add(point.Clone());
+        }
+
+        foreach (Point2D point in NewlyEffectedPoints)
+        {
+            clonedGeometryData.NewlyEffectedPoints.Add(point.Clone());
+        }
+
+        foreach (GeometryCurve curve in Curves)
+        {
+            clonedGeometryData.Curves.Add(curve.Clone(clonedGeometryData.Points));
+        }
+
+        foreach (GeometryCurve curve in NewlyEffectedCurves)
+        {
+            clonedGeometryData.NewlyEffectedCurves.Add(curve.Clone(clonedGeometryData.NewlyEffectedPoints));
+        }
+
+        foreach (GeometrySurface surface in Surfaces)
+        {
+            GeometryLoop clonedLoop = surface.OuterLoop.Clone();
+            clonedGeometryData.Loops.Add(clonedLoop);
+            var innerLoops = new List<GeometryLoop>();
+            innerLoops.AddRange(surface.InnerLoops.Select(loop => loop.Clone()).ToList());
+            clonedGeometryData.Loops.AddRange(innerLoops);
+            GeometrySurface clonedSurface = surface.Clone();
+            clonedSurface.OuterLoop = clonedLoop;
+            clonedSurface.InnerLoops.AddRange(innerLoops);
+            clonedGeometryData.Surfaces.Add(clonedSurface);
+        }
+
+        // For the clone, set use geometry generator to null.
+        // This will ensure that a new generator for this geometry using this geometry will be used. 
+        clonedGeometryData.geometryGenerator = null;
+        return clonedGeometryData;
+    }
+
+    public bool HandleDelete(List<IGeometryObject> aList)
+    {
+        var regenerationResult = false;
+
+        //SaveGeometryState();
+
+        foreach (IGeometryObject anObject in aList)
+        {
+            bool tobeRegenerated;
+            if (anObject.GetType() == typeof(GeometryPoint))
+            {
+                var selectedPoint = (Point2D) anObject;
+                //if (Points.Contains(selectedPoint))
+                {
+                    tobeRegenerated = DeletePoint(selectedPoint);
+                    if (!regenerationResult)
+                    {
+                        regenerationResult = tobeRegenerated;
+                    }
+                    //DataEventPublisher.DataListModified(Points);
+                }
+            }
+            else if (anObject.GetType() == typeof(GeometryCurve))
+            {
+                var selectedCurve = (GeometryCurve) anObject;
+
+                tobeRegenerated = DeleteCurve(selectedCurve, true);
+                if (!regenerationResult)
+                {
+                    regenerationResult = tobeRegenerated;
+                }
+
+                // if (curveDataList.Contains(selectedCurve))
+                // {
+                //     DataEventPublisher.DataListModified(curveDataList);
+                // }
+            }
+            else if (anObject.GetType() == typeof(GeometrySurface))
+            {
+                var selectedSurface = (GeometrySurface) anObject;
+                DeleteSurface(selectedSurface, true);
+                //DataEventPublisher.DataListModified(surfaceDataList);
+            }
+        }
+
+        if (regenerationResult)
+        {
+            RegenerateGeometry();
+        }
+
+        return regenerationResult;
+    }
+
+    /// <summary>
+    /// Deletes the given IGeometrySurface if aValidate is true.
+    /// </summary>
+    /// <param name="aSurface"></param>
+    /// <param name="aValidate"></param>
+    public void DeleteSurface(GeometrySurface aSurface, bool aValidate)
+    {
+        aValidate = aValidate && !geometryGenerator.IsRegenerationOn;
+        GeometrySurface surface = aSurface;
+
+        GeometryLoop outerLoop = aSurface.OuterLoop;
+
+        if (aValidate)
+        {
+            // Delete all curves which are part of the surface
+            //DataEventPublisher.BeforeChange(Curves);
+            //DataEventPublisher.BeforeChange(Points);
+
+            var curvesToBeDeleted = new List<GeometryCurve>();
+            foreach (GeometryCurve curve in outerLoop.CurveList)
+            {
+                bool allowDelete = curve.SurfaceAtLeft == null || curve.SurfaceAtLeft == surface;
+                allowDelete &= curve.SurfaceAtRight == null || curve.SurfaceAtRight == surface;
+
+                if (allowDelete)
+                {
+                    curvesToBeDeleted.Add(curve);
+                }
+                else
+                {
+                    NewlyEffectedCurves.Add(curve);
+                }
+            }
+
+            foreach (GeometryCurve delCurve in curvesToBeDeleted)
+            {
+                DeleteCurve(delCurve, true);
+            }
+
+            Remove(outerLoop, false);
+            Remove(aSurface, false);
+        }
+        else
+        {
+            Remove(outerLoop, false);
+            Remove(surface, false);
+        }
+    }
+
+    /// <summary>
     /// Returns a <see cref="System.String" /> that represents this instance.
     /// </summary>
     /// <returns>
@@ -298,6 +559,29 @@
     }
 
     /// <summary>
+    /// Gets next connected top curve in list of curves
+    /// </summary>
+    /// <param name="curve"></param>
+    /// <param name="boundaryCurves"></param>
+    /// <param name="excludedCurves"></param>
+    /// <returns>Curve</returns>
+    protected internal GeometryCurve GetNextTopCurve(GeometryCurve curve, List<GeometryCurve> boundaryCurves,
+                                                     List<GeometryCurve> excludedCurves)
+    {
+        // if current curve ends on right limit then that must have been the last one so stop the search
+        if (Math.Abs(curve.HeadPoint.X - Right) < GeometryConstants.Accuracy || Math.Abs(curve.EndPoint.X - Right) < GeometryConstants.Accuracy)
+        {
+            return null;
+        }
+
+        IEnumerable<GeometryCurve> includedCurves = boundaryCurves.Where(geometryCurve => geometryCurve != curve && !excludedCurves.Contains(geometryCurve));
+        IEnumerable<GeometryCurve> connectedCurves = includedCurves.Where(geometryCurve => AreConnected(curve, geometryCurve));
+        IEnumerable<GeometryCurve> connectedCurvesOnRightSide = connectedCurves.Where(geometryCurve => IsOnLeftSideOf(curve, geometryCurve));
+        GeometryCurve topConnectedCurve = connectedCurvesOnRightSide.MaxBy(c => c.HeadPoint.Z + c.EndPoint.Z);
+        return topConnectedCurve;
+    }
+
+    /// <summary>
     /// Removes the boundary curves from the given list of curves.
     /// The boundaries themselves are determined from the given geometry
     /// </summary>
@@ -335,29 +619,6 @@
     }
 
     /// <summary>
-    /// Gets next connected top curve in list of curves
-    /// </summary>
-    /// <param name="curve"></param>
-    /// <param name="boundaryCurves"></param>
-    /// <param name="excludedCurves"></param>
-    /// <returns>Curve</returns>
-    protected internal GeometryCurve GetNextTopCurve(GeometryCurve curve, List<GeometryCurve> boundaryCurves,
-                                          List<GeometryCurve> excludedCurves)
-    {
-        // if current curve ends on right limit then that must have been the last one so stop the search
-        if (Math.Abs(curve.HeadPoint.X - Right) < GeometryConstants.Accuracy || Math.Abs(curve.EndPoint.X - Right) < GeometryConstants.Accuracy)
-        {
-            return null;
-        }
-
-        IEnumerable<GeometryCurve> includedCurves = boundaryCurves.Where(geometryCurve => geometryCurve != curve && !excludedCurves.Contains(geometryCurve));
-        IEnumerable<GeometryCurve> connectedCurves = includedCurves.Where(geometryCurve => AreConnected(curve, geometryCurve));
-        IEnumerable<GeometryCurve> connectedCurvesOnRightSide = connectedCurves.Where(geometryCurve => IsOnLeftSideOf(curve, geometryCurve));
-        GeometryCurve topConnectedCurve = connectedCurvesOnRightSide.MaxBy(c => c.HeadPoint.Z + c.EndPoint.Z);
-        return topConnectedCurve;
-    }
-
-    /// <summary>
     /// create a copy of the curves
     /// </summary>
     /// <param name="bCurves"></param>
@@ -488,12 +749,12 @@
 
     private static bool AreConnected(GeometryCurve curve1, GeometryCurve curve2)
     {
-        return curve1.HeadPoint.LocationEquals(curve2.HeadPoint) || 
+        return curve1.HeadPoint.LocationEquals(curve2.HeadPoint) ||
                curve1.HeadPoint.LocationEquals(curve2.EndPoint) ||
-               curve1.EndPoint.LocationEquals(curve2.HeadPoint) || 
+               curve1.EndPoint.LocationEquals(curve2.HeadPoint) ||
                curve1.EndPoint.LocationEquals(curve2.EndPoint);
     }
-    
+
     /// <summary>
     /// Checks if curve1 is on the left side of curve2
     /// </summary>
@@ -502,36 +763,127 @@
     /// <returns>True when curve1 is on the left side of curve2</returns>
     private static bool IsOnLeftSideOf(GeometryCurve curve1, GeometryCurve curve2)
     {
-        return curve1.HeadPoint.X.IsLessThanOrEqualTo(curve2.HeadPoint.X) && 
+        return curve1.HeadPoint.X.IsLessThanOrEqualTo(curve2.HeadPoint.X) &&
                curve1.HeadPoint.X.IsLessThanOrEqualTo(curve2.EndPoint.X) &&
                curve1.EndPoint.X.IsLessThanOrEqualTo(curve2.HeadPoint.X) &&
                curve1.EndPoint.X.IsLessThanOrEqualTo(curve2.EndPoint.X);
     }
-        
+
+    private Point2D DetermineNewPointAndFlags(Point2D requestedPoint, out bool isExistingPoint, out bool flag2)
+    {
+        isExistingPoint = false;
+        flag2 = false;
+        // try to find the point in Points
+        Point2D newPoint = GetPoint(requestedPoint, GeometryConstants.Accuracy);
+
+        if (newPoint != null)
+        {
+            requestedPoint.X = newPoint.X;
+            requestedPoint.Z = newPoint.Z;
+            if (!Points.Contains(requestedPoint))
+            {
+                newPoint = null;
+            }
+            else
+            {
+                isExistingPoint = true;
+            }
+        }
+
+        if (newPoint == null)
+        {
+            newPoint = new Point2D(requestedPoint.X, requestedPoint.Z);
+            Create(newPoint);
+        }
+        else
+        {
+            flag2 = true;
+        }
+
+        return newPoint;
+    }
+
+    private void Create(IGeometryObject aData)
+    {
+        if (aData.GetType() == typeof(Point2D))
+        {
+            var point = (Point2D) aData;
+            Points.Add(point);
+        }
+        else if (aData.GetType() == typeof(GeometryCurve))
+        {
+            var geometryCurve = (GeometryCurve) aData;
+            Curves.Add(geometryCurve);
+        }
+        else if (aData.GetType() == typeof(GeometryLoop))
+        {
+            Loops.Add((GeometryLoop) aData);
+        }
+        else if (aData.GetType() == typeof(GeometrySurface))
+        {
+            Surfaces.Add((GeometrySurface) aData);
+        }
+    }
+
     /// <summary>
-    /// Updates the line at the top of the geometry
+    /// Checks whether the given point already exists in Points within the requested snap distance. 
     /// </summary>
-    public void UpdateSurfaceLine()
+    /// <param name="point2D"></param>
+    /// <param name="snapDistance"></param>
+    /// <returns>the existing point if found else null</returns>
+    private Point2D GetPoint(Point2D point2D, double snapDistance)
     {
-        if (updatingSurfaceLine)
+        for (var index = 0; index < Points.Count; ++index)
         {
-            return;
+            if (Routines2D.DetermineIfPointsCoincide(point2D.X, point2D.Z, Points[index].X, Points[index].Z, snapDistance))
+            {
+                return new Point2D(Points[index].X, Points[index].Z);
+            }
         }
 
-        updatingSurfaceLine = true;
+        return null;
+    }
 
-        List<GeometryCurve> bCurves = GetBoundaryCurves();
-        if (bCurves.Count == 0)
+    private void CheckForCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(Point2D aPoint, List<GeometryCurve> source)
+    {
+        var line1Point1 = new Point2D();
+        var line2Point1 = new Point2D();
+        line1Point1.Init(source[0].HeadPoint != aPoint ? source[0].HeadPoint : source[0].EndPoint);
+        line2Point1.Init(source[1].HeadPoint != aPoint ? source[1].HeadPoint : source[1].EndPoint);
+        double angle = Routines2D.FindAngle(line1Point1, aPoint, line2Point1, aPoint);
+        if (angle.IsGreaterThanOrEqualTo(179.0) && angle.IsLessThanOrEqualTo(181.0))
         {
-            surfaceLine.CalcPoints.Clear();
+            FixCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(aPoint, source);
         }
+    }
 
-        List<GeometryCurve> curvesCopy = GetCurvesCopy(bCurves);
-        List<GeometryCurve> curves = GetTopCurves(curvesCopy);
-        CreateSurfaceLinePointString(curves);
+    private void FixCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(Point2D aPoint, List<GeometryCurve> source)
+    {
+        for (var index = 0; index < Curves.Count - 1; ++index)
+        {
+            if (Curves[index] == source[0])
+            {
+                if (Curves[index].EndPoint != source[1].EndPoint && aPoint == source[0].HeadPoint && aPoint == source[1].HeadPoint)
+                {
+                    Curves[index].HeadPoint = source[1].EndPoint;
+                }
+                else if (Curves[index].EndPoint != source[1].EndPoint && aPoint == source[1].HeadPoint)
+                {
+                    Curves[index].EndPoint = source[1].EndPoint;
+                }
+                else if (Curves[index].HeadPoint != source[1].HeadPoint && aPoint == Curves[index].EndPoint)
+                {
+                    Curves[index].EndPoint = source[1].HeadPoint;
+                }
+                else if (Curves[index].HeadPoint == source[1].EndPoint)
+                {
+                    Curves[index].HeadPoint = source[1].HeadPoint;
+                }
 
-        updatingSurfaceLine = false;
-        surfaceLine.SyncPoints();
+                Remove(aPoint, false);
+                Remove(source[1], false);
+            }
+        }
     }
 
     #region properties
@@ -582,6 +934,9 @@
     /// </summary>
     public List<GeometrySurface> Surfaces { get; } = new List<GeometrySurface>();
 
+    /// <summary>
+    /// (Re-)generates the geometry
+    /// </summary>
     public void RegenerateGeometry()
     {
         if (isRegeneratingGeometry)
@@ -913,6 +1268,7 @@
                 {
                     HandleDelete(objectlist);
                 }
+
                 removeFromList = true;
             }
         }
@@ -927,6 +1283,7 @@
                 {
                     HandleDelete(objectlist);
                 }
+
                 if (Curves.Remove(geometryCurve))
                 {
                     RemoveDeletedCurveFromIsUsedCurveLists(geometryCurve);
@@ -945,6 +1302,7 @@
                 {
                     HandleDelete(objectlist);
                 }
+
                 removeFromList = true;
             }
         }
@@ -957,7 +1315,7 @@
                 removeFromList = true;
             }
         }
-        
+
         return removeFromList;
     }
 
@@ -1002,7 +1360,7 @@
 
         return curvePointDependency;
     }
-    
+
     /// <summary>
     /// Returns a list of boundary curves. These are curves which are used in only one surface so they have to be on a boundary (inner or outer)
     /// </summary>
@@ -1045,312 +1403,4 @@
     #endregion
 
     #endregion
-    
-    public Point2D CreatePoint(Point2D requestedPoint, bool snapToExistingPoint)
-    {
-        Point2D newPoint = DetermineNewPointAndFlags(requestedPoint, out bool flag1, out bool flag2);
-        if (!flag2 && snapToExistingPoint)
-        {
-            int count = Curves.Count;
-            for (int index = 0; index < count; ++index)
-            {
-                GeometryCurve curve = Curves[index];
-                if (Routines2D.DoesPointExistInLine(curve.HeadPoint, curve.EndPoint, newPoint, GeometryConstants.Accuracy))
-                {
-                    Routines2D.GetPointOnLineClosestTo(newPoint.X, newPoint.Z, curve.HeadPoint.X, curve.HeadPoint.Z, 
-                                                       curve.EndPoint.X, curve.EndPoint.Z, out Point2D aResultPoint); 
-                                                         
-                    newPoint.X = aResultPoint.X;
-                    newPoint.Z = aResultPoint.Z;
-                    break;
-                }
-            }
-        }
-        if (!NewlyEffectedPoints.Contains(newPoint) && !flag1)
-          NewlyEffectedPoints.Add(newPoint);
-        return newPoint;
-    }
-
-    private Point2D DetermineNewPointAndFlags(Point2D requestedPoint, out bool isExistingPoint, out bool flag2)
-    {
-        isExistingPoint = false;
-        flag2 = false;
-        // try to find the point in Points
-        Point2D newPoint = GetPoint(requestedPoint, GeometryConstants.Accuracy);
-        
-        if (newPoint != null)
-        {
-            requestedPoint.X = newPoint.X;
-            requestedPoint.Z = newPoint.Z;
-            if (!Points.Contains(requestedPoint))
-                newPoint = null;
-            else
-                isExistingPoint = true;
-        }
-        if (newPoint == null)
-        {
-            newPoint = new Point2D(requestedPoint.X, requestedPoint.Z);
-            Create(newPoint);
-        }
-        else
-            flag2 = true;
-
-        return newPoint;
-    }
-
-    private void Create(IGeometryObject aData)
-    {
-        if (aData.GetType() == typeof (Point2D))
-        {
-            Point2D point = (Point2D) aData;
-            Points.Add(point);
-        }
-        else if (aData.GetType() == typeof (GeometryCurve))
-        {
-            GeometryCurve geometryCurve = (GeometryCurve) aData;
-            Curves.Add(geometryCurve);
-        }
-        else if (aData.GetType() == typeof (GeometryLoop))
-            Loops.Add((GeometryLoop) aData);
-        else if (aData.GetType() == typeof (GeometrySurface))
-            Surfaces.Add((GeometrySurface) aData);
-    }
-    
-    /// <summary>
-    /// Checks whether the given point already exists in Points within the requested snap distance. 
-    /// </summary>
-    /// <param name="point2D"></param>
-    /// <param name="snapDistance"></param>
-    /// <returns>the existing point if found else null</returns>
-    private Point2D GetPoint(Point2D point2D, double snapDistance)
-    {
-        for (int index = 0; index < Points.Count; ++index)
-        {
-            if (Routines2D.DetermineIfPointsCoincide(point2D.X, point2D.Z, Points[index].X, Points[index].Z, snapDistance))
-                return new Point2D(Points[index].X, Points[index].Z);
-        }
-        return null;
-    }
-    
-    public bool DeletePoint(Point2D aPoint)
-    {
-      
-      bool flag = false;
-      List<GeometryCurve> source = new List<GeometryCurve>();
-      if (Curves.Count > 0)
-      {
-        source.AddRange(Curves.Where((Func<GeometryCurve, bool>) (c => c.HeadPoint == aPoint || c.EndPoint == aPoint)));
-        if (source.Count == 2)
-        {
-            CheckForCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(aPoint, source);
-        }
-        Remove(aPoint, false);
-        if (source.Exists((curve => curve.SurfaceAtLeft != null || curve.SurfaceAtRight != null)))
-          flag = true;
-        foreach (GeometryCurve aCurve in source)
-          DeleteCurve(aCurve, true);
-        return flag;
-      }
-      Remove(aPoint, false);
-      return false;
-    }
-
-    private void CheckForCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(Point2D aPoint, List<GeometryCurve> source)
-    {
-        Point2D line1Point1 = new Point2D();
-        Point2D line2Point1 = new Point2D();
-        line1Point1.Init(source[0].HeadPoint != aPoint ? source[0].HeadPoint : source[0].EndPoint);
-        line2Point1.Init(source[1].HeadPoint != aPoint ? source[1].HeadPoint : source[1].EndPoint);
-        double angle = Routines2D.FindAngle(line1Point1, aPoint, line2Point1, aPoint);
-        if (angle.IsGreaterThanOrEqualTo(179.0) && angle.IsLessThanOrEqualTo(181.0))
-        {
-            FixCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(aPoint, source);
-        }
-    }
-
-    private void FixCurvesWherePointIsOnBothConnectedCurvesInLineWithEachOther(Point2D aPoint, List<GeometryCurve> source)
-    {
-        for (int index = 0; index < Curves.Count - 1; ++index)
-        {
-            if (Curves[index] == source[0])
-            {
-                if (Curves[index].EndPoint != source[1].EndPoint && aPoint == source[0].HeadPoint && aPoint == source[1].HeadPoint)
-                    Curves[index].HeadPoint = source[1].EndPoint;
-                else if (Curves[index].EndPoint != source[1].EndPoint && aPoint == source[1].HeadPoint)
-                    Curves[index].EndPoint = source[1].EndPoint;
-                else if (Curves[index].HeadPoint != source[1].HeadPoint && aPoint == Curves[index].EndPoint)
-                    Curves[index].EndPoint = source[1].HeadPoint;
-                else if (Curves[index].HeadPoint == source[1].EndPoint)
-                    Curves[index].HeadPoint = source[1].HeadPoint;
-                Remove(aPoint, false);
-                Remove(source[1], false);
-            }
-        }
-    }
-
-    public GeometryCurve CreateCurve(Point2D aPoint1, Point2D aPoint2)
-    {
-        foreach (GeometryCurve curve in Curves)
-        {
-          if (curve.HeadPoint == aPoint1 && curve.EndPoint == aPoint2 || curve.HeadPoint == aPoint2 && curve.EndPoint == aPoint1)
-          {
-            return curve;
-          }
-        }
-        GeometryCurve curve1 = new GeometryCurve();
-        geometryGenerator.SetIsUsed(curve1, CurveDirection.Forward, false);
-        geometryGenerator.SetIsUsed(curve1, CurveDirection.Reverse, false);
-        curve1.HeadPoint = aPoint1;
-        curve1.EndPoint = aPoint2;
-        Create(curve1);
-        NewlyEffectedCurves.Add(curve1);
-        return curve1;
-    }
-
-    /// <summary>
-    /// Clones the geometry data.
-    /// </summary>
-    /// <returns>Returns a clone</returns>
-    public GeometryData Clone()
-    {
-        var clonedGeometryData = new GeometryData
-        {
-            Left = this.Left,
-            Right = this.Right,
-            Bottom = this.Bottom
-        };
-        foreach (Point2D point in this.Points)
-        {
-            clonedGeometryData.Points.Add(point.Clone());
-        }
-        foreach (Point2D point in this.NewlyEffectedPoints)
-        {
-            clonedGeometryData.NewlyEffectedPoints.Add(point.Clone());
-        }
-        foreach (GeometryCurve curve in this.Curves)
-        {
-            clonedGeometryData.Curves.Add(curve.Clone(clonedGeometryData.Points));
-        }
-        foreach (GeometryCurve curve in this.NewlyEffectedCurves)
-        {
-            clonedGeometryData.NewlyEffectedCurves.Add(curve.Clone(clonedGeometryData.NewlyEffectedPoints));
-        }
-        foreach (GeometrySurface surface in this.Surfaces)
-        {
-            var clonedLoop = surface.OuterLoop.Clone();
-            clonedGeometryData.Loops.Add(clonedLoop);
-            List<GeometryLoop> innerLoops = new List<GeometryLoop>();
-            innerLoops.AddRange(surface.InnerLoops.Select(loop => loop.Clone()).ToList());
-            clonedGeometryData.Loops.AddRange(innerLoops);
-            var clonedSurface = surface.Clone();
-            clonedSurface.OuterLoop = clonedLoop;
-            clonedSurface.InnerLoops.AddRange(innerLoops);
-            clonedGeometryData.Surfaces.Add(clonedSurface);
-        }
-        
-        // For the clone, set use geometry generator to null.
-        // This will ensure that a new generator for this geometry using this geometry will be used. 
-        clonedGeometryData.geometryGenerator = null;
-        return clonedGeometryData;
-    }
-    
-    public bool HandleDelete(List<IGeometryObject> aList)
-    {
-        bool regenerationResult = false;
-
-        //SaveGeometryState();
-
-        foreach (var anObject in aList)
-        {
-            bool tobeRegenerated;
-            if (anObject.GetType() == typeof(GeometryPoint))
-            {
-                var selectedPoint = (Point2D) anObject;
-                //if (Points.Contains(selectedPoint))
-                {
-                    tobeRegenerated = DeletePoint(selectedPoint);
-                    if (!regenerationResult)
-                    {
-                        regenerationResult = tobeRegenerated;
-                    }
-                    //DataEventPublisher.DataListModified(Points);
-                }
-            }
-            else if (anObject.GetType() == typeof(GeometryCurve))
-            {
-                var selectedCurve = (GeometryCurve) anObject;
-
-                tobeRegenerated = DeleteCurve(selectedCurve, true);
-                if (!regenerationResult)
-                {
-                    regenerationResult = tobeRegenerated;
-                }
-
-                // if (curveDataList.Contains(selectedCurve))
-                // {
-                //     DataEventPublisher.DataListModified(curveDataList);
-                // }
-            }
-            else if (anObject.GetType() == typeof(GeometrySurface))
-            {
-                var selectedSurface = (GeometrySurface) anObject;
-                DeleteSurface(selectedSurface, true);
-               //DataEventPublisher.DataListModified(surfaceDataList);
-            }
-        }
-        if (regenerationResult)
-        {
-            RegenerateGeometry();
-        }
-
-        return regenerationResult;
-    }
-    
-    /// <summary>
-    /// Deletes the given IGeometrySurface if aValidate is true.
-    /// </summary>
-    /// <param name="aSurface"></param>
-    /// <param name="aValidate"></param>
-    public void DeleteSurface(GeometrySurface aSurface, bool aValidate)
-    {
-        aValidate = aValidate && !geometryGenerator.IsRegenerationOn;
-        var surface = aSurface;
-
-        GeometryLoop outerLoop = aSurface.OuterLoop;
-
-        if (aValidate)
-        {
-            // Delete all curves which are part of the surface
-            //DataEventPublisher.BeforeChange(Curves);
-            //DataEventPublisher.BeforeChange(Points);
-
-            var curvesToBeDeleted = new List<GeometryCurve>();
-            foreach (var curve in outerLoop.CurveList)
-            {
-                bool allowDelete = curve.SurfaceAtLeft == null || curve.SurfaceAtLeft == surface;
-                allowDelete &= curve.SurfaceAtRight == null || curve.SurfaceAtRight == surface;
-                    
-                if (allowDelete)
-                {
-                    curvesToBeDeleted.Add(curve);
-                }
-                else
-                {
-                    NewlyEffectedCurves.Add(curve);
-                }
-            }
-
-            foreach (var delCurve in curvesToBeDeleted)
-            {
-                DeleteCurve(delCurve, true);
-            }
-            Remove(outerLoop, false);
-            Remove(aSurface, false);
-        }
-        else
-        {
-            Remove(outerLoop, false);
-            Remove(surface, false);
-        }
-    }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs
===================================================================
diff -u -r5477 -r5494
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs	(.../GeometryPointString.cs)	(revision 5477)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPointString.cs	(.../GeometryPointString.cs)	(revision 5494)
@@ -80,21 +80,13 @@
     /// </summary>
     private const double epsilon = GeometryConstants.Accuracy;
 
-    /// <summary>
+    /// <summary>  
     /// The calculate points as protected field (to be able to prevent recursive calls to CalcPoints)
     /// </summary>
     protected readonly List<Point2D> calcPoints = new List<Point2D>();
 
     private readonly List<GeometryPoint> points = new List<GeometryPoint>();
-    private bool isFrozen;
-    private bool hasNaNx;
-    private readonly double frozenMaxZ = double.NaN;
-
-    // sortedPoints must never be used outside this class. Either the GPS concerned must have sorted points but then they already are 
-    // (eg. surfaceline, headline) or they may be unsorted in which case using the sorted list in other classes leads to errors (eg.
-    // geometrysurfaces, waternetlines) 
-    private List<Point2D> sortedPoints;
-
+    
     /// <summary>
     /// Gets the <see cref="GeometryPoint"/> at the specified index.
     /// </summary>
@@ -202,11 +194,6 @@
     /// <returns></returns>
     public double GetMaxZ()
     {
-        if (isFrozen)
-        {
-            return frozenMaxZ;
-        }
-
         return CalcPoints.Any()
                    ? CalcPoints.Max(p => p.Z)
                    : double.NaN;
@@ -220,11 +207,6 @@
     /// <returns>The minimal X value or <see cref="double.NaN"/> in case there are no points.</returns>
     public double GetMinX()
     {
-        if (isFrozen && !hasNaNx)
-        {
-            return sortedPoints[0].X;
-        }
-
         return CalcPoints.Any(p => !double.IsNaN(p.X))
                    ? CalcPoints.Where(p => !double.IsNaN(p.X)).Min(p => p.X)
                    : double.NaN;
@@ -238,11 +220,6 @@
     /// <returns></returns>
     public double GetMaxX()
     {
-        if (isFrozen && !hasNaNx)
-        {
-            return sortedPoints[sortedPoints.Count - 1].X;
-        }
-
         return CalcPoints.Any(p => !double.IsNaN(p.X))
                    ? CalcPoints.Where(p => !double.IsNaN(p.X)).Max(p => p.X)
                    : double.NaN;
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPoint.cs
===================================================================
diff -u -r5480 -r5494
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPoint.cs	(.../GeometryPoint.cs)	(revision 5480)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryPoint.cs	(.../GeometryPoint.cs)	(revision 5494)
@@ -37,8 +37,6 @@
     /// </summary>
     public const double Precision = GeometryConstants.Accuracy;
 
-    private object owner;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="GeometryPoint"/> class.
     /// </summary>