Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs
===================================================================
diff -u -r4540 -r6087
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 4540)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs	(.../SurfaceLine2.cs)	(revision 6087)
@@ -107,15 +107,15 @@
     /// Define a new characteristic point on the surface line with the given characteristic 
     /// point annotation.
     /// </summary>
-    /// <param name="geometryPoint">The point to be added. Cannot be null.</param>
-    /// <param name="annotations">The annotations for <paramref name="geometryPoint"/>.</param>
-    public void AddCharacteristicPoint(GeometryPoint geometryPoint, params CharacteristicPointType[] annotations)
+    /// <param name="point">The point to be added. Cannot be null.</param>
+    /// <param name="annotations">The annotations for <paramref name="point"/>.</param>
+    public void AddCharacteristicPoint(Point2D point, params CharacteristicPointType[] annotations)
     {
         if (annotations == null || annotations.Length == 0)
         {
             CharacteristicPoints.Add(new CharacteristicPoint
             {
-                GeometryPoint = geometryPoint,
+                Point = point,
                 CharacteristicPointType = CharacteristicPointType.None
             });
         }
@@ -125,7 +125,7 @@
             {
                 CharacteristicPoints.Add(new CharacteristicPoint
                 {
-                    GeometryPoint = geometryPoint,
+                    Point = point,
                     CharacteristicPointType = type
                 });
             }
@@ -141,7 +141,7 @@
     /// <param name="annotations">The annotations for geometryPoint with x, z/>.</param>
     public void AddCharacteristicPoint(double x, double z, params CharacteristicPointType[] annotations)
     {
-        var geometryPoint = new GeometryPoint(x, z);
+        var geometryPoint = new Point2D(x, z);
         AddCharacteristicPoint(geometryPoint, annotations);
     }
 
@@ -150,9 +150,9 @@
     /// </summary>
     /// <param name="geometryPoint"></param>
     /// <returns></returns>
-    public IEnumerable<CharacteristicPointType> GetCharacteristicPoints(GeometryPoint geometryPoint)
+    public IEnumerable<CharacteristicPointType> GetCharacteristicPoints(Point2D geometryPoint)
     {
-        return CharacteristicPoints.Where(cp => ReferenceEquals(cp.GeometryPoint, geometryPoint))
+        return CharacteristicPoints.Where(cp => ReferenceEquals(cp.Point, geometryPoint))
                                    .Select(cp => cp.CharacteristicPointType);
     }
 
@@ -171,7 +171,7 @@
     /// <param name="endX">The end x.</param>
     /// <returns>collection of points between start X and end X (inlcuding those)</returns>
     /// <exception cref="System.ArgumentException">End value is smaller then the start value</exception>
-    public virtual IEnumerable<GeometryPoint> GetPointSegmentIncluding(double startX, double endX)
+    public virtual IEnumerable<Point2D> GetPointSegmentIncluding(double startX, double endX)
     {
         if (endX < startX)
         {
@@ -234,11 +234,11 @@
     /// <value>
     /// The points orderd by x.
     /// </value>
-    private IEnumerable<GeometryPoint> PointsOrderedByX
+    private IEnumerable<Point2D> PointsOrderedByX
     {
         get
         {
-            return Geometry.Points.OrderBy(p => p.X);
+            return Geometry.CalcPoints.OrderBy(p => p.X);
         }
     }
 
@@ -249,16 +249,16 @@
     /// <param name="startX">The start x.</param>
     /// <param name="endX">The end x.</param>
     /// <returns><c>true</c> if the given point is between the given start X and end X, otherwise <c>false</c></returns>
-    private bool TestIncluding(GeometryPoint point, double startX, double endX)
+    private bool TestIncluding(Point2D point, double startX, double endX)
     {
         if (point == null)
         {
             return false;
         }
 
         double x = point.X;
-        return (x >= startX || x.AlmostEquals(startX, GeometryPoint.Precision))
-               && (x <= endX || x.AlmostEquals(endX, GeometryPoint.Precision));
+        return (x >= startX || x.AlmostEquals(startX, GeometryConstants.Accuracy))
+               && (x <= endX || x.AlmostEquals(endX, GeometryConstants.Accuracy));
     }
 
     /// <summary>
@@ -278,19 +278,19 @@
         CharacteristicPoints.GeometryMustContainPoint = source.CharacteristicPoints.GeometryMustContainPoint;
         Geometry = cloneGeometry ? source.Geometry.Clone() : source.Geometry;
 
-        Dictionary<GeometryPoint, CharacteristicPointType[]> geometryAnnotations = GetCharacteristicAnnotationsInSource(source, cloneGeometry);
+        Dictionary<Point2D, CharacteristicPointType[]> geometryAnnotations = GetCharacteristicAnnotationsInSource(source, cloneGeometry);
 
         // Reconstruct annotation state from dictionary:
         if (CharacteristicPoints.GeometryMustContainPoint)
         {
-            foreach (KeyValuePair<GeometryPoint, CharacteristicPointType[]> annotation in geometryAnnotations)
+            foreach (KeyValuePair<Point2D, CharacteristicPointType[]> annotation in geometryAnnotations)
             {
                 for (var i = 0; i < annotation.Value.Length; i++)
                 {
                     int index = -1;
                     for (var j = 0; j < CharacteristicPoints.Count; j++)
                     {
-                        if (ReferenceEquals(CharacteristicPoints[j].GeometryPoint, annotation.Key))
+                        if (ReferenceEquals(CharacteristicPoints[j].Point, annotation.Key))
                         {
                             index = j;
                             break;
@@ -315,9 +315,9 @@
         }
         else
         {
-            foreach (KeyValuePair<GeometryPoint, CharacteristicPointType[]> annotation in geometryAnnotations)
+            foreach (KeyValuePair<Point2D, CharacteristicPointType[]> annotation in geometryAnnotations)
             {
-                AddCharacteristicPoint((GeometryPoint) annotation.Key.Clone(), annotation.Value);
+                AddCharacteristicPoint((Point2D) annotation.Key.Clone(), annotation.Value);
             }
         }
     }
@@ -333,7 +333,7 @@
     /// take the same instance instead.</param>
     /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
     /// that have annotations.</returns>
-    private Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource(SurfaceLine2 source, bool cloneGeometry)
+    private Dictionary<Point2D, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource(SurfaceLine2 source, bool cloneGeometry)
     {
         return CharacteristicPoints.GeometryMustContainPoint
                    ? GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(source, cloneGeometry)
@@ -350,15 +350,15 @@
     /// take the same instance instead.</param>
     /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
     /// that have annotations.</returns>
-    private Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(SurfaceLine2 source, bool cloneGeometry)
+    private Dictionary<Point2D, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(SurfaceLine2 source, bool cloneGeometry)
     {
-        var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
+        var geometryAnnotations = new Dictionary<Point2D, CharacteristicPointType[]>();
         for (var i = 0; i < source.Geometry.Count; i++)
         {
-            CharacteristicPointType[] annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.Points[i]).Where(cpt => cpt != CharacteristicPointType.None).ToArray();
+            CharacteristicPointType[] annotationsForPoint = source.GetCharacteristicPoints(source.Geometry.CalcPoints[i]).Where(cpt => cpt != CharacteristicPointType.None).ToArray();
             if (annotationsForPoint.Length > 0)
             {
-                geometryAnnotations[Geometry.Points[i]] = annotationsForPoint;
+                geometryAnnotations[Geometry.CalcPoints[i]] = annotationsForPoint;
             }
         }
 
@@ -372,15 +372,15 @@
     /// <param name="source">The referenced surfaceline.</param>
     /// <returns>Dictionary keyed on <see cref="GeometryPoint"/> instances in the surfaceline
     /// that have annotations.</returns>
-    private static Dictionary<GeometryPoint, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(SurfaceLine2 source)
+    private static Dictionary<Point2D, CharacteristicPointType[]> GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(SurfaceLine2 source)
     {
-        var geometryAnnotations = new Dictionary<GeometryPoint, CharacteristicPointType[]>();
+        var geometryAnnotations = new Dictionary<Point2D, CharacteristicPointType[]>();
         foreach (CharacteristicPoint characteristicPoint in source.CharacteristicPoints)
         {
-            if (!geometryAnnotations.ContainsKey(characteristicPoint.GeometryPoint))
+            if (!geometryAnnotations.ContainsKey(characteristicPoint.Point))
             {
-                geometryAnnotations[characteristicPoint.GeometryPoint] =
-                    source.GetCharacteristicPoints(characteristicPoint.GeometryPoint).ToArray();
+                geometryAnnotations[characteristicPoint.Point] =
+                    source.GetCharacteristicPoints(characteristicPoint.Point).ToArray();
             }
         }