Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs
===================================================================
diff -u -r1974 -r3079
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 1974)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 3079)
@@ -33,6 +33,11 @@
     /// <seealso cref="System.ICloneable" />
     public class GeometryData : GeometryObject
     {
+        private GeometryGenerator geometryGenerator;
+        private readonly List<GeometryCurve> newlyEffectedCurves = new List<GeometryCurve>();
+        private readonly List<Point2D> newlyEffectedPoints = new List<Point2D>();
+        private bool isRegeneratingGeometry;
+
         private readonly List<GeometryCurve> curveDataList = new List<GeometryCurve>();
 
         private readonly List<GeometryLoop> loopDataList = new List<GeometryLoop>();
@@ -47,6 +52,14 @@
 
         private bool updatingSurfaceLine;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GeometryData"/> class.
+        /// </summary>
+        public GeometryData()
+        {
+            geometryGenerator = null;
+        }
+
         #region properties
 
         /// <summary>
@@ -56,7 +69,7 @@
         /// The points.
         /// </value>
         [Validate]
-        public IList<Point2D> Points
+        public List<Point2D> Points
         {
             get
             {
@@ -65,6 +78,20 @@
         }
 
         /// <summary>
+        /// Gets the newly effected points.
+        /// </summary>
+        /// <value>
+        /// The newly effected points.
+        /// </value>
+        public List<Point2D> NewlyEffectedPoints
+        {
+            get
+            {
+                return newlyEffectedPoints;
+            }
+        }
+
+        /// <summary>
         /// gets the Curve data list.
         /// </summary>
         /// <value>
@@ -79,6 +106,20 @@
         }
 
         /// <summary>
+        /// Gets the newly effected curves.
+        /// </summary>
+        /// <value>
+        /// The newly effected curves.
+        /// </value>
+        public List<GeometryCurve> NewlyEffectedCurves
+        {
+            get
+            {
+                return newlyEffectedCurves;
+            }
+        }
+
+        /// <summary>
         /// gets the Loop data list.
         /// </summary>
         /// <value>
@@ -103,6 +144,35 @@
             }
         }
 
+        public void RegenerateGeometry()
+        {
+            if (isRegeneratingGeometry)
+            {
+                return;
+            }
+
+            isRegeneratingGeometry = true;
+            if (geometryGenerator == null)
+            {
+                geometryGenerator = new GeometryGenerator(this);
+            }
+            lock (this)
+            {
+                SynchronizeLoops();
+                RemoveDoublesFromNewlyEffectedPointsAndCurves();
+                Curves.Clear();
+                Points.Clear();
+                Points.AddRange(newlyEffectedPoints);
+                Curves.AddRange(newlyEffectedCurves);
+
+                geometryGenerator.GenerateGeometry();
+                newlyEffectedPoints.Clear();
+                newlyEffectedCurves.Clear();
+                UpdateSurfaceLine();
+            }
+            isRegeneratingGeometry = false;
+        }
+
         /// <summary>
         /// Gets the minimum geometry points x.
         /// </summary>
@@ -225,6 +295,64 @@
             }
         }
 
+        public void RemoveDoublesFromNewlyEffectedPointsAndCurves()
+        {
+            var pdel = new List<Point2D>();
+            var par = newlyEffectedPoints.ToArray();
+            for (int i = 0; i < par.Length; i++)
+            {
+                for (int j = i; j < par.Length; j++)
+                {
+                    if (i != j && par[i].LocationEquals(par[j]))
+                    {
+                        if (!pdel.Contains(par[j]))
+                        {
+                            pdel.Add(par[j]);
+                        }
+                    }
+                }
+            }
+            foreach (var point in pdel)
+            {
+                newlyEffectedPoints.Remove(point);
+            }
+
+            var cdel = new List<GeometryCurve>();
+            var car = newlyEffectedCurves.ToArray();
+            // First remove all "illegal" newlyeffected curves
+            for (int i = 0; i < car.Length; i++)
+            {
+                if (car[i].HeadPoint == null || car[i].EndPoint == null || car[i].HeadPoint.LocationEquals(car[i].EndPoint))
+                {
+                    cdel.Add(car[i]);
+                }
+            }
+            foreach (var curve in cdel)
+            {
+                newlyEffectedCurves.Remove(curve);
+            }
+            // then remove all real doubles
+            var car2 = newlyEffectedCurves.ToArray();
+            cdel.Clear();
+            for (int i = 0; i < car2.Length; i++)
+            {
+                for (int j = i; j < car2.Length; j++)
+                {
+                    if (i != j && car2[i].LocationEquals(car2[j]))
+                    {
+                        if (!cdel.Contains(car2[j]))
+                        {
+                            cdel.Add(car2[j]);
+                        }
+                    }
+                }
+            }
+            foreach (var curve in cdel)
+            {
+                newlyEffectedCurves.Remove(curve);
+            }
+        }
+
         /// <summary>
         /// Gets all points on the Left boundary.
         /// </summary>
@@ -295,10 +423,10 @@
             pointDataList.Clear();
             curveDataList.Clear();
             surfaceDataList.Clear();
-
-//            newlyEffectedPoints.Clear();
-//            newlyEffectedCurves.Clear();
+            newlyEffectedPoints.Clear();
+            newlyEffectedCurves.Clear();
         }
+
         /// <summary>
         /// deletes all the Loop from IGeometryLoop.
         /// </summary>
@@ -338,7 +466,7 @@
         }
 
         /// <summary>
-        /// CheckIfIntersectStricktly
+        /// CheckIfIntersect
         /// Determines if two lines intersect each other stricktly (so no extrapolated points).
         /// </summary>
         /// <param name="aL1P1">Line 1 GeometryPoint 1</param>
@@ -543,27 +671,26 @@
         }
 
         /// <summary>
-        /// Updates the line at the top of the geometry
+        /// Deletes the point and the curves it belongs too.
         /// </summary>
-        private void UpdateSurfaceLine()
+        /// <param name="point">The point.</param>
+        public void DeletePointWithCurves(Point2D point)
         {
-            if (updatingSurfaceLine)
+            var curvesToDelete = new List<GeometryCurve>();
+            foreach (var curve in Curves)
             {
-                return;
+                if (curve.ContainsPoint(point))
+                {
+                    curvesToDelete.Add(curve);
+                }
             }
 
-            updatingSurfaceLine = true;
-
-            var bCurves = GetBoundaryCurves();
-            if (bCurves.Count == 0)
+            foreach (var curveToDelete in curvesToDelete)
             {
-                surfaceLine.CalcPoints.Clear();
+                Curves.Remove(curveToDelete);
             }
-            var curvesCopy = GetCurvesCopy(bCurves);
-            var curves = GetTopCurves(curvesCopy);
-            CreateSurfaceLinePointString(curves);
 
-            updatingSurfaceLine = false;
+            Points.Remove(point);
         }
 
         /// <summary>
@@ -789,5 +916,30 @@
             return (curve1.HeadPoint == curve2.HeadPoint || curve1.HeadPoint == curve2.EndPoint ||
                     curve1.EndPoint == curve2.HeadPoint || curve1.EndPoint == curve2.EndPoint);
         }
+
+        /// <summary>
+        /// Updates the line at the top of the geometry
+        /// </summary>
+        private void UpdateSurfaceLine()
+        {
+            if (updatingSurfaceLine)
+            {
+                return;
+            }
+
+            updatingSurfaceLine = true;
+
+            var bCurves = GetBoundaryCurves();
+            if (bCurves.Count == 0)
+            {
+                surfaceLine.CalcPoints.Clear();
+            }
+            var curvesCopy = GetCurvesCopy(bCurves);
+            var curves = GetTopCurves(curvesCopy);
+            CreateSurfaceLinePointString(curves);
+
+            updatingSurfaceLine = false;
+            surfaceLine.SyncPoints();
+        }
     }
 }
\ No newline at end of file