public void PolygonIntersectionWithPolygon_TouchesWithPointOnSide_ReturnsEmptyCollection()
{
// Setup
Point2D[] polyA = CreateBasePolygon();
var polyB = new[]
{
new Point2D(5, 0),
new Point2D(4, 2),
new Point2D(5, 4),
new Point2D(6, 4),
new Point2D(6, 0)
};
// Call
IEnumerable <IEnumerable <Point2D> > intersections = AdvancedMath2D.PolygonIntersectionWithPolygon(polyA, polyB);
// Assert
Assert.AreEqual(new[]
{
new[]
{
new Point2D(4, 2)
}
}, intersections);
}
public void FromXToXY_WithReferencePointOffsetAndRotation_ReturnsCoordinatesFromReferencePoint()
{
// Setup
const double center = 5.0;
double[] xCoordinates =
{
center - Math.Sqrt(8),
center,
center + Math.Sqrt(2)
};
var referencePoint = new Point2D(3, 4);
const double offset = 5;
const double rotation = 45;
// Call
IEnumerable <Point2D> points = AdvancedMath2D.FromXToXY(xCoordinates, referencePoint, offset, rotation);
// Assert
CollectionElementsAlmostEquals(new[]
{
new Point2D(1, 2),
new Point2D(3, 4),
new Point2D(4, 5)
}, points);
}
private static void AssertPopStatePoints(IEnumerable <MacroStabilityInwardsSoilLayer2D> layers, IEnumerable <PersistableStatePoint> popStatePoints)
{
IEnumerable <MacroStabilityInwardsSoilLayer2D> layersWithPop = layers.Where(l => l.Data.UsePop &&
l.Data.Pop.Mean != RoundedDouble.NaN &&
l.Data.Pop.CoefficientOfVariation != RoundedDouble.NaN);
Assert.AreEqual(layersWithPop.Count(), popStatePoints.Count());
for (var j = 0; j < layersWithPop.Count(); j++)
{
MacroStabilityInwardsSoilLayer2D layerWithPop = layersWithPop.ElementAt(j);
PersistableStatePoint statePoint = popStatePoints.ElementAt(j);
Assert.IsNotNull(statePoint.Id);
Assert.AreEqual($"POP - {layerWithPop.Data.MaterialName}", statePoint.Label);
Assert.IsNotNull(statePoint.LayerId);
Assert.IsTrue(statePoint.IsProbabilistic);
Point2D interiorPoint = AdvancedMath2D.GetPolygonInteriorPoint(layerWithPop.OuterRing.Points, layerWithPop.NestedLayers.Select(nl => nl.OuterRing.Points));
Assert.AreEqual(interiorPoint.X, statePoint.Point.X);
Assert.AreEqual(interiorPoint.Y, statePoint.Point.Z);
Assert.AreEqual(MacroStabilityInwardsSemiProbabilisticDesignVariableFactory.GetPop(layerWithPop.Data).GetDesignValue(), statePoint.Stress.Pop);
AssertStochasticParameter(layerWithPop.Data.Pop, statePoint.Stress.PopStochasticParameter);
}
}
private static IEnumerable <Point2D> GetWorldPoints(DikeProfile dikeProfile)
{
return(AdvancedMath2D.FromXToXY(
dikeProfile.DikeGeometry.Select(p => - p.Point.X),
dikeProfile.WorldReferencePoint,
-dikeProfile.X0,
dikeProfile.Orientation));
}
private static IEnumerable <Point2D> GetWorldPoints(ForeshoreProfile foreshoreProfile)
{
return(AdvancedMath2D.FromXToXY(
foreshoreProfile.Geometry.Select(p => - p.X).ToArray(),
foreshoreProfile.WorldReferencePoint,
-foreshoreProfile.X0,
foreshoreProfile.Orientation));
}
public void FromXToXY_NoPoints_ReturnsEmptyCollection()
{
// Call
IEnumerable <Point2D> points = AdvancedMath2D.FromXToXY(new double[0], new Point2D(0, 0), 3, 2);
// Assert
CollectionAssert.IsEmpty(points);
}
private static IEnumerable <Point2D[]> GetSoilLayerWithSurfaceLineIntersection(Point2D[] surfaceLineLocalGeometry, PipingSoilLayer soilLayer, PipingSoilProfile soilProfile)
{
IEnumerable <Point2D> surfaceLineAsPolygon = CreateSurfaceLinePolygonAroundSoilLayer(surfaceLineLocalGeometry, soilLayer, soilProfile);
Point2D[] soilLayerAsPolygon = CreateSurfaceLineWideSoilLayer(surfaceLineLocalGeometry, soilLayer, soilProfile);
return(AdvancedMath2D.PolygonIntersectionWithPolygon(surfaceLineAsPolygon, soilLayerAsPolygon));
}
private static IEnumerable <Point2D> CreateSurfaceLinePolygonAroundSoilLayer(IEnumerable <Point2D> surfaceLineLocalGeometry, PipingSoilLayer soilLayer, PipingSoilProfile soilProfile)
{
double topLevel = soilLayer.Top;
double bottomLevel = topLevel - soilProfile.GetLayerThickness(soilLayer);
double closingSurfaceLineToPolygonBottomLevel = Math.Min(surfaceLineLocalGeometry.Select(p => p.Y).Min(), bottomLevel) - 1;
return(AdvancedMath2D.CompleteLineToPolygon(surfaceLineLocalGeometry, closingSurfaceLineToPolygonBottomLevel).ToArray());
}
public void GetPolygonInteriorPoint_OuterRingNull_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.GetPolygonInteriorPoint(null, new IEnumerable <Point2D> [0]);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("outerRing", exception.ParamName);
}
public void GetPolygonInteriorPoint_InnerRingsNull_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.GetPolygonInteriorPoint(CreateBasePolygon(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("innerRings", exception.ParamName);
}
public void CompleteLineToPolygon_WithoutLine_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.CompleteLineToPolygon(null, double.NaN).ToArray();
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("line", exception.ParamName);
}
public void PointInPolygon_PointNull_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.PointInPolygon(null, Enumerable.Empty <Point2D>(), Enumerable.Empty <IEnumerable <Point2D> >());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("point", exception.ParamName);
}
public void PointInPolygon_InnerRingsNull_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.PointInPolygon(new Point2D(0, 0), Enumerable.Empty <Point2D>(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("innerRings", exception.ParamName);
}
public void PointInPolygon_PointOutsidePolygon_ReturnsFalse(IEnumerable <Point2D> outerRing, IEnumerable <IEnumerable <Point2D> > innerRings)
{
// Setup
var point = new Point2D(-1, -1);
// Call
bool pointInPolygon = AdvancedMath2D.PointInPolygon(point, outerRing, innerRings);
// Assert
Assert.IsFalse(pointInPolygon);
}
public void FromXToXY_WithoutReferencePoint_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.FromXToXY(new double[0], null, 3, 2);
// Assert
var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentNullException>(
Call, "Cannot transform to coordinates without a reference point.");
Assert.AreEqual("referencePoint", exception.ParamName);
}
public void FromXToXY_WithoutPoints_ThrowsArgumentNullException()
{
// Call
void Call() => AdvancedMath2D.FromXToXY(null, new Point2D(0, 0), 3, 2);
// Assert
var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentNullException>(
Call, "Cannot transform to coordinates without a source.");
Assert.AreEqual("xCoordinates", exception.ParamName);
}
public void GetPolygonInteriorPoint_TrianglePolygon_ReturnsInteriorPoint()
{
// Setup
Point2D[] outerRing = CreateTrianglePolygon();
// Call
Point2D interiorPoint = AdvancedMath2D.GetPolygonInteriorPoint(outerRing, new IEnumerable <Point2D> [0]);
// Assert
Assert.AreEqual(new Point2D(3, 2), interiorPoint);
}
public void FromXToXY_WithRotation180_ReturnsCoordinatesOnNegativeYAxis()
{
// Setup
double[] xCoordinates = ThreeRandomXCoordinates();
var referencePoint = new Point2D(0, 0);
// Call
IEnumerable <Point2D> points = AdvancedMath2D.FromXToXY(xCoordinates, referencePoint, 0, 180);
// Assert
CollectionElementsAlmostEquals(xCoordinates.Select(x => new Point2D(0, -x)), points);
}
public void GetPolygonInteriorPoint_PolygonWithHoles_ReturnsInteriorPoint()
{
// Setup
Point2D[] outerRing = CreateCustomPolygon();
Point2D[][] innerRings = CreateInnerRings();
// Call
Point2D interiorPoint = AdvancedMath2D.GetPolygonInteriorPoint(outerRing, innerRings);
// Assert
Assert.AreEqual(new Point2D(0.75, 2.5), interiorPoint);
}
public void FromXToXY_WithOffset_ReturnsCoordinatesNearerToOrigin()
{
// Setup
double[] xCoordinates = ThreeRandomXCoordinates();
var referencePoint = new Point2D(0, 0);
int offset = new Random(21).Next();
// Call
IEnumerable <Point2D> points = AdvancedMath2D.FromXToXY(xCoordinates, referencePoint, offset, 0);
// Assert
CollectionElementsAlmostEquals(xCoordinates.Select(x => new Point2D(0, x - offset)), points);
}
public void PointInPolygon_PointInHole_ReturnsFalse()
{
// Setup
Point2D[] outerRing = CreateCustomPolygon();
Point2D[][] innerRings = CreateInnerRings();
var point = new Point2D(2, 3);
// Call
bool pointInPolygon = AdvancedMath2D.PointInPolygon(point, outerRing, innerRings);
// Assert
Assert.IsFalse(pointInPolygon);
}
public void FromXToXY_WithReferencePoint_ReturnsCoordinatesFromReferencePoint()
{
// Setup
var random = new Random(21);
double[] xCoordinates = ThreeRandomXCoordinates();
var referencePoint = new Point2D(random.NextDouble(), random.NextDouble());
// Call
IEnumerable <Point2D> points = AdvancedMath2D.FromXToXY(xCoordinates, referencePoint, 0, 0);
// Assert
CollectionElementsAlmostEquals(xCoordinates.Select(x => new Point2D(referencePoint.X, referencePoint.Y + x)), points);
}
public void CompleteLineToPolygon_LineWithLessThanTwoPoints_ThrowsArgumentNullException([Range(0, 1)] int pointCount)
{
// Setup
IEnumerable <Point2D> points = Enumerable.Repeat(new Point2D(3, 2), pointCount);
// Call
void Call() => AdvancedMath2D.CompleteLineToPolygon(points, double.NaN).ToArray();
// Assert
const string message = "The line needs to have at least two points to be able to create a complete polygon.";
var exception = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentException>(Call, message);
Assert.AreEqual("line", exception.ParamName);
}
private static PersistableStatePoint CreatePOPStatePoint(MacroStabilityInwardsSoilLayer2D layer, MacroStabilityInwardsExportStageType stageType,
IdFactory idFactory, MacroStabilityInwardsExportRegistry registry)
{
Point2D interiorPoint = AdvancedMath2D.GetPolygonInteriorPoint(layer.OuterRing.Points, layer.NestedLayers.Select(layers => layers.OuterRing.Points));
return(new PersistableStatePoint
{
Id = idFactory.Create(),
LayerId = registry.GeometryLayers[stageType][layer],
IsProbabilistic = true,
Point = new PersistablePoint(interiorPoint.X, interiorPoint.Y),
Stress = CreatePOPStress(layer.Data),
Label = string.Format(Resources.PersistableStateFactory_CreateStatePoint_POP_LayerName_0, layer.Data.MaterialName)
});
}
private static MacroStabilityInwardsSoilProfileUnderSurfaceLine Create(MacroStabilityInwardsSoilProfile1D soilProfile,
MacroStabilityInwardsSurfaceLine surfaceLine)
{
Point2D[] localizedSurfaceLine = surfaceLine.LocalGeometry.ToArray();
double geometryBottom = Math.Min(soilProfile.Bottom, localizedSurfaceLine.Min(p => p.Y)) - 1;
IEnumerable <Point2D> surfaceLineGeometry = AdvancedMath2D.CompleteLineToPolygon(localizedSurfaceLine, geometryBottom);
IEnumerable <TempSoilLayerGeometry> layerGeometries = soilProfile.Layers.Select(
layer => As2DGeometry(
layer,
soilProfile,
localizedSurfaceLine.First().X,
localizedSurfaceLine.Last().X))
.ToArray();
return(GeometriesToIntersections(layerGeometries, surfaceLineGeometry));
}
/// <summary>
/// Gets the <see cref="MacroStabilityInwardsSoilLayer2D"/> the <paramref name="preconsolidationStress"/> is placed on.
/// </summary>
/// <param name="layers">The layers of the profile.</param>
/// <param name="preconsolidationStress">The <see cref="IMacroStabilityInwardsPreconsolidationStress"/> to get the layer for.</param>
/// <returns>The <see cref="MacroStabilityInwardsSoilLayer2D"/> the <paramref name="preconsolidationStress"/> is placed on;
/// or <c>null</c> when no layer can be found.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static MacroStabilityInwardsSoilLayer2D GetLayerForPreconsolidationStress(
IEnumerable <MacroStabilityInwardsSoilLayer2D> layers, IMacroStabilityInwardsPreconsolidationStress preconsolidationStress)
{
if (layers == null)
{
throw new ArgumentNullException(nameof(layers));
}
if (preconsolidationStress == null)
{
throw new ArgumentNullException(nameof(preconsolidationStress));
}
return(layers.SingleOrDefault(l => AdvancedMath2D.PointInPolygon(
preconsolidationStress.Location,
l.OuterRing.Points,
l.NestedLayers.Select(nl => nl.OuterRing.Points))));
}
public void PolygonIntersectionWithPolygon_NoIntersection_ReturnsEmptyCollection()
{
// Setup
Point2D[] polyA = CreateBasePolygon();
var polyB = new[]
{
new Point2D(5, 0),
new Point2D(5, 4),
new Point2D(9, 4),
new Point2D(9, 0)
};
// Call
IEnumerable <IEnumerable <Point2D> > intersections = AdvancedMath2D.PolygonIntersectionWithPolygon(polyA, polyB);
// Assert
CollectionAssert.IsEmpty(intersections);
}
public void PolygonIntersectionWithPolygon_IntersectsComplete_ReturnsIntersectionEqualToPolygon()
{
// Setup
Point2D[] polyA = CreateBasePolygon();
var polyB = new[]
{
new Point2D(0, 0),
new Point2D(0, 4),
new Point2D(4, 4),
new Point2D(4, 0)
};
// Call
IEnumerable <IEnumerable <Point2D> > intersections = AdvancedMath2D.PolygonIntersectionWithPolygon(polyA, polyB);
// Assert
Assert.AreEqual(1, intersections.Count());
Assert.AreEqual(polyA, intersections.ElementAt(0));
}
public void PolygonIntersectionWithPolygon_PartlyIntersects_ReturnsPartialIntersection()
{
// Setup
Point2D[] polyA = CreateBasePolygon();
var polyB = new[]
{
new Point2D(0, 0),
new Point2D(0, 4),
new Point2D(2, 4),
new Point2D(2, 0)
};
// Call
IEnumerable <IEnumerable <Point2D> > intersections = AdvancedMath2D.PolygonIntersectionWithPolygon(polyA, polyB);
// Assert
Assert.AreEqual(1, intersections.Count());
CollectionAssert.AreEqual(polyB, intersections.ElementAt(0));
}
public void PolygonIntersectionWithPolygon_WithSelfIntersectingPolygon_ThrowsInvalidPolygonException()
{
// Setup
Point2D[] polyA = CreateBasePolygon();
var polyB = new[]
{
new Point2D(4, 0),
new Point2D(4, 4),
new Point2D(6, 0),
new Point2D(8, 4),
new Point2D(8, 0)
};
// Call
void Call() => AdvancedMath2D.PolygonIntersectionWithPolygon(polyB, polyA);
// Assert
Assert.Throws <InvalidPolygonException>(Call);
}
