public BasicGradientBrush(BasicColor color, BasicColor color2, float angle) : base(color)
{
Color2 = color2;
Angle = angle;
StartPoint = new BasicPoint(0, 0);
EndPoint = new BasicPoint(0, 0);
}
public void GeometryDistanceAlgorithmDistancePointsTest()
{
BasicPoint first = new BasicPoint(new Coordinate(0, 10));
BasicPoint second = new BasicPoint(new Coordinate(10, 10));
GeometryDistanceAlgorithm.Distance(first, second).ShouldBe(10);
first = new BasicPoint(new Coordinate(10, 10));
second = new BasicPoint(new Coordinate(10, 0));
GeometryDistanceAlgorithm.Distance(first, second).ShouldBe(10);
first = new BasicPoint(new Coordinate(67, 75));
second = new BasicPoint(new Coordinate(17, 89));
GeometryDistanceAlgorithm.Distance(first, second).ShouldBe(51.92, 0.01);
// same point
GeometryDistanceAlgorithm.Distance(first, first).ShouldBe(0);
// same coordinate
second = new BasicPoint(first.Coordinate);
GeometryDistanceAlgorithm.Distance(first, second).ShouldBe(0);
// undefined coordinate
second = new BasicPoint(Coordinate.Undefined);
GeometryDistanceAlgorithm.Distance(first, second).ShouldBe(Double.NaN);
}
public BasicGradientBrush(BasicColor color, BasicColor color2, BasicPoint startPoint, BasicPoint endPoint)
: base(color)
{
Color2 = color2;
StartPoint = startPoint;
EndPoint = endPoint;
}
private void GetingOutSideItem()
{
IBoard <IItem, int> board = new BasicBoard(360);
IItem item = new BasicEnemy(range: 5);
IPoint <int> point = new BasicPoint(1);
board.Put(item, point);
board.Get(new BasicPoint(360), new BasicWeapon());
}
public void GetFreeAreaLessOneItem()
{
IBoard <IItem, int> board = new BasicBoard(4);
IItem item = new BasicEnemy(range: 2);
IPoint <int> point = new BasicPoint(1);
board.Put(item, point);
Assert.AreEqual(1, board.FreePointsTo(item).Length);
}
public void GetItemInsideRange()
{
IBoard <IItem, int> board = new BasicBoard();
IItem item = new BasicEnemy(range: 5);
IPoint <int> point = new BasicPoint(360);
board.Put(item, point);
Assert.AreSame(item, board.Get(new BasicPoint(2), new BasicWeapon()));
}
public void MustBeAFullBoard()
{
IBoard <IItem, int> board = new BasicBoard(4);
IItem item = new BasicEnemy(range: 4);
IPoint <int> point = new BasicPoint(1);
board.Put(item, point);
Assert.AreEqual(0, board.FreePointsTo(item).Length);
}
public void GetItemAtSamePosition()
{
IBoard <IItem, int> board = new BasicBoard();
IItem item = new BasicEnemy(5);
IPoint <int> point = new BasicPoint(1);
board.Put(item, point);
Assert.AreSame(item, board.Get(point, new BasicWeapon()));
}
public void GeometryDistanceAlgorithmDistancePolygonsTest()
{
// point outside polygon
BasicPoint point = new BasicPoint(new Coordinate(1, 4));
BasicPolygon polygon = new BasicPolygon(new[] { new Coordinate(0, 0), new Coordinate(2, 0), new Coordinate(2, 2), new Coordinate(0, 2) });
GeometryDistanceAlgorithm.Distance(point, polygon).ShouldBe(2);
// point on polygon shell
point = new BasicPoint(new Coordinate(2, 1));
polygon = new BasicPolygon(new[] { new Coordinate(0, 0), new Coordinate(2, 0), new Coordinate(2, 2), new Coordinate(0, 2) });
GeometryDistanceAlgorithm.Distance(point, polygon).ShouldBe(0);
// point in polygon
point = new BasicPoint(new Coordinate(1, 1));
polygon = new BasicPolygon(new[] { new Coordinate(0, 0), new Coordinate(2, 0), new Coordinate(2, 2), new Coordinate(0, 2) });
GeometryDistanceAlgorithm.Distance(point, polygon).ShouldBe(0);
}
public void MinkowskiSumAlgorithmBufferTest()
{
// two triangles
Coordinate[] buffer = new[] { new Coordinate(5, 5), new Coordinate(5, 7), new Coordinate(4, 6) };
Coordinate[] sourceShell = new[] { new Coordinate(2, 1), new Coordinate(4, 1), new Coordinate(3, 3), new Coordinate(2, 1) };
Coordinate[] expectedShell = new[]
{
new Coordinate(6, 7),
new Coordinate(7, 6),
new Coordinate(9, 6),
new Coordinate(9, 8),
new Coordinate(8, 10),
new Coordinate(7, 9),
};
IBasicPolygon expected = new BasicPolygon(expectedShell);
IBasicPolygon actual = MinkowskiSumAlgorithm.Buffer(sourceShell, buffer);
PolygonAlgorithms.IsConvex(actual).ShouldBeTrue();
actual.Shell.ShouldBe(expected.Shell);
// triangle and a square
buffer = new[] { new Coordinate(8, 6), new Coordinate(9, 6), new Coordinate(9, 7), new Coordinate(8, 7) };
sourceShell = new[] { new Coordinate(3, 4), new Coordinate(5, 4), new Coordinate(4, 6), new Coordinate(3, 4) };
expectedShell = new[]
{
new Coordinate(11, 11),
new Coordinate(11, 10),
new Coordinate(13, 10),
new Coordinate(14, 10),
new Coordinate(14, 11),
new Coordinate(13, 13),
new Coordinate(12, 13),
new Coordinate(11, 11)
};
expected = new BasicPolygon(expectedShell);
actual = MinkowskiSumAlgorithm.Buffer(sourceShell, buffer);
PolygonAlgorithms.IsConvex(actual).ShouldBeTrue();
actual.Shell.ShouldBe(expected.Shell);
// square and circle of 4 points (square)
buffer = new[] { new Coordinate(8, 6), new Coordinate(9, 6), new Coordinate(9, 7), new Coordinate(8, 7), new Coordinate(8, 6) };
expectedShell = new[]
{
new Coordinate(6, 6),
new Coordinate(8, 4),
new Coordinate(9, 4),
new Coordinate(11, 6),
new Coordinate(11, 7),
new Coordinate(9, 9),
new Coordinate(8, 9),
new Coordinate(6, 7),
new Coordinate(6, 6)
};
expected = new BasicPolygon(expectedShell);
actual = MinkowskiSumAlgorithm.Buffer(buffer, 2, 4);
PolygonAlgorithms.IsConvex(actual).ShouldBeTrue();
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
// point and circle (of 4 points)
IBasicPoint point = new BasicPoint(new Coordinate(1, 1, 0));
actual = MinkowskiSumAlgorithm.Buffer(point, 2, 4);
expectedShell = new[]
{
new Coordinate(3, 1), new Coordinate(1, 3),
new Coordinate(-1, 1), new Coordinate(1, -1)
};
expected = new BasicPolygon(expectedShell);
PolygonAlgorithms.IsConvex(actual).ShouldBeTrue();
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
// square with a square hole and circle (of 8 points)
sourceShell = new[]
{
new Coordinate(1, 1),
new Coordinate(9, 1),
new Coordinate(9, 9),
new Coordinate(1, 9),
new Coordinate(1, 1)
};
Coordinate[][] sourceHoles = new[]
{
new[]
{
new Coordinate(3, 3),
new Coordinate(3, 7),
new Coordinate(7, 7),
new Coordinate(7, 3),
new Coordinate(3, 3)
}
};
actual = MinkowskiSumAlgorithm.Buffer(new BasicPolygon(sourceShell, sourceHoles), 1, 8);
expectedShell = new[]
{
new Coordinate(0, 1), new Coordinate(0.3, 0.3),
new Coordinate(1, 0), new Coordinate(9, 0),
new Coordinate(9.7, 0.3), new Coordinate(10, 1),
new Coordinate(10, 9), new Coordinate(9.7, 9.7),
new Coordinate(9, 10), new Coordinate(1, 10),
new Coordinate(0.3, 9.7), new Coordinate(0, 9)
};
Coordinate[][] expectedHoles = new[]
{
new[]
{
new Coordinate(4, 3), new Coordinate(3.7, 3.7),
new Coordinate(3, 4), new Coordinate(3, 6),
new Coordinate(3.7, 6.3), new Coordinate(4, 7),
new Coordinate(6, 7), new Coordinate(6.3, 6.3),
new Coordinate(7, 6), new Coordinate(7, 4),
new Coordinate(6.3, 3.7), new Coordinate(6, 3)
}
};
expected = new BasicPolygon(expectedShell, expectedHoles);
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
actual.HoleCount.ShouldBe(expected.HoleCount);
for (Int32 holeIndex = 0; holeIndex < expected.HoleCount; holeIndex++)
{
actual.Holes[holeIndex].Count.ShouldBe(expected.Holes[holeIndex].Count);
for (Int32 coordIndex = 0; coordIndex < expected.Holes[holeIndex].Count; coordIndex++)
{
actual.Holes[holeIndex][coordIndex].X.ShouldBe(expected.Holes[holeIndex][coordIndex].X, 0.01);
actual.Holes[holeIndex][coordIndex].Y.ShouldBe(expected.Holes[holeIndex][coordIndex].Y, 0.01);
}
}
// line string (2 points) and square
buffer = new[] { new Coordinate(0, 2), new Coordinate(0, 0), new Coordinate(2, 0), new Coordinate(2, 2) };
actual = MinkowskiSumAlgorithm.Buffer(new[] { new Coordinate(0, 4), new Coordinate(2, 4) }, buffer);
expectedShell = new[]
{
new Coordinate(0, 6), new Coordinate(0, 4),
new Coordinate(2, 4), new Coordinate(4, 4),
new Coordinate(4, 6), new Coordinate(2, 6)
};
expected = new BasicPolygon(expectedShell);
actual.Shell.ShouldBe(expected.Shell);
// line string (4 points) and square
buffer = new[] { new Coordinate(0, 2), new Coordinate(0, 0), new Coordinate(2, 0), new Coordinate(2, 2) };
actual = MinkowskiSumAlgorithm.Buffer(new[] { new Coordinate(1, 1), new Coordinate(3, 3), new Coordinate(5, 6), new Coordinate(3, 8) }, buffer);
expectedShell = new[]
{
new Coordinate(1, 3), new Coordinate(1, 1),
new Coordinate(3, 1), new Coordinate(5, 3),
new Coordinate(7, 6), new Coordinate(7, 8),
new Coordinate(5, 10), new Coordinate(3, 10)
};
expected = new BasicPolygon(expectedShell);
actual.Shell.ShouldBe(expected.Shell);
// concave and convex with no hole in the result
buffer = new[] { new Coordinate(13, 2), new Coordinate(14, 3), new Coordinate(13, 4), new Coordinate(12, 3) };
sourceShell = new[]
{
new Coordinate(1, 1), new Coordinate(11, 1),
new Coordinate(11, 6), new Coordinate(8, 6),
new Coordinate(9, 3), new Coordinate(3, 3),
new Coordinate(4, 6), new Coordinate(1, 6)
};
actual = MinkowskiSumAlgorithm.Buffer(sourceShell, buffer);
expectedShell = new[]
{
new Coordinate(13, 4), new Coordinate(14, 3),
new Coordinate(24, 3), new Coordinate(25, 4),
new Coordinate(25, 9), new Coordinate(24, 10),
new Coordinate(21, 10), new Coordinate(20, 9),
new Coordinate(20.67, 7), new Coordinate(17.33, 7),
new Coordinate(18, 9), new Coordinate(17, 10),
new Coordinate(14, 10), new Coordinate(13, 9)
};
expected = new BasicPolygon(expectedShell);
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
// convex and concave with no hole in the result
buffer = new[] { new Coordinate(0, 3), new Coordinate(-3, 0), new Coordinate(0, -3), new Coordinate(3, 0) };
sourceShell = new[]
{
new Coordinate(1, 1), new Coordinate(11, 1),
new Coordinate(11, 6), new Coordinate(8, 6),
new Coordinate(9, 3), new Coordinate(3, 3),
new Coordinate(4, 6), new Coordinate(1, 6)
};
actual = MinkowskiSumAlgorithm.Buffer(sourceShell, buffer);
expectedShell = new[]
{
new Coordinate(-2, 1), new Coordinate(1, -2),
new Coordinate(11, -2), new Coordinate(14, 1),
new Coordinate(14, 6), new Coordinate(11, 9),
new Coordinate(8, 9), new Coordinate(6, 7),
new Coordinate(4, 9), new Coordinate(1, 9),
new Coordinate(-2, 6)
};
expected = new BasicPolygon(expectedShell);
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
// convex and concave with hole in the result
buffer = new[] { new Coordinate(13, 4), new Coordinate(12, 3), new Coordinate(13, 2), new Coordinate(14, 3) };
sourceShell = new[]
{
new Coordinate(1, 1), new Coordinate(11, 1),
new Coordinate(11, 6), new Coordinate(7, 6),
new Coordinate(9, 3), new Coordinate(4, 3),
new Coordinate(6, 6), new Coordinate(1, 6)
};
actual = MinkowskiSumAlgorithm.Buffer(sourceShell, buffer);
expectedShell = new[]
{
new Coordinate(13, 4), new Coordinate(14, 3),
new Coordinate(24, 3), new Coordinate(25, 4),
new Coordinate(25, 9), new Coordinate(24, 10),
new Coordinate(20, 10), new Coordinate(19.5, 9.5),
new Coordinate(19, 10), new Coordinate(14, 10),
new Coordinate(13, 9)
};
expectedHoles = new[]
{
new[]
{
new Coordinate(19.5, 8.25),
new Coordinate(20.3, 7),
new Coordinate(18.6, 7)
}
};
expected = new BasicPolygon(expectedShell, expectedHoles);
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
actual.HoleCount.ShouldBe(expected.HoleCount);
for (Int32 holeIndex = 0; holeIndex < expected.HoleCount; holeIndex++)
{
actual.Holes[holeIndex].Count.ShouldBe(expected.Holes[holeIndex].Count);
for (Int32 coordIndex = 0; coordIndex < expected.Holes[holeIndex].Count; coordIndex++)
{
actual.Holes[holeIndex][coordIndex].X.ShouldBe(expected.Holes[holeIndex][coordIndex].X, 0.1);
actual.Holes[holeIndex][coordIndex].Y.ShouldBe(expected.Holes[holeIndex][coordIndex].Y, 0.1);
}
}
// convex source polygon with hole and a rhombus
buffer = new[]
{
new Coordinate(10, 2),
new Coordinate(11, 3),
new Coordinate(10, 4),
new Coordinate(9, 3)
};
sourceShell = new[]
{
new Coordinate(1, 1),
new Coordinate(9, 1),
new Coordinate(9, 9),
new Coordinate(1, 9),
new Coordinate(1, 1)
};
sourceHoles = new[]
{
new[]
{
new Coordinate(3, 3),
new Coordinate(3, 7),
new Coordinate(7, 7),
new Coordinate(7, 3),
new Coordinate(3, 3)
}
};
actual = MinkowskiSumAlgorithm.Buffer(new BasicPolygon(sourceShell, sourceHoles), new BasicPolygon(buffer));
expectedShell = new[]
{
new Coordinate(10, 4), new Coordinate(11, 3),
new Coordinate(19, 3), new Coordinate(20, 4),
new Coordinate(20, 12), new Coordinate(19, 13),
new Coordinate(11, 13), new Coordinate(10, 12)
};
expectedHoles = new[]
{
new[]
{
new Coordinate(14, 6), new Coordinate(13, 7),
new Coordinate(13, 9), new Coordinate(14, 10),
new Coordinate(16, 10), new Coordinate(17, 9),
new Coordinate(17, 7), new Coordinate(16, 6)
}
};
expected = new BasicPolygon(expectedShell, expectedHoles);
actual.Shell.Count.ShouldBe(expected.Shell.Count);
for (Int32 coordIndex = 0; coordIndex < expected.Shell.Count; coordIndex++)
{
actual.Shell[coordIndex].X.ShouldBe(expected.Shell[coordIndex].X, 0.01);
actual.Shell[coordIndex].Y.ShouldBe(expected.Shell[coordIndex].Y, 0.01);
}
actual.HoleCount.ShouldBe(expected.HoleCount);
for (Int32 holeIndex = 0; holeIndex < expected.HoleCount; holeIndex++)
{
actual.Shell.Count.ShouldBe(expected.Holes[holeIndex].Count);
for (Int32 coordIndex = 0; coordIndex < expected.Holes[holeIndex].Count; coordIndex++)
{
actual.Holes[holeIndex][coordIndex].X.ShouldBe(expected.Holes[holeIndex][coordIndex].X, 0.01);
actual.Holes[holeIndex][coordIndex].Y.ShouldBe(expected.Holes[holeIndex][coordIndex].Y, 0.01);
}
}
// exceptions
Should.Throw <ArgumentNullException>(() => MinkowskiSumAlgorithm.Buffer((IBasicPolygon)null, new BasicPolygon(buffer)));
Should.Throw <ArgumentNullException>(() => MinkowskiSumAlgorithm.Buffer(new BasicPolygon(sourceShell, sourceHoles), null));
}
public void GeometryDistanceAlgorithmDistanceLineStringsTest()
{
// parallel line strings
BasicLineString firstLineString = new BasicLineString(new[] { new Coordinate(2, 2), new Coordinate(2, -2) });
BasicLineString secondLineString = new BasicLineString(new[] { new Coordinate(4, 2), new Coordinate(4, -2) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(2);
firstLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(2, 2) });
secondLineString = new BasicLineString(new[] { new Coordinate(0, 2), new Coordinate(2, 4) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(Math.Sqrt(2), 0.001);
firstLineString = new BasicLineString(new[] { new Coordinate(2, 2), new Coordinate(2, -2), new Coordinate(10, -2), new Coordinate(10, 2) });
secondLineString = new BasicLineString(new[] { new Coordinate(2, 24), new Coordinate(2, 22), new Coordinate(10, 22), new Coordinate(10, 24) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(20);
// one line is skewed towards the other
firstLineString = new BasicLineString(new[] { new Coordinate(2, 2), new Coordinate(2, -2) });
secondLineString = new BasicLineString(new Coordinate[] { new Coordinate(4, 2), new Coordinate(3, -2) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(1);
// a line and a line string, where the line string's middle point is the closest to the middle of the line
firstLineString = new BasicLineString(new[] { new Coordinate(2, 2), new Coordinate(2, -2) });
secondLineString = new BasicLineString(new[] { new Coordinate(4, 2), new Coordinate(3, 0), new Coordinate(7, -2) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(1);
// intersecting lines
firstLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(2, 2) });
secondLineString = new BasicLineString(new[] { new Coordinate(0, 2), new Coordinate(2, 0) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(0);
firstLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(1, 1) });
secondLineString = new BasicLineString(new[] { new Coordinate(0, 1), new Coordinate(1, 0) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(0);
firstLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(1, 1) });
secondLineString = new BasicLineString(new[] { new Coordinate(1, 1), new Coordinate(2, 2) });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(0);
// point on line
BasicPoint point = new BasicPoint(new Coordinate(1, 1));
secondLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(2, 2) });
GeometryDistanceAlgorithm.Distance(point, secondLineString).ShouldBe(0);
point = new BasicPoint(new Coordinate(1.5, 1.5));
secondLineString = new BasicLineString(new[] { new Coordinate(0, 0), new Coordinate(1, 1), new Coordinate(2, 2) });
GeometryDistanceAlgorithm.Distance(point, secondLineString).ShouldBe(0);
// empty line strings
secondLineString = new BasicLineString(new Coordinate[] { });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(Double.MaxValue);
firstLineString = new BasicLineString(new Coordinate[] { });
secondLineString = new BasicLineString(new Coordinate[] { });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(Double.MaxValue);
// invalid line
secondLineString = new BasicLineString(new Coordinate[] { new Coordinate(0, 0), Coordinate.Undefined });
GeometryDistanceAlgorithm.Distance(firstLineString, secondLineString).ShouldBe(Double.MaxValue);
}
