Index: DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.StixFileReader/SoilProfile2DDataModel.cs
===================================================================
diff -u -r5433 -r5922
--- DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.StixFileReader/SoilProfile2DDataModel.cs	(.../SoilProfile2DDataModel.cs)	(revision 5433)
+++ DamClients/DamUI/trunk/src/DamClientsLibrary/Deltares.Dam.StixFileReader/SoilProfile2DDataModel.cs	(.../SoilProfile2DDataModel.cs)	(revision 5922)
@@ -38,8 +38,9 @@
     ///     Converts a <see cref="PersistableDataModel" /> to a <see cref="SoilProfile2D" />.
     /// </summary>
     /// <param name="dataModel"></param>
+    /// <param name="offsetX"></param>
     /// <returns></returns>
-    public SoilProfile2D Create(PersistableDataModel dataModel)
+    public SoilProfile2D Create(PersistableDataModel dataModel, double offsetX)
     {
         string geometryId = dataModel.Scenarios.Last().Stages.Last().GeometryId;
         PersistableGeometry geometry = dataModel.Geometry.First(g => g.Id == geometryId);
@@ -48,13 +49,13 @@
 
         foreach (PersistableLayer layer in geometry.Layers)
         {
-            CreateCurvesFromLayer(layer, soilProfile2D.Geometry.Curves);
-            GeometrySurface surface = CreateSurfacesFromLayer(layer, soilProfile2D.Geometry.Surfaces);
+            CreateCurvesFromLayer(layer, soilProfile2D.Geometry.Curves, offsetX);
+            GeometrySurface surface = CreateSurfacesFromLayer(layer, soilProfile2D.Geometry.Surfaces, offsetX);
             foreach (PersistablePoint point in layer.Points)
             {
-                if (!IsPointPresent(point, soilProfile2D.Geometry.Points))
+                if (!IsPointPresent(point, soilProfile2D.Geometry.Points, offsetX))
                 {
-                    soilProfile2D.Geometry.Points.Add(new GeometryPoint(point.X, 0, point.Z));
+                    soilProfile2D.Geometry.Points.Add(new GeometryPoint(point.X + offsetX, 0, point.Z));
                 }
             }
 
@@ -74,17 +75,10 @@
             };
             soilProfile2D.Surfaces.Add(soilLayer2D);
         }
-        SetLimits(soilProfile2D);
+        soilProfile2D.Geometry.Rebox();
         return soilProfile2D;
     }
 
-    private static void SetLimits(SoilProfile2D soilProfile2D)
-    {
-        soilProfile2D.Geometry.Left = soilProfile2D.Geometry.MinGeometryPointsX;
-        soilProfile2D.Geometry.Right = soilProfile2D.Geometry.MaxGeometryPointsX;
-        soilProfile2D.Geometry.Bottom = soilProfile2D.Geometry.MinGeometryPointsZ;
-    }
-
     private Color FetchSoilColor(PersistableSoil persistableSoil, PersistableDataModel dataModel)
     {
         var color = new Color();
@@ -123,16 +117,16 @@
         return soilId == string.Empty ? null : dataModel.Soils.Soils.FirstOrDefault(soil => soil.Id == soilId);
     }
 
-    private GeometrySurface CreateSurfacesFromLayer(PersistableLayer layer, ICollection<GeometrySurface> geometrySurface)
+    private GeometrySurface CreateSurfacesFromLayer(PersistableLayer layer, ICollection<GeometrySurface> geometrySurface, double offsetX)
     {
         var surface = new GeometrySurface();
         for (var i = 0; i < layer.Points.Count(); i++)
         {
-            surface.OuterLoop.Points.Add(new GeometryPoint(layer.Points.ElementAt(i).X, 0, layer.Points.ElementAt(i).Z));
+            surface.OuterLoop.Points.Add(new GeometryPoint(layer.Points.ElementAt(i).X + offsetX, 0, layer.Points.ElementAt(i).Z));
 
             for (var j = 0; j < layer.Points.Count(); j++)
             {
-                GeometryCurve curve = CreateCurveFromLayer(layer, j);
+                GeometryCurve curve = CreateCurveFromLayer(layer, j, offsetX);
                 if (!IsCurvePresent(curve, surface.OuterLoop.CurveList))
                 {
                     surface.OuterLoop.CurveList.Add(curve);
@@ -148,42 +142,43 @@
         return surface;
     }
 
-    private void CreateCurvesFromLayer(PersistableLayer layer, ICollection<GeometryCurve> geometryCurves)
+    private void CreateCurvesFromLayer(PersistableLayer layer, ICollection<GeometryCurve> geometryCurves, double offsetX)
     {
         for (var i = 0; i < layer.Points.Count(); i++)
         {
-            GeometryCurve curve = CreateCurveFromLayer(layer, i);
+            GeometryCurve curve = CreateCurveFromLayer(layer, i, offsetX);
             if (!IsCurvePresent(curve, geometryCurves))
             {
                 geometryCurves.Add(curve);
             }
         }
+        //GeometryCurve curve = CreateCurveFromLayer(layer, i, offsetX);
     }
 
-    private GeometryCurve CreateCurveFromLayer(PersistableLayer layer, int index)
+    private GeometryCurve CreateCurveFromLayer(PersistableLayer layer, int index, double offsetX)
     {
         GeometryCurve curve;
         if (index == layer.Points.Count() - 1)
         {
-            curve = CreateCurve(layer.Points.ElementAt(index), layer.Points.ElementAt(0));
+            curve = CreateCurve(layer.Points.ElementAt(index), layer.Points.ElementAt(0), offsetX);
         }
         else
         {
-            curve = CreateCurve(layer.Points.ElementAt(index), layer.Points.ElementAt(index + 1));
+            curve = CreateCurve(layer.Points.ElementAt(index), layer.Points.ElementAt(index + 1), offsetX);
         }
 
         return curve;
     }
 
-    private GeometryCurve CreateCurve(PersistablePoint firstPoint, PersistablePoint secondPoint)
+    private GeometryCurve CreateCurve(PersistablePoint firstPoint, PersistablePoint secondPoint, double offsetX)
     {
         return new GeometryCurve
         {
-            HeadPoint = new GeometryPoint(firstPoint.X, 0, firstPoint.Z),
-            EndPoint = new GeometryPoint(secondPoint.X, 0, secondPoint.Z)
+            HeadPoint = new GeometryPoint(firstPoint.X + offsetX, 0, firstPoint.Z),
+            EndPoint = new GeometryPoint(secondPoint.X + offsetX, 0, secondPoint.Z)
         };
     }
-
+    
     private bool IsCurvePresent(GeometryCurve curve, IEnumerable<GeometryCurve> geometryCurves)
     {
         return geometryCurves.Any(geometryCurve =>
@@ -193,9 +188,9 @@
                                        ArePointsEqual(geometryCurve.HeadPoint, curve.EndPoint)));
     }
 
-    private bool IsPointPresent(PersistablePoint point, IEnumerable<GeometryPoint> geometryPoints)
+    private bool IsPointPresent(PersistablePoint point, IEnumerable<GeometryPoint> geometryPoints, double offsetX)
     {
-        return geometryPoints.Any(geometryPoint => ArePointsEqual(geometryPoint, point));
+        return geometryPoints.Any(geometryPoint => ArePointsEqual(geometryPoint, point, offsetX));
     }
 
     private bool ArePointsEqual(GeometryPoint firstPoint, GeometryPoint secondPoint)
@@ -206,11 +201,11 @@
                (Math.Abs(firstPoint.Z - secondPoint.Z) < pointTolerance);
     }
 
-    private bool ArePointsEqual(GeometryPoint firstPoint, PersistablePoint secondPoint)
+    private bool ArePointsEqual(GeometryPoint firstPoint, PersistablePoint secondPoint, double offsetX)
     {
         const double pointTolerance = 1E-6;
 
-        return (Math.Abs(firstPoint.X - secondPoint.X) < pointTolerance) &&
+        return (Math.Abs(firstPoint.X - (secondPoint.X + offsetX)) < pointTolerance) &&
                (Math.Abs(firstPoint.Z - secondPoint.Z) < pointTolerance);
     }
 }
\ No newline at end of file