public void TestEqualVertices()
{
Vertex v1 = new Vertex(0.1234, 0.1234);
Vertex v2 = new Vertex(0.1234, 0.1234);
Assert.IsTrue(v1.Equals(v2));
}
public void TestInvalidObjectComparison()
{
Vertex v1 = new Vertex(0.1234, 0.1234);
LAV lav = new LAV();
Assert.IsFalse(v1.Equals(lav));
}
public void TestEdgeAngleBisectorPoint()
{
Vertex v1;
Vertex v2;
Vertex v3;
v1 = new Vertex(1, 3);
v2 = new Vertex(1, 1);
v3 = new Vertex(3, 1);
LineSegment ls1 = new LineSegment(v1, v2);
LineSegment ls2 = new LineSegment(v2, v3);
Vertex bisector = MathLibrary.GetAngleBisectorVertex(ls1, ls2);
Assert.AreEqual(1.71, Math.Round(bisector.GetX(), 2));
Assert.AreEqual(1.71, Math.Round(bisector.GetY(), 2));
v1 = new Vertex(5.78, 5.90);
v2 = new Vertex(5, 3);
v3 = new Vertex(6.93, 3.52);
ls1 = new LineSegment(v1, v2);
ls2 = new LineSegment(v2, v3);
bisector = MathLibrary.GetAngleBisectorVertex(ls1, ls2);
Assert.AreEqual(5.71, Math.Round(bisector.GetX(), 2));
Assert.AreEqual(3.71, Math.Round(bisector.GetY(), 2));
}
//V2 ALWAYS NEEDS TO BE THE MIDDLE VERTEX
public static double GetAngleBetweenVerticese(Vertex v1, Vertex v2, Vertex v3)
{
double a = MathLibrary.GetDistanceBetweenVertices(v1, v2);
double b = MathLibrary.GetDistanceBetweenVertices(v2, v3);
double c = MathLibrary.GetDistanceBetweenVertices(v1, v3);
return RadiansToDegrees(Math.Acos(((a * a) + (b * b) - (c * c)) / (2 * a * b)));
}
public void TestBreakAndCreateNew()
{
SLAV slav = new SLAV();
//NEED TO MAINTAIN THIS LIST FOR TESTING PURPOSES
LAV localLav = new LAV();
Vertex v1 = new Vertex(0, 3);
Vertex v2 = new Vertex(2, 0);
Vertex v3 = new Vertex(4, 2);
Vertex v4 = new Vertex(6, 0);
Vertex v5 = new Vertex(8, 3);
localLav.Add(v1);
localLav.Add(v2);
localLav.Add(v3);
localLav.Add(v4);
localLav.Add(v5);
SSLOperations.SetVertexType(localLav);
SSLOperations.ComputeAngleBisectors(localLav);
slav.Insert(v1, 0);
slav.Insert(v2, 0);
slav.Insert(v3, 0);
slav.Insert(v4, 0);
slav.Insert(v5, 0);
SSLOperations.SetVertexType(slav.Get(0));
SSLOperations.ComputeAngleBisectors(slav.Get(0));
LAV lav = slav.Get(0);
Assert.AreEqual(v1, lav.Get(1));
Assert.AreEqual(v2, lav.Get(2));
Assert.AreEqual(v3, lav.Get(3));
Assert.AreEqual(Vertex.VertexType.Split, lav.Get(3).Type);
Assert.AreEqual(v4, lav.Get(4));
Assert.AreEqual(v5, lav.Get(5));
slav.BreakAndCreateNew(v3, 0);
lav = slav.Get(0);
Assert.AreEqual(v1, lav.Get(1));
Assert.AreEqual(v2, lav.Get(2));
Assert.AreEqual(new Vertex(4, 3), lav.Get(3));
Assert.AreEqual(v1, lav.Get(3).GetNextVertex());
lav = slav.Get(1);
Assert.AreEqual(new Vertex(4, 3), lav.Get(1));
Assert.AreEqual(v4, lav.Get(2));
Assert.AreEqual(v5, lav.Get(3));
Assert.AreEqual(new Vertex(4, 3), lav.Get(3).GetNextVertex());
}
public void TestAngleBisector()
{
Vertex v1 = new Vertex(1, 1);
Vertex bisector = new Vertex(2, 3);
v1.AngleBisector = bisector;
Assert.AreEqual(2, bisector.GetX());
Assert.AreEqual(3, bisector.GetY());
}
//THIS IS FOR UNIT TESTING ONLY, DONT FEEL LIKE DOING THE DISTANCE CALCULATIONS
public Intersection(double x, double y, Vertex vA, Vertex vB, double distance)
{
this.x = x;
this.y = y;
this.vA = vA;
this.vB = vB;
this.distance = distance;
}
public void TestAddVertexToList()
{
Vertex v = new Vertex(0.0, 1.1);
listOfActiveVertices.Add(v);
Vertex startVertex = listOfActiveVertices.GetStart();
Assert.AreEqual(0.0, startVertex.GetX());
Assert.AreEqual(1.1, startVertex.GetY());
Assert.IsNull(startVertex.GetPrevVertex());
Assert.IsNull(startVertex.GetNextVertex());
}
public Vertex(Vertex v)
{
this.x = v.GetX();
this.y = v.GetY();
this.prevVertex = null;
this.nextVertex = null;
this.bisectorVertex = v.bisectorVertex;
this.processed = v.Processed;
this.type = v.Type;
}
public void AngleBetweenVerticesTests()
{
Vertex v1;
Vertex v2;
Vertex v3;
v1 = new Vertex(0, 3);
v2 = new Vertex(0, 0);
v3 = new Vertex(4, 0);
Assert.AreEqual(90, MathLibrary.GetAngleBetweenVerticese(v1, v2, v3));
}
public void TestDeepCopy()
{
Vertex v = new Vertex(0, 1);
Vertex bisector = new Vertex(100, 100);
v.SetProcessed();
v.Type = Vertex.VertexType.Split;
v.AngleBisector = bisector;
Vertex v2 = new Vertex(v);
Assert.IsTrue(v2.Processed);
Assert.AreEqual(Vertex.VertexType.Split, v2.Type);
Assert.AreEqual(bisector, v2.AngleBisector);
}
public void TestAddTwoVertexToList()
{
Vertex v1 = new Vertex(0.0, 0.0);
listOfActiveVertices.Add(v1);
Vertex v2 = new Vertex(1.1, 1.1);
listOfActiveVertices.Add(v2);
Vertex startVertex = listOfActiveVertices.GetStart();
Assert.AreEqual(0.0, startVertex.GetX());
Assert.AreEqual(0.0, startVertex.GetY());
Assert.AreEqual(v2, startVertex.GetNextVertex());
Assert.AreEqual(v2, startVertex.GetPrevVertex());
}
public void TestIntersectionInit()
{
Vertex vA = new Vertex(2, 6);
Vertex vB = new Vertex(2, 2);
Intersection intersection = new Intersection(4, 4, vA, vB, Vertex.VertexType.Edge, ls1, ls2);
Assert.AreEqual(4, intersection.GetX());
Assert.AreEqual(4, intersection.GetY());
Assert.AreEqual(vA, intersection.GetVA());
Assert.AreEqual(vB, intersection.GetVB());
Assert.AreEqual(2, intersection.Distance);
}
public Vertex(double x, double y)
{
this.x = x;
this.y = y;
this.prevVertex = null;
this.nextVertex = null;
this.bisectorVertex = null;
this.prevLS = null;
this.nextLS = null;
this.processed = false;
this.type = VertexType.Undefined;
}
public void TestLineSegmentEdges()
{
Vertex v1 = new Vertex(0, 1);
Vertex v2 = new Vertex(0, 0);
Vertex v3 = new Vertex(1, 0);
Assert.IsNull(v2.PrevLineSegment);
Assert.IsNull(v2.NextLineSegment);
v2.SetPrevVertex(v1);
v2.SetNextVertex(v3);
Assert.AreEqual(new LineSegment(v1, v2), v2.PrevLineSegment);
Assert.AreEqual(new LineSegment(v2, v3), v2.NextLineSegment);
}
public Intersection(double x, double y, Vertex vA, Vertex vB, Vertex.VertexType type, LineSegment lsVA, LineSegment lsVB)
{
this.x = x;
this.y = y;
this.vA = vA;
this.vB = vB;
this.type = type;
this.lsVA = lsVA;
this.lsVB = lsVB;
this.distance = MathLibrary.GetDistanceBetweenLineAndVertex(vA, vB, new Vertex(x, y));
}
public void TestInputReader()
{
InputReader inputReader = new InputReader(inputHelper);
LAV listOfActiveVertices;
inputReader.ReadInput(out listOfActiveVertices);
Vertex v1 = new Vertex(0, 0);
Vertex v2 = new Vertex(1, 1);
Vertex v3 = new Vertex(3, 3);
Vertex startNode = listOfActiveVertices.GetStart();
Assert.IsTrue(v1.Equals(startNode));
Assert.IsTrue(startNode.GetPrevVertex().Equals(v3));
Assert.IsTrue(startNode.GetNextVertex().Equals(v2));
}
public static double GetDistanceBetweenLineAndVertex(Vertex endPoint1, Vertex endPoint2, Vertex point)
{
double bottom = ((endPoint2.GetX() - endPoint1.GetX()) * (endPoint2.GetX() - endPoint1.GetX())) + ((endPoint2.GetY() - endPoint1.GetY()) * (endPoint2.GetY() - endPoint1.GetY()));
double dot = ((point.GetX() - endPoint1.GetX()) * (endPoint2.GetX() - endPoint1.GetX())) + ((point.GetY() - endPoint1.GetY()) * (endPoint2.GetY() - endPoint1.GetY()));
double t = dot / bottom;
double newX = endPoint1.GetX() + t * (endPoint2.GetX() - endPoint1.GetX());
double newY = endPoint1.GetY() + t * (endPoint2.GetY() - endPoint1.GetY());
double retVal = Math.Sqrt(((point.GetX() - newX) * (point.GetX() - newX)) + ((point.GetY() - newY) * (point.GetY() - newY)));
if (double.IsNaN(retVal))
return double.PositiveInfinity;
else
return retVal;
}
public static Vertex GetAngleBisectorVertex(LineSegment ls1, LineSegment ls2)
{
Vertex intersection = GetIntersectionPoint(ls1, ls2);
//THE LINES ARE PARALLEL
if (double.IsInfinity(intersection.GetX()) || double.IsNaN(intersection.GetX()) || double.IsInfinity(intersection.GetY()) || double.IsNaN(intersection.GetY()))
return null;
Vertex maxLine1;
Vertex maxLine2;
if (GetDistanceBetweenVertices(ls1.Start, intersection) >= GetDistanceBetweenVertices(ls1.End, intersection))
maxLine1 = ls1.Start;
else
maxLine1 = ls1.End;
if (GetDistanceBetweenVertices(ls2.Start, intersection) >= GetDistanceBetweenVertices(ls2.End, intersection))
maxLine2 = ls2.Start;
else
maxLine2 = ls2.End;
double bisectorX = 0;
double bisectorY = 0;
double distance12 = GetDistanceBetweenVertices(maxLine1, intersection);
double distance32 = GetDistanceBetweenVertices(maxLine2, intersection);
bisectorX = (maxLine1.GetX() - intersection.GetX()) / distance12;
bisectorY = (maxLine1.GetY() - intersection.GetY()) / distance12;
bisectorX = bisectorX + ((maxLine2.GetX() - intersection.GetX()) / distance32);
bisectorY = bisectorY + ((maxLine2.GetY() - intersection.GetY()) / distance32);
bisectorX = bisectorX * 0.5;
bisectorY = bisectorY * 0.5;
double distance = GetDistanceOfVertex(bisectorX, bisectorY);
bisectorX = intersection.GetX() + (bisectorX / distance);
bisectorY = intersection.GetY() + (bisectorY / distance);
Vertex bisectorVertex = new Vertex(bisectorX, bisectorY);
return bisectorVertex;
}
public void Add(Vertex v)
{
if (startVertex == null)
{
startVertex = v;
}
else
{
endVertex.SetNextVertex(v);
v.SetPrevVertex(endVertex);
v.SetNextVertex(startVertex);
}
length++;
endVertex = v;
if(!startVertex.Equals(endVertex))
startVertex.SetPrevVertex(endVertex);
}
public void TestForEach()
{
Vertex v1 = new Vertex(0, 0);
listOfActiveVertices.Add(v1);
Vertex v2 = new Vertex(1, 1);
listOfActiveVertices.Add(v2);
Vertex v3 = new Vertex(2, 2);
listOfActiveVertices.Add(v3);
int count = 0;
foreach (Vertex v in listOfActiveVertices)
{
Assert.AreEqual(Convert.ToDouble(count), v.GetX());
Assert.AreEqual(Convert.ToDouble(count), v.GetY());
count++;
}
}
public void DistanceBetweenVerticesTests()
{
Vertex v1;
Vertex v2;
v1 = new Vertex(0, 0);
v2 = new Vertex(1, 0);
Assert.AreEqual(1.0, MathLibrary.GetDistanceBetweenVertices(v1, v2));
v1 = new Vertex(0, 0);
v2 = new Vertex(2, 0);
Assert.AreEqual(2.0, MathLibrary.GetDistanceBetweenVertices(v1, v2));
v1 = new Vertex(1, 5);
v2 = new Vertex(-2, 1);
Assert.AreEqual(5, MathLibrary.GetDistanceBetweenVertices(v1, v2));
v1 = new Vertex(-2, -3);
v2 = new Vertex(-4, 4);
Assert.AreEqual(7.28011, Math.Round(MathLibrary.GetDistanceBetweenVertices(v1, v2), 5));
}
public static List<LineSegment> GenerateSkeleton(SLAV setListOfActiveVertices)
{
List<LineSegment> result = new List<LineSegment>();
int lavIndex = 0;
if (queue.IsEmpty())
SSLOperations.GeneratePriorityQueue(setListOfActiveVertices.Get(lavIndex));
while (!queue.IsEmpty())
{
while (!queue.IsEmpty())
{
Intersection intersection = GetMinIntersection();
if (intersection.Type == Vertex.VertexType.Undefined)
{
throw new Exception("Undefined vertex type.");
}
if (!intersection.GetVA().Processed && !intersection.GetVB().Processed)
{
double intersectionX = Math.Round(intersection.GetX(), 2);
double intersectionY = Math.Round(intersection.GetY(), 2);
Vertex intersectionVertex = new Vertex(intersectionX, intersectionY);
if (intersection.Type == Vertex.VertexType.Edge || intersection.Type == Vertex.VertexType.Split)
{
result.Add(new LineSegment(intersection.GetVB(), intersectionVertex));
result.Add(new LineSegment(intersection.GetVA(), intersectionVertex));
setListOfActiveVertices.Get(lavIndex).Insert(intersectionVertex, intersection.GetVB(), intersection.GetVA());
intersectionVertex.NextLineSegment = intersection.GetLSVA();
intersectionVertex.PrevLineSegment = intersection.GetLSVB();
SetVertexType(intersectionVertex);
intersectionVertex.AngleBisector = MathLibrary.GetAngleBisectorVertex(intersectionVertex.PrevLineSegment, intersectionVertex.NextLineSegment);
if (intersectionVertex.AngleBisector == null) //THE LINES ARE PARALLEL
{
intersectionVertex.AngleBisector = MathLibrary.Rotate(intersectionVertex, MathLibrary.GetAngleBisectorVertex(new LineSegment(intersectionVertex, intersection.GetVB()), new LineSegment(intersectionVertex, intersection.GetVA())), 180);
}
}
intersection.GetVA().SetProcessed();
intersection.GetVB().SetProcessed();
}
}
Vertex startVertex = setListOfActiveVertices.Get(lavIndex).GetStart();
if (startVertex.GetNextVertex().GetNextVertex().Equals(startVertex))
{
result.Add(new LineSegment(startVertex, startVertex.GetNextVertex()));
}
else
{
SSLOperations.GeneratePriorityQueue(setListOfActiveVertices.Get(lavIndex));
}
}
return result;
}
public static void SetVertexType(Vertex v)
{
Vertex next = null;
Vertex prev = null;
double nextX = 0;
double nextY = 0;
double prevX = 0;
double prevY = 0;
double myX = 0;
double myY = 0;
myX = v.GetX();
myY = v.GetY();
next = v.GetNextVertex();
prev = v.GetPrevVertex();
nextX = next.GetX();
nextY = next.GetY();
prevX = prev.GetX();
prevY = prev.GetY();
if (nextX == myX)
{
nextX += 0.01;
}
if (nextY == myY)
{
nextY -= 0.01;
}
if (prevX == myX)
{
prevX -= 0.01;
}
if (prevY == myY)
{
prevY -= 0.01;
}
if ((prevY < myY && prevX < myX) && (nextY < myY && myX < nextX)) //PEAK
{
v.Type = Vertex.VertexType.Split;
}
else if ((prevY > myY && myX < prevX) && (nextY > myY && nextX < myX)) //VALLEY
{
v.Type = Vertex.VertexType.Split;
}
else if ((prevY > myY && myX > prevX) && (myY > nextY && myX > nextX)) //>
{
v.Type = Vertex.VertexType.Split;
}
else if ((prevY < myY && prevX > myX) && (myY < nextY && nextX > myX)) //<
{
v.Type = Vertex.VertexType.Split;
}
else
{
v.Type = Vertex.VertexType.Edge;
}
}
public static Intersection GetClosestIntersection(Vertex v)
{
Vertex next = v.GetNextVertex();
Vertex prev = v.GetPrevVertex();
Vertex nextIntersection = MathLibrary.GetIntersectionPoint(new LineSegment(next, next.AngleBisector), new LineSegment(v, v.AngleBisector));
Vertex prevIntersection = MathLibrary.GetIntersectionPoint(new LineSegment(prev, prev.AngleBisector), new LineSegment(v, v.AngleBisector));
Vertex.VertexType type = Vertex.VertexType.Undefined;
if (MathLibrary.GetDistanceBetweenLineAndVertex(v, next, nextIntersection) < MathLibrary.GetDistanceBetweenLineAndVertex(v, prev, prevIntersection))
{
if (v.Type == Vertex.VertexType.Split || next.Type == Vertex.VertexType.Split)
type = Vertex.VertexType.Split;
else
type = Vertex.VertexType.Edge;
Intersection i = new Intersection(nextIntersection.GetX(), nextIntersection.GetY(), next, v, type, next.NextLineSegment, v.PrevLineSegment);
return i;
}
else
{
if (v.Type == Vertex.VertexType.Split || prev.Type == Vertex.VertexType.Split)
type = Vertex.VertexType.Split;
else
type = Vertex.VertexType.Edge;
Intersection i = new Intersection(prevIntersection.GetX(), prevIntersection.GetY(), v, prev, type, prev.PrevLineSegment, v.NextLineSegment);
return i;
}
}
public void TestIntersectionPointLineEquations()
{
Vertex v1 = new Vertex(1, 3);
Vertex v2 = new Vertex(1, 1);
Vertex v3 = new Vertex(3, 1);
LineSegment ls1 = new LineSegment(v1, v2);
LineSegment ls2 = new LineSegment(v2, v3);
Assert.AreEqual(new Vertex(1, 1), MathLibrary.GetIntersectionPoint(ls1, ls2));
v1 = new Vertex(1, 1);
v2 = new Vertex(5, 5);
v3 = new Vertex(0, 4);
Vertex v4 = new Vertex(4, 0);
ls1 = new LineSegment(v1, v2);
ls2 = new LineSegment(v3, v4);
Assert.AreEqual(new Vertex(2, 2), MathLibrary.GetIntersectionPoint(ls1, ls2));
}
public void TestTriangleContainsPoint()
{
Vertex v1 = new Vertex(0, 0);
Vertex v2 = new Vertex(4, 0);
Vertex v3 = new Vertex(2, 2);
Assert.IsTrue(MathLibrary.TriangleContainsPoint(v1, v2, v3, new Vertex(2, 1)));
Assert.IsFalse(MathLibrary.TriangleContainsPoint(v1, v2, v3, new Vertex(0, 1)));
Assert.IsFalse(MathLibrary.TriangleContainsPoint(v1, v2, v3, new Vertex(2, -1)));
Assert.IsFalse(MathLibrary.TriangleContainsPoint(v1, v2, v3, new Vertex(3, 1.5)));
}
public void TestSplitAngleBisectorPoint()
{
Vertex v1 = new Vertex(4, 0);
Vertex v2 = new Vertex(4, 3);
Vertex v3 = new Vertex(8, 3);
LineSegment ls1 = new LineSegment(v1, v2);
LineSegment ls2 = new LineSegment(v2, v3);
Vertex bisector = MathLibrary.GetAngleBisectorVertex(ls1, ls2);
bisector = MathLibrary.Rotate(v2, bisector, 180);
Assert.AreEqual(3.29, Math.Round(bisector.GetX(), 2));
Assert.AreEqual(3.71, Math.Round(bisector.GetY(), 2));
}
public void TestRectangleContainsPoint()
{
Vertex v1 = new Vertex(0, 6);
Vertex v2 = new Vertex(0, 3);
Vertex v3 = new Vertex(8, 3);
Vertex v4 = new Vertex(8, 6);
Assert.IsTrue(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(4, 4)));
Assert.IsFalse(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(8, 3)));
Assert.IsFalse(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(-1, 5)));
Assert.IsFalse(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(2, 2)));
Assert.IsFalse(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(9, 4)));
Assert.IsFalse(MathLibrary.RectangleContainsPoint(v1, v2, v3, v4, new Vertex(7, 7)));
}
public void TestQuadrilateralContainsPoint2()
{
Vertex v1 = new Vertex(4, 2);
Vertex v2 = new Vertex(6, 2);
Vertex v3 = new Vertex(15.69, 34.02);
Vertex v4 = new Vertex(-9.26, 34.02);
Assert.IsTrue(MathLibrary.QuadrilateralContainsPoint(v1, v2, v3, v4, new Vertex(3.5, 4)));
}
