//-----------------------------------------------------------------------
//
// Copyright (c) 2009 Deltares. All rights reserved.
//
// B.S.T.I.M. The
// tom.the@deltares.nl
// 03-12-2009
// Tests for SurfaceLineShoulderAdapter
//-----------------------------------------------------------------------
using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using System;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.Geotechnics.SurfaceLines;
using NUnit.Framework;
namespace Deltares.Dam.Tests
{
[TestFixture]
public class SurfaceLineShoulderAdapterTest
{
const double pointCoordinateTolerance = 0.001;
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void ThrowsAnExceptionWhenNoSurfaceLevelPointExist()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
}
}
///
/// Test if ConstructNewSurfaceLine returns a new surface line.
///
[Test]
public void ConstructNewSurfaceLineReturnsANewSurfaceLine()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(0, 0, false))
{
Assert.IsNotNull(constructNewSurfaceLine);
}
}
}
///
/// Test if adapt the surface line without shoulder returns surfaceline with both characteristic points at shoulder inside.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderMustHaveBothCharacteristicPointsAtShoulderInside()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
}
}
}
///
/// Test if adapted surface line without shoulder has correct point at top shoulder inside.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInside()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
surfaceLineAdapter.MaxShoulderLevel = 0.67;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel - pointAtToePolder.Z);
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.33, expectedShoulderHeight);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
///
/// Test if adapted surface line without shoulder has correct intersection point at dike.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDike()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
///
/// Test if adapted surface line without shoulder has correct intersection point at ground level.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtGroundLevel()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
var expectedPoint = GeometryPoint.CreateNewXZPoint(
pointAtTopPolder.X + (1 - expectedShoulderHeight) + shoulderWidth + expectedShoulderHeight * surfaceLineAdapter.SlopeOfNewShoulder, 0);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
///
/// Test if adapted surface line without shoulder that the new shoulder should is not higher then top of dike.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderNewShoulderShouldNotBeHeigherThenTopOfDike()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 3;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedZ = pointAtTopPolder.Z;
var actualZ = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z;
Assert.AreEqual(expectedZ, actualZ);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderNewShoulderWidthShouldExpand()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 3;
const int shoulderHeight = 3;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
double expectedShoulderBaseX = pointAtTopPolder.X + (1 - expectedShoulderHeight);
Assert.AreEqual(expectedShoulderBaseX, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).X);
Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z);
Assert.AreEqual(expectedShoulderBaseX + shoulderWidth, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X);
Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z);
Assert.AreEqual(expectedShoulderBaseX + shoulderWidth + surfaceLineAdapter.SlopeOfNewShoulder * expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X);
Assert.AreEqual(0, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
}
}
}
[Test]
public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtTopShoulderInside()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
surfaceLine.EnsurePointOfType(-100, 0, CharacteristicPointType.SurfaceLevelOutside);
surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(2, 1, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(3, 0.5, CharacteristicPointType.ShoulderBaseInside);
surfaceLine.EnsurePointOfType(4, 0.5, CharacteristicPointType.ShoulderTopInside);
surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
surfaceLineAdapter.MaxShoulderLevel = 0.67;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.66, 0.67);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithShoulderHasCorrectShoulderPoints()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 2;
const int shoulderHeight = 1;
surfaceLine.EnsurePointOfType(-100, 0, CharacteristicPointType.SurfaceLevelOutside);
surfaceLine.EnsurePointOfType(0, 1, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(1, 2, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(2, 2, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(3, 1.5, CharacteristicPointType.ShoulderBaseInside);
surfaceLine.EnsurePointOfType(4, 1.5, CharacteristicPointType.ShoulderTopInside);
surfaceLine.EnsurePointOfType(5, 1, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(100, 1, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
surfaceLineAdapter.MaxShoulderLevel = 0.67 + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
// Check if dike toe is correct
var expectedPoint = GeometryPoint.CreateNewXZPoint(6.00, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
// Check if shoulder top point is correct
expectedPoint = GeometryPoint.CreateNewXZPoint(4.66, 1.67);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
// Check if shoulderbase point is correct
expectedPoint = GeometryPoint.CreateNewXZPoint(2.66, 1.67);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
}
}
}
[Test]
public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtInsteekShoulderInside()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
surfaceLine.EnsurePointOfType(-1, 0, CharacteristicPointType.SurfaceLevelOutside);
surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(1, 4, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(2, 4, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(3, 0.5, CharacteristicPointType.ShoulderBaseInside);
surfaceLine.EnsurePointOfType(4, 0.5, CharacteristicPointType.ShoulderTopInside);
surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(10, 0, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(2.857, 1.0);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
}
}
}
[Test]
public void AdaptedSurfaceLineHasCorrectTail()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
//--------------
// test setup
//--------------
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 4 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 4 };
var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 0.5 };
var pointAtShoulderTop = new GeometryPoint { X = 4, Z = 0.5 };
var pointAtToePolder = new GeometryPoint { X = 5, Z = 0 };
var extraPoint1 = new GeometryPoint { X = 8, Z = -2 };
var extraPoint2 = new GeometryPoint { X = 9, Z = -1 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelOutside = new GeometryPoint { X = -1, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
// extra added points b
surfaceLine.EnsurePoint(extraPoint1.X, extraPoint1.Z);
surfaceLine.EnsurePoint(extraPoint2.X, extraPoint2.Z);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelOutside.X, pointAtSurfaceLevelOutside.Z, CharacteristicPointType.SurfaceLevelOutside);
//--------------
// actual test
//--------------
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
//--------------
// checks
//--------------
double xToePolder = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X;
double xSurfaceLevelInside = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X;
var actualExtraPoints = adaptedSurfaceLine.GetPointSegmentIncluding(xToePolder, xSurfaceLevelInside);
const int expectedNumberOfPoints = 9;
Assert.AreEqual(expectedNumberOfPoints, adaptedSurfaceLine.Geometry.Points.Count);
const int expectedNumberOfExtraPoints = 3;
Assert.AreEqual(expectedNumberOfExtraPoints, actualExtraPoints.Count());
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside);
var actualXValue = pointAtSurfaceLevelInside.X;
Assert.AreEqual(actualXValue, actualPoint.X, pointCoordinateTolerance);
Assert.AreEqual(pointAtSurfaceLevelInside.Z, actualPoint.Z, pointCoordinateTolerance);
// extra point 2 should still be there
Assert.IsTrue(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint2)));
// extra point 1 should still be deleted
Assert.IsFalse(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint1)));
}
}
}
private SurfaceLine2 CreateSurfaceLineWithSkewedSurfaceLevelInside()
{
var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
};
var pointSurfaceLevelOutside = new GeometryPoint { X = -1, Z = -1 };
var pointDikeToeAtRiver = new GeometryPoint { X = 0, Z = 0 };
var pointDikeTopAtRiver = new GeometryPoint { X = 4, Z = 4 };
var pointDikeTopAtPolder = new GeometryPoint { X = 6, Z = 4 };
var pointDikeToeAtPolder = new GeometryPoint { X = 10, Z = 0 };
var pointSurfaceLevelInside = new GeometryPoint { X = 18, Z = -1 };
surfaceLine.EnsurePointOfType(pointSurfaceLevelOutside.X, pointSurfaceLevelOutside.Z, CharacteristicPointType.SurfaceLevelOutside);
surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
surfaceLine.SortPoints();
return surfaceLine;
}
private void EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(SurfaceLine2 surfaceLine, SurfaceLine2 adaptedSurfaceLine, double shoulderHeight, double shoulderWidth)
{
const double cTolerance = 0.0000001;
Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z, cTolerance);
double intersectionInsideSlopeWithDikeBaseXCoordinate = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).X + (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
Assert.AreEqual(intersectionInsideSlopeWithDikeBaseXCoordinate - shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).X, cTolerance);
Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z, cTolerance);
Assert.AreEqual(intersectionInsideSlopeWithDikeBaseXCoordinate - shoulderHeight + shoulderWidth, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X, cTolerance);
double rightShift = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X;
Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, cTolerance);
Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, cTolerance);
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside()
{
using(var surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside())
using (var location = new Location())
{
const int shoulderWidth = 2;
const int shoulderHeight = 1;
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderWidth);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointInSlopeHasCorrectPointsInside()
{
using(var surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside())
using (var location = new Location())
{
const int shoulderWidth = 2;
const int shoulderHeight = 1;
surfaceLine.EnsurePoint(8, 1.9);
surfaceLine.SortPoints();
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
Assert.AreEqual(7, surfaceLine.Geometry.Points.Count);
Assert.AreEqual(8, adaptedSurfaceLine.Geometry.Points.Count);
EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderWidth);
}
}
}
private SurfaceLine2 CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside()
{
var surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside();
var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 0.9 };
var pointDikeToeAtPolder = new GeometryPoint { X = 13, Z = 0 };
surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.SortPoints();
return surfaceLine;
}
[Test]
public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside()
{
using(var surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside())
using (var location = new Location())
{
const int shoulderWidth = 2;
const int shoulderHeight = 1;
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderWidth);
}
}
}
[Test]
public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointsHasCorrectPointsInside()
{
using(var surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside())
using (var location = new Location())
{
const int shoulderWidth = 2;
const int shoulderHeight = 1;
surfaceLine.EnsurePoint(8, 1.9);
surfaceLine.EnsurePoint(10, 1);
surfaceLine.EnsurePoint(12, 0.5);
surfaceLine.EnsurePoint(14, -0.5);
surfaceLine.SortPoints();
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
Assert.AreEqual(12, surfaceLine.Geometry.Points.Count);
Assert.AreEqual(9, adaptedSurfaceLine.Geometry.Points.Count);
EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderWidth);
}
}
}
[Test]
public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints()
{
using (var surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside())
using (var location = new Location())
{
const double cTolerance = 0.0000001;
// Place traffic-load on shoulder
var pointTrafficLoadOutside = new GeometryPoint { X = 9.5, Z = 0.975 };
var pointTrafficLoadInside = new GeometryPoint { X = 10.5, Z = 0.925 };
surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
// Adapt shoulder
const int shoulderWidth = 2;
const int shoulderHeight = 1;
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
// Check resulting traffic load
var expectedPointTrafficLoadOutside = new GeometryPoint { X = 9.5, Z = 1.0 };
var expectedPointTrafficLoadInside = new GeometryPoint { X = 10.5, Z = 1.0 };
Assert.AreEqual(expectedPointTrafficLoadOutside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, cTolerance);
Assert.AreEqual(expectedPointTrafficLoadInside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, cTolerance);
Assert.AreEqual(expectedPointTrafficLoadOutside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
Assert.AreEqual(expectedPointTrafficLoadInside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitch()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(11.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(12.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(14.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
// two points added to the original surface line to create the shoulder, 1 "normal" point remains of old ditch
Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasDitchBottomMadeHorizontal()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -3 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(11.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(12.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(14.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
// two points added to the original surface line to create the shoulder, 1 remains from old ditch
Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasNoInBetweenPointAfterAdaption()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 12, Z = 0 };
var inBetweenPointAtSurfaceLevelInside = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = -90 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePoint(inBetweenPointAtSurfaceLevelInside.X, inBetweenPointAtSurfaceLevelInside.Z);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
Assert.AreEqual(10, surfaceLine.Geometry.Points.Count);
// one inbetweenpoint deleted, two shoulderpoints added so in total 1 point added.
Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtNewDitchLocation()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 12, Z = 0 };
var apoint = new GeometryPoint { X = 12.5, Z = 0 };
var apoint2 = new GeometryPoint { X = 13, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(11.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(12.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(18.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(11, surfaceLine.Geometry.Points.Count);
// two points deleted from the original surface line as they were in the new location of the ditch
// two points added to the original surface line to create the shoulder, so number of points remains!
Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count);
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 12, Z = 0 };
var apoint2 = new GeometryPoint { X = 13, Z = 0 };
var apoint3 = new GeometryPoint { X = 20, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
Assert.AreEqual(12, surfaceLine.Geometry.Points.Count);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(11.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(12.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(14.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
var expectedExtraPointBeyondDitchUnchanged = GeometryPoint.CreateNewXZPoint(20, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2];
Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged.LocationEquals(actualPoint));
Assert.AreEqual(12, surfaceLine.Geometry.Count);
// two points deleted from the original surface line as they were in the new location of the ditch
// two points added to the original surface line to create the shoulder, 1 point remains from the original ditch so in total + 1
Assert.AreEqual(13, adaptedSurfaceLine.Geometry.Count);
}
}
}
///
/// Test whether adapted the surface line without shoulder has correct intersection point at dike and ditch with points at and beyond new ditch location2.
///
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation2()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 12, Z = 0 };
var apoint2 = new GeometryPoint { X = 19, Z = 0 };
var apoint3 = new GeometryPoint { X = 20, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
Assert.AreEqual(12, surfaceLine.Geometry.Count);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(11.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(12.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(14.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
var expectedExtraPointBeyondDitchUnchanged1 = GeometryPoint.CreateNewXZPoint(19, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 3];
Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged1.LocationEquals(actualPoint));
var expectedExtraPointBeyondDitchUnchanged2 = GeometryPoint.CreateNewXZPoint(20, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2];
Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged2.LocationEquals(actualPoint));
Assert.AreEqual(12, surfaceLine.Geometry.Count);
// one point deleted from the original surface line as it was in the new location of the ditch
// two points added to the original surface line to create the shoulder, 1 point remains from old ditch so number of points new = + 2
Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count);
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void ThrowsAnExceptionWhenNewShoulderDoesNotFit()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 100;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var line = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFit()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const double shoulderWidth = 94.51;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z,
CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var line = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFitWithDitch()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const double shoulderWidth = 90.51;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 19, Z = 0 };
var apoint3 = new GeometryPoint { X = 20, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var line = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight05()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewMaxHeightShoulderAsFraction = true;
location.NewMaxHeightShoulderAsFraction = 0.5;
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
surfaceLineAdapter.MaxShoulderLevel = location.NewMaxHeightShoulderAsFraction *
(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) +
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, expectedShoulderHeight);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight1()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewMaxHeightShoulderAsFraction = true;
location.NewMaxHeightShoulderAsFraction = 1;
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
var expectedPoint = GeometryPoint.CreateNewXZPoint(3, expectedShoulderHeight);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithResetLimitedMaxHeight()
{
const double maxFractionOfDikeHeightForShoulderHeight = 0.5;
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewMaxHeightShoulderAsFraction = true;
location.NewMaxHeightShoulderAsFraction = 1;
const int shoulderWidth = 1;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = maxFractionOfDikeHeightForShoulderHeight * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, expectedShoulderHeight);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithNewTopSlopeAngle()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewShoulderTopSlope = true;
location.NewShoulderTopSlope = 0.05;
const double shoulderWidth = 4.5;
const double shoulderHeight = 0.5;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = 0.8 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedBasePoint = GeometryPoint.CreateNewXZPoint(2.263, 0.737);
var actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
var expectedTopPoint = GeometryPoint.CreateNewXZPoint(7, 0.5);
var actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
var expectedToePoint = GeometryPoint.CreateNewXZPoint(8.5, 0.0);
var actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void AdaptedSurfaceLineWithNewVerySteepTopSlopeAngle()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewShoulderTopSlope = true;
location.NewShoulderTopSlope = 0.5;
const double shoulderWidth = 4.5;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using(var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
// Dike top polder now coincides with the shoulder base.
// var expectedBasePoint = GeometryPoint.CreateNewXZPoint(2, 1);
// var actualBasePoint = adaptedSurfaceLine[CharacteristicPointType.ShoulderBaseInside];
// Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
// var actualDikeTopPoint = adaptedSurfaceLine[CharacteristicPointType.DikeTopAtPolder];
// Assert.IsTrue(expectedBasePoint.LocationEquals(actualDikeTopPoint));
// var expectedTopPoint = GeometryPoint.CreateNewXZPoint(7, 0.5);
// var actualTopPoint = adaptedSurfaceLine[CharacteristicPointType.ShoulderTopInside];
// Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
// var expectedToePoint = GeometryPoint.CreateNewXZPoint(8.5, 0.0);
// var actualToePoint = adaptedSurfaceLine[CharacteristicPointType.DikeToeAtPolder];
// Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithNewBaseSlopeAngle()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewShoulderBaseSlope = true;
location.NewShoulderBaseSlope = 1;
const double shoulderWidth = 4.5;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedBasePoint = GeometryPoint.CreateNewXZPoint(2.5, 0.5);
var actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
var expectedTopPoint = GeometryPoint.CreateNewXZPoint(7, 0.5);
var actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
var expectedToePoint = GeometryPoint.CreateNewXZPoint(7.5, 0.0);
var actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
}
}
}
[Test]
public void AdaptedSurfaceLineWithNewBaseSlopeAngleButWithReset()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewShoulderBaseSlope = true;
location.NewShoulderBaseSlope = 1;
const double shoulderWidth = 4.5;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
// Reset the slope
surfaceLineAdapter.SlopeOfNewShoulder = 2;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedBasePoint = GeometryPoint.CreateNewXZPoint(2.5, 0.5);
var actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
var expectedTopPoint = GeometryPoint.CreateNewXZPoint(7, 0.5);
var actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
var expectedToePoint = GeometryPoint.CreateNewXZPoint(8, 0.0);
var actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void AdaptedSurfaceLineWithNewBaseSlopeAngleFarTooShallow()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
location.UseNewShoulderBaseSlope = true;
location.NewShoulderBaseSlope = 0.001;
const double shoulderWidth = 4.5;
const int shoulderHeight = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location);
//set the max shoulder height locally
surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
[Test]
public void AdaptedSurfaceLineWithNewMinDistanceFromToe()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
location.UseNewMinDistanceDikeToeStartDitch = true;
location.NewMinDistanceDikeToeStartDitch = 1;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(7.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(8.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(9.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(10.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(11, surfaceLine.Geometry.Count);
// two points deleted from the original surface line as they were in the new location of the ditch
// two points added to the original surface line to create the shoulder, so number of points remains!
Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count);
}
}
}
[Test]
public void AdaptedSurfaceLineWithLargeNewMinDistanceFromToe()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
location.UseNewMinDistanceDikeToeStartDitch = true;
location.NewMinDistanceDikeToeStartDitch = 31;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(37.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(38.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(39.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(40.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(11, surfaceLine.Geometry.Count);
// two points added to the original surface line to create the shoulder, 1 point remains from old ditch
Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count);
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void AdaptedSurfaceLineWithTooLargeNewMinDistanceFromToe()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
location.UseNewMinDistanceDikeToeStartDitch = true;
location.NewMinDistanceDikeToeStartDitch = 131;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using(var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
[Test]
public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinition()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
location.UseNewMinDistanceDikeToeStartDitch = true;
location.NewMinDistanceDikeToeStartDitch = 1;
location.UseNewDitchDefinition = true;
location.PolderLevel = -0.2;
location.NewSlopeAngleDitch = 1;
location.NewDepthDitch = 1.8;
location.NewWidthDitchBottom = 2;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
var expectedPoint = GeometryPoint.CreateNewXZPoint(3.5, 1);
var actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
var expectedShoulderTopInside = GeometryPoint.CreateNewXZPoint(4.5, 1);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
var expectedDikeToePolder = GeometryPoint.CreateNewXZPoint(6.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
var expectedDitchDikeSide = GeometryPoint.CreateNewXZPoint(7.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchDikeSide = GeometryPoint.CreateNewXZPoint(9.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
var expectedBottomDitchPolderSide = GeometryPoint.CreateNewXZPoint(11.5, -2);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
var expectedDitchPolderSide = GeometryPoint.CreateNewXZPoint(13.5, 0);
actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
Assert.AreEqual(11, surfaceLine.Geometry.Count);
// two points deleted from the original surface line as they were in the new location of the ditch
// two points added to the original surface line to create the shoulder, so number of points remains!
Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count);
}
}
}
[Test]
[ExpectedException(typeof(SurfaceLineAdapterException))]
public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinitionFailsBecausePolderLevelIsTooHigh()
{
using (var surfaceLine = new SurfaceLine2
{
CharacteristicPoints = { GeometryMustContainPoint = true },
Geometry = new LocalizedGeometryPointString()
})
using (var location = new Location())
{
const int shoulderWidth = 1;
const int shoulderHeight = 1;
location.UseNewMinDistanceDikeToeStartDitch = true;
location.NewMinDistanceDikeToeStartDitch = 1;
location.UseNewDitchDefinition = true;
// Make Polderlevel far too high
location.PolderLevel = 20.2;
location.NewSlopeAngleDitch = 1;
location.NewDepthDitch = 1.8;
location.NewWidthDitchBottom = 2;
var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
var pointAtTopRiver = new GeometryPoint { X = 2, Z = 2 };
var pointAtTopPolder = new GeometryPoint { X = 3, Z = 2 };
var pointAtToePolder = new GeometryPoint { X = 4, Z = 0 };
var ditchTopAtDikeSide = new GeometryPoint { X = 5, Z = 0 };
var ditchBottomAtDikeSide = new GeometryPoint { X = 6, Z = -2 };
var ditchBottomAtPolderSide = new GeometryPoint { X = 7, Z = -2 };
var ditchTopAtPolderSide = new GeometryPoint { X = 8, Z = 0 };
var apoint = new GeometryPoint { X = 9, Z = 0 };
var apoint2 = new GeometryPoint { X = 10, Z = 0 };
var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location) { SlopeOfNewShoulder = 2 };
using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderWidth, shoulderHeight, false))
{
}
}
}
}
}