Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs =================================================================== diff -u -r4000 -r4052 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs (.../SurfaceLineShoulderAdapterTest.cs) (revision 4000) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators.Tests/DikesDesign/SurfaceLineShoulderAdapterTest.cs (.../SurfaceLineShoulderAdapterTest.cs) (revision 4052) @@ -28,2650 +28,2649 @@ using Deltares.DamEngine.Data.Geotechnics; using NUnit.Framework; -namespace Deltares.DamEngine.Calculators.Tests.DikesDesign +namespace Deltares.DamEngine.Calculators.Tests.DikesDesign; + +[TestFixture] +public class SurfaceLineShoulderAdapterTest { - [TestFixture] - public class SurfaceLineShoulderAdapterTest - { - const double pointCoordinateTolerance = 0.001; + const double pointCoordinateTolerance = 0.001; - [Test] - public void ThrowsAnExceptionWhenNoSurfaceLevelPointExist() + [Test] + public void ThrowsAnExceptionWhenNoSurfaceLevelPointExist() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - 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); - Assert.That(() => new SurfaceLineShoulderAdapter(surfaceLine, location, 0), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + 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); + Assert.That(() => new SurfaceLineShoulderAdapter(surfaceLine, location, 0), Throws.InstanceOf()); + } - /// - /// Test if ConstructNewSurfaceLine returns a new surface line. - /// - [Test] - public void ConstructNewSurfaceLineReturnsANewSurfaceLine() + /// + /// Test if ConstructNewSurfaceLine returns a new surface line. + /// + [Test] + public void ConstructNewSurfaceLineReturnsANewSurfaceLine() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - 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, 0); - SurfaceLine2 constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(0, 0, false); - Assert.IsNotNull(constructNewSurfaceLine); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + 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, 0); + SurfaceLine2 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() + /// + /// Test if adapt the surface line without shoulder returns surfaceline with both characteristic points at shoulder inside. + /// + [Test] + public void AdaptedSurfaceLineWithoutShoulderMustHaveBothCharacteristicPointsAtShoulderInside() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside)); - Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, 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() + /// + /// Test if adapted surface line without shoulder has correct point at top shoulder inside. + /// + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInside() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.67; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel - pointAtToePolder.Z); - var expectedPoint = new GeometryPoint(3.33, expectedShoulderHeight); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.67; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel - pointAtToePolder.Z); + var expectedPoint = new GeometryPoint(3.33, expectedShoulderHeight); + GeometryPoint 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() + /// + /// Test if adapted surface line without shoulder has correct intersection point at dike. + /// + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDike() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint 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() + /// + /// Test if adapted surface line without shoulder has correct intersection point at ground level. + /// + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtGroundLevel() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z)); - var expectedPoint = new GeometryPoint( - pointAtTopPolder.X + (1 - expectedShoulderHeight) + shoulderLength + expectedShoulderHeight * surfaceLineAdapter.SlopeOfNewShoulder, 0); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z)); + var expectedPoint = new GeometryPoint( + pointAtTopPolder.X + (1 - expectedShoulderHeight) + shoulderLength + expectedShoulderHeight * surfaceLineAdapter.SlopeOfNewShoulder, 0); + GeometryPoint 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() + /// + /// Test if adapted surface line without shoulder that the new shoulder should is not higher then top of dike. + /// + [Test] + public void AdaptedSurfaceLineWithoutShoulderNewShoulderShouldNotBeHeigherThenTopOfDike() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedZ = pointAtTopPolder.Z; - double actualZ = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z; - Assert.AreEqual(expectedZ, actualZ); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedZ = pointAtTopPolder.Z; + double actualZ = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z; + Assert.AreEqual(expectedZ, actualZ); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderNewShoulderLengthShouldExpand() + [Test] + public void AdaptedSurfaceLineWithoutShoulderNewShoulderLengthShouldExpand() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, 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 + shoulderLength, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X); - Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z); - Assert.AreEqual(expectedShoulderBaseX + shoulderLength + surfaceLineAdapter.SlopeOfNewShoulder * expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X); - Assert.AreEqual(0, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, 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 + shoulderLength, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X); + Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z); + Assert.AreEqual(expectedShoulderBaseX + shoulderLength + surfaceLineAdapter.SlopeOfNewShoulder * expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X); + Assert.AreEqual(0, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); + } - [Test] - public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtTopShoulderInside() + [Test] + public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtTopShoulderInside() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.67; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.66, 0.67); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.67; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.66, 0.67); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + } - [Test] - public void AdaptedSurfaceLineWithShoulderHasCorrectShoulderPoints() + [Test] + public void AdaptedSurfaceLineWithShoulderHasCorrectShoulderPoints() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - surfaceLineAdapter.MaxShoulderLevel = 0.67 + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(6.00, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); - Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); - expectedPoint = new GeometryPoint(4.66, 1.67); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); - Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); - expectedPoint = new GeometryPoint(2.66, 1.67); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); - Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + surfaceLineAdapter.MaxShoulderLevel = 0.67 + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(6.00, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); + Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); + expectedPoint = new GeometryPoint(4.66, 1.67); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); + Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); + expectedPoint = new GeometryPoint(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() + [Test] + public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtInsteekShoulderInside() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(2.857, 1.0); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); - Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(2.857, 1.0); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance); + Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance); + } - [Test] - public void AdaptedSurfaceLineHasCorrectTail() + [Test] + public void AdaptedSurfaceLineHasCorrectTail() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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); - 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); - var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double xToePolder = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X; - double xSurfaceLevelInside = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X; - IEnumerable 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()); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside); - double actualXValue = pointAtSurfaceLevelInside.X; - Assert.AreEqual(actualXValue, actualPoint.X, pointCoordinateTolerance); - Assert.AreEqual(pointAtSurfaceLevelInside.Z, actualPoint.Z, pointCoordinateTolerance); - Assert.IsTrue(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint2))); - Assert.IsFalse(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint1))); - } - - [Test] - public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside() + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 1; + const int shoulderHeight = 1; + var pointAtToeRiver = new GeometryPoint { - SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside(); - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); - } - - [Test] - public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointInSlopeHasCorrectPointsInside() + X = 0, + Z = 0 + }; + var pointAtTopRiver = new GeometryPoint { - SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside(); - var location = new Location(); - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - Assert.AreEqual(7, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(8, adaptedSurfaceLine.Geometry.Points.Count); - EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); - } - - [Test] - public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside() + X = 1, + Z = 4 + }; + var pointAtTopPolder = new GeometryPoint { - SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); - var location = new Location(); - const int shoulderLength = 2; - const int shoulderHeight = 1; - var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); - } + 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); + 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); + var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double xToePolder = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X; + double xSurfaceLevelInside = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X; + IEnumerable 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()); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside); + double actualXValue = pointAtSurfaceLevelInside.X; + Assert.AreEqual(actualXValue, actualPoint.X, pointCoordinateTolerance); + Assert.AreEqual(pointAtSurfaceLevelInside.Z, actualPoint.Z, pointCoordinateTolerance); + Assert.IsTrue(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint2))); + Assert.IsFalse(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint1))); + } - [Test] - public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointsHasCorrectPointsInside() + [Test] + public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside(); + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); + } + + [Test] + public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointInSlopeHasCorrectPointsInside() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside(); + var location = new Location(); + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + Assert.AreEqual(7, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(8, adaptedSurfaceLine.Geometry.Points.Count); + EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); + } + + [Test] + public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); + var location = new Location(); + const int shoulderLength = 2; + const int shoulderHeight = 1; + var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); + } + + [Test] + public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointsHasCorrectPointsInside() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); + var location = new Location(); + const int shoulderLength = 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, 0) { - SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - Assert.AreEqual(12, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(9, adaptedSurfaceLine.Geometry.Points.Count); - EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); - } + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + Assert.AreEqual(12, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(9, adaptedSurfaceLine.Geometry.Points.Count); + EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength); + } - [Test] - public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints() + [Test] + public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); + var location = new Location(); + const double cTolerance = 0.0000001; + var pointTrafficLoadOutside = new GeometryPoint { - SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside(); - var location = new Location(); - const double cTolerance = 0.0000001; - 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); - const int shoulderLength = 2; - const int shoulderHeight = 1; - var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - 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); - } + 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); + const int shoulderLength = 2; + const int shoulderHeight = 1; + var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + 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() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitch() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(11.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(14.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(9, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(11.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(14.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(9, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasDitchBottomMadeHorizontal() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasDitchBottomMadeHorizontal() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(11.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(14.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(9, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(11.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(14.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(9, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasNoInBetweenPointAfterAdaption() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasNoInBetweenPointAfterAdaption() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - Assert.AreEqual(10, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + Assert.AreEqual(10, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtNewDitchLocation() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtNewDitchLocation() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(11.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(18.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(11, surfaceLine.Geometry.Points.Count); - Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(11.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(18.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(11, surfaceLine.Geometry.Points.Count); + Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(11.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(14.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - var expectedExtraPointBeyondDitchUnchanged = new GeometryPoint(20, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2]; - Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged.LocationEquals(actualPoint)); - Assert.AreEqual(12, surfaceLine.Geometry.Count); - Assert.AreEqual(13, adaptedSurfaceLine.Geometry.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(11.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(14.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + var expectedExtraPointBeyondDitchUnchanged = new GeometryPoint(20, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2]; + Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged.LocationEquals(actualPoint)); + Assert.AreEqual(12, surfaceLine.Geometry.Count); + 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() + /// + /// 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() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(11.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(14.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - var expectedExtraPointBeyondDitchUnchanged1 = new GeometryPoint(19, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 3]; - Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged1.LocationEquals(actualPoint)); - var expectedExtraPointBeyondDitchUnchanged2 = new GeometryPoint(20, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2]; - Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged2.LocationEquals(actualPoint)); - Assert.AreEqual(12, surfaceLine.Geometry.Count); - Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(11.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(14.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + var expectedExtraPointBeyondDitchUnchanged1 = new GeometryPoint(19, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 3]; + Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged1.LocationEquals(actualPoint)); + var expectedExtraPointBeyondDitchUnchanged2 = new GeometryPoint(20, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2]; + Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged2.LocationEquals(actualPoint)); + Assert.AreEqual(12, surfaceLine.Geometry.Count); + Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count); + } - [Test] - public void ThrowsAnExceptionWhenNewShoulderDoesNotFit() + [Test] + public void ThrowsAnExceptionWhenNewShoulderDoesNotFit() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0); - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0); + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - [Test] - public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFit() + [Test] + public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFit() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const double shoulderLength = 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, 0); - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const double shoulderLength = 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, 0); + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - [Test] - public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFitWithDitch() + [Test] + public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFitWithDitch() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const double shoulderLength = 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, 0); - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const double shoulderLength = 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, 0); + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight05() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight05() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewMaxHeightShoulderAsFraction = true; - location.NewMaxHeightShoulderAsFraction = 0.5; - const int shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = location.NewMaxHeightShoulderAsFraction * - (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); - var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewMaxHeightShoulderAsFraction = true; + location.NewMaxHeightShoulderAsFraction = 0.5; + const int shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = location.NewMaxHeightShoulderAsFraction * + (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); + var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight1() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight1() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewMaxHeightShoulderAsFraction = true; - location.NewMaxHeightShoulderAsFraction = 1; - const int shoulderLength = 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, 0); - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z)); - var expectedPoint = new GeometryPoint(3, expectedShoulderHeight); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewMaxHeightShoulderAsFraction = true; + location.NewMaxHeightShoulderAsFraction = 1; + const int shoulderLength = 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, 0); + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z)); + var expectedPoint = new GeometryPoint(3, expectedShoulderHeight); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + } - [Test] - public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithResetLimitedMaxHeight() + [Test] + public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithResetLimitedMaxHeight() + { + const double maxFractionOfDikeHeightForShoulderHeight = 0.5; + var surfaceLine = new SurfaceLine2 { - const double maxFractionOfDikeHeightForShoulderHeight = 0.5; - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewMaxHeightShoulderAsFraction = true; - location.NewMaxHeightShoulderAsFraction = 1; - const int shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = maxFractionOfDikeHeightForShoulderHeight * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); - var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewMaxHeightShoulderAsFraction = true; + location.NewMaxHeightShoulderAsFraction = 1; + const int shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = maxFractionOfDikeHeightForShoulderHeight * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z); + var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + } - [Test] - public void AdaptedSurfaceLineWithNewTopSlopeAngle() + [Test] + public void AdaptedSurfaceLineWithNewTopSlopeAngle() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewShoulderTopSlope = true; - location.NewShoulderTopSlope = 0.05; - const double shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.8 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedBasePoint = new GeometryPoint(2.263, 0.737); - GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); - var expectedTopPoint = new GeometryPoint(7, 0.5); - GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); - var expectedToePoint = new GeometryPoint(8.5, 0.0); - GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewShoulderTopSlope = true; + location.NewShoulderTopSlope = 0.05; + const double shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.8 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedBasePoint = new GeometryPoint(2.263, 0.737); + GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); + var expectedTopPoint = new GeometryPoint(7, 0.5); + GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); + var expectedToePoint = new GeometryPoint(8.5, 0.0); + GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); + } - [Test] - public void AdaptedSurfaceLineWithNewVerySteepTopSlopeAngle() + [Test] + public void AdaptedSurfaceLineWithNewVerySteepTopSlopeAngle() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewShoulderTopSlope = true; - location.NewShoulderTopSlope = 0.5; - const double shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - // TODO (The) what to do with the outcommented code? - // 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)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewShoulderTopSlope = true; + location.NewShoulderTopSlope = 0.5; + const double shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + // TODO (The) what to do with the outcommented code? + // 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() + [Test] + public void AdaptedSurfaceLineWithNewBaseSlopeAngle() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewShoulderBaseSlope = true; - location.NewShoulderBaseSlope = 1; - const double shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedBasePoint = new GeometryPoint(2.5, 0.5); - GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); - var expectedTopPoint = new GeometryPoint(7, 0.5); - GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); - var expectedToePoint = new GeometryPoint(7.5, 0.0); - GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewShoulderBaseSlope = true; + location.NewShoulderBaseSlope = 1; + const double shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedBasePoint = new GeometryPoint(2.5, 0.5); + GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); + var expectedTopPoint = new GeometryPoint(7, 0.5); + GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); + var expectedToePoint = new GeometryPoint(7.5, 0.0); + GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); + } - [Test] - public void AdaptedSurfaceLineWithNewBaseSlopeAngleButWithReset() + [Test] + public void AdaptedSurfaceLineWithNewBaseSlopeAngleButWithReset() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewShoulderBaseSlope = true; - location.NewShoulderBaseSlope = 1; - const double shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - surfaceLineAdapter.SlopeOfNewShoulder = 2; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedBasePoint = new GeometryPoint(2.5, 0.5); - GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); - var expectedTopPoint = new GeometryPoint(7, 0.5); - GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); - var expectedToePoint = new GeometryPoint(8, 0.0); - GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewShoulderBaseSlope = true; + location.NewShoulderBaseSlope = 1; + const double shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + surfaceLineAdapter.SlopeOfNewShoulder = 2; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedBasePoint = new GeometryPoint(2.5, 0.5); + GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint)); + var expectedTopPoint = new GeometryPoint(7, 0.5); + GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint)); + var expectedToePoint = new GeometryPoint(8, 0.0); + GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint)); + } - [Test] - public void AdaptedSurfaceLineWithNewBaseSlopeAngleFarTooShallow() + [Test] + public void AdaptedSurfaceLineWithNewBaseSlopeAngleFarTooShallow() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - location.UseNewShoulderBaseSlope = true; - location.NewShoulderBaseSlope = 0.001; - const double shoulderLength = 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, 0); - surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + location.UseNewShoulderBaseSlope = true; + location.NewShoulderBaseSlope = 0.001; + const double shoulderLength = 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, 0); + surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z; + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - [Test] - public void AdaptedSurfaceLineWithNewMinDistanceFromToe() + [Test] + public void AdaptedSurfaceLineWithNewMinDistanceFromToe() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(7.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(8.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(9.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(10.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(11, surfaceLine.Geometry.Count); - Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(7.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(8.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(9.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(10.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(11, surfaceLine.Geometry.Count); + Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count); + } - [Test] - public void AdaptedSurfaceLineWithLargeNewMinDistanceFromToe() + [Test] + public void AdaptedSurfaceLineWithLargeNewMinDistanceFromToe() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(37.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(38.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(39.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(40.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(11, surfaceLine.Geometry.Count); - Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(37.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(38.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(39.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(40.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(11, surfaceLine.Geometry.Count); + Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count); + } - [Test] - public void AdaptedSurfaceLineWithTooLargeNewMinDistanceFromToe() + [Test] + public void AdaptedSurfaceLineWithTooLargeNewMinDistanceFromToe() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 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, 0) - { - SlopeOfNewShoulder = 2 - }; - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 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, 0) + { + SlopeOfNewShoulder = 2 + }; + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - [Test] - public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinition() + [Test] + public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinition() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 1; - const int shoulderHeight = 1; - location.UseNewMinDistanceDikeToeStartDitch = true; - location.NewMinDistanceDikeToeStartDitch = 1; - location.UseNewDitchDefinition = true; - double 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, polderLevel) - { - SlopeOfNewShoulder = 2 - }; - SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); - var expectedPoint = new GeometryPoint(3.5, 1); - GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); - Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); - var expectedShoulderTopInside = new GeometryPoint(4.5, 1); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); - Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); - var expectedDikeToePolder = new GeometryPoint(6.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); - Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); - var expectedDitchDikeSide = new GeometryPoint(7.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); - Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchDikeSide = new GeometryPoint(9.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); - Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); - var expectedBottomDitchPolderSide = new GeometryPoint(11.5, -2); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); - Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); - var expectedDitchPolderSide = new GeometryPoint(13.5, 0); - actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); - Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); - Assert.AreEqual(11, surfaceLine.Geometry.Count); - Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 1; + const int shoulderHeight = 1; + location.UseNewMinDistanceDikeToeStartDitch = true; + location.NewMinDistanceDikeToeStartDitch = 1; + location.UseNewDitchDefinition = true; + double 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, polderLevel) + { + SlopeOfNewShoulder = 2 + }; + SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false); + var expectedPoint = new GeometryPoint(3.5, 1); + GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside); + Assert.IsTrue(expectedPoint.LocationEquals(actualPoint)); + var expectedShoulderTopInside = new GeometryPoint(4.5, 1); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside); + Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint)); + var expectedDikeToePolder = new GeometryPoint(6.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder); + Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint)); + var expectedDitchDikeSide = new GeometryPoint(7.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide); + Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchDikeSide = new GeometryPoint(9.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide); + Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint)); + var expectedBottomDitchPolderSide = new GeometryPoint(11.5, -2); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide); + Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint)); + var expectedDitchPolderSide = new GeometryPoint(13.5, 0); + actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide); + Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint)); + Assert.AreEqual(11, surfaceLine.Geometry.Count); + Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count); + } - [Test] - public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinitionFailsBecausePolderLevelIsTooHigh() + [Test] + public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinitionFailsBecausePolderLevelIsTooHigh() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - var location = new Location(); - const int shoulderLength = 1; - const int shoulderHeight = 1; - location.UseNewMinDistanceDikeToeStartDitch = true; - location.NewMinDistanceDikeToeStartDitch = 1; - location.UseNewDitchDefinition = true; - var 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, polderLevel) - { - SlopeOfNewShoulder = 2 - }; - Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); - } + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + var location = new Location(); + const int shoulderLength = 1; + const int shoulderHeight = 1; + location.UseNewMinDistanceDikeToeStartDitch = true; + location.NewMinDistanceDikeToeStartDitch = 1; + location.UseNewDitchDefinition = true; + var 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, polderLevel) + { + SlopeOfNewShoulder = 2 + }; + Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf()); + } - private SurfaceLine2 CreateSurfaceLineWithSkewedSurfaceLevelInside() + private SurfaceLine2 CreateSurfaceLineWithSkewedSurfaceLevelInside() + { + var surfaceLine = new SurfaceLine2 { - var surfaceLine = new SurfaceLine2 + CharacteristicPoints = { - CharacteristicPoints = - { - GeometryMustContainPoint = true - }, - Geometry = new GeometryPointString() - }; - 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 - }; + GeometryMustContainPoint = true + }, + Geometry = new GeometryPointString() + }; + 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; - } + 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 shoulderLength) - { - 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 + shoulderLength, 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); - } + private void EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(SurfaceLine2 surfaceLine, SurfaceLine2 adaptedSurfaceLine, double shoulderHeight, double shoulderLength) + { + 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 + shoulderLength, 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); + } - private SurfaceLine2 CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside() + private SurfaceLine2 CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside() + { + SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside(); + var pointShoulderBaseInside = new GeometryPoint { - SurfaceLine2 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 - }; + 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; - } + 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; } } \ No newline at end of file