/// <summary>
/// 处理顶点
/// </summary>
/// <param name="point">Point.</param>
private void HandleVertex(Vector2 point)
{
DoubleLink <Vector2> .Node node = _Vertexes.Find(point);
if (node == null)
{
return;
}
VertexType type = TypeOfVertex(node);
Debug.Log(type);
switch (type)
{
case VertexType.Start: HandleStartVertex(node); break;
case VertexType.End: HandleEndVertex(node); break;
case VertexType.Split: HandleSpiltVertex(node); break;
case VertexType.Merge: HandleMergeVertex(node); break;
case VertexType.Regular: HandleRegularVertex(node); break;
default:
break;
}
}
internal void InsertBefore(DoubleLink before)
{
_prev = before._prev;
_next = before;
before._prev = this;
_prev._next = this;
}
public Polygon()
{
_Vertexes = new DoubleLink <Vector2> ();
_Vertexes.CompareHandler = (Vector2 n0, Vector2 n1) => {
return(Tool.Compare(n0, n1));
};
}
//
// Huiswerk methodes
//
public void BubbleSort()
{
if (First == null && Last == null)
{
return;
}
DoubleLink outerLink = First;
while (outerLink != null)
{
DoubleLink innerLink = First;
while (innerLink != null)
{
DoubleLink useLink = innerLink;
DoubleLink nextLink = innerLink.Next;
if (nextLink != null)
{
if (useLink.Naw.CompareTo(nextLink.Naw) > 0)
{
SwapLinkWithNext(useLink);
}
innerLink = innerLink.Next;
}
else
{
break;
}
}
outerLink = outerLink.Next;
}
}
internal void InsertAfter(DoubleLink after)
{
_prev = after;
_next = after._next;
after._next = this;
_next._prev = this;
}
public DoubleLink SwapLinkWithNext(DoubleLink link)
{
if (link.Next != null)
{
if (link.Previous == null)
{
link.Next.Previous = null;
First = link.Next;
}
else
{
link.Next.Previous = link.Previous;
link.Previous.Next = link.Next;
}
link.Previous = link.Next;
if (link.Next.Next == null)
{
link.Next = null;
Last = link;
}
else
{
link.Next.Next.Previous = link;
link.Next = link.Next.Next;
}
link.Previous.Next = link;
}
return(link.Previous);
}
public static NawDoublyLinkedList Random(int min, int max, out int count)
{
var result = new NawDoublyLinkedList();
var r = new Random();
count = r.Next(min, max);
DoubleLink prev = null;
for (var i = 0; i < count; ++i)
{
var newLink = new DoubleLink
{
Naw = RandomNawGenerator.New(10)
};
if (prev == null)
{
result.First = newLink;
}
else
{
prev.Next = newLink;
}
newLink.Previous = prev;
prev = newLink;
result.Last = prev;
}
return(result);
}
//
// Workshop methodes
//
public void InsertHead(NAW naw)
{
//throw new NotImplementedException();
DoubleLink _current = First;
DoubleLink _previous;
First.Naw = naw;
First.Next = _current;
First.Previous = null;
_previous = First;
_current.Previous = _previous;
if (_current.Next != null)
{
while (_current.Next != null)
{
_previous = _current;
_current = _current.Next;
_current.Previous = _previous;
}
}
else
{
Last = _current;
}
}
public DoubleLink SwapLinkWithNext(DoubleLink link)
{
//throw new NotImplementedException();
DoubleLink toSwap = link;
DoubleLink toSwapWith;
if (toSwap.Next != null)
{
toSwapWith = toSwap.Next;
toSwap.Previous = toSwapWith;
toSwap.Next = toSwapWith.Next;
toSwapWith.Previous = link.Previous;
toSwapWith.Next = toSwap;
return(toSwapWith);
}
else
{
return(null);
}
return(null);
}
public DoubleLink SwapLinkWithNext(DoubleLink link)
{
DoubleLink linknext = link.Next;
DoubleLink next = linknext.Next;
DoubleLink linkprevious = link.Previous;
if (First == link)
{
First = linknext;
}
if (linkprevious != null)
{
linkprevious.Next = linknext;
}
linknext.Previous = linkprevious;
linknext.Next = link;
link.Previous = linknext;
link.Next = next;
if (next != null)
{
next.Previous = link;
}
if (Last == linknext)
{
Last = link;
}
return(linknext);
}
public void BubbleSort()
{
int swapped;
DoubleLink inner;
DoubleLink outer = new DoubleLink();
if (First == null)
{
return;
}
do
{
swapped = 0;
inner = First;
while (inner.Next != outer && inner.Next != null)
{
if (inner.Naw.CompareTo(inner.Next.Naw) > 0)
{
NAW n = inner.Naw;
inner.Naw = inner.Next.Naw;
inner.Next.Naw = n;
swapped = 1;
}
inner = inner.Next;
}
outer = inner;
}while (swapped != 0);
}
public DoubleLink SwapLinkWithNext(DoubleLink link)
{
DoubleLink rightLink = link.Next;
if (link == Last)
{
return(null);
}
if (link == First)
{
First = rightLink;
}
else
{
link.Previous.Next = rightLink;
}
if (rightLink == Last)
{
Last = link;
}
else
{
rightLink.Next.Previous = link;
}
link.Next = rightLink.Next;
rightLink.Previous = link.Previous;
link.Previous = rightLink;
rightLink.Next = link;
return(rightLink);
}
public static NawDoublyLinkedList FromArray(NAW[] array)
{
var result = new NawDoublyLinkedList();
foreach (var item in array)
{
var link = new DoubleLink
{
Naw = item,
Previous = result.Last,
Next = null
};
if (result.First == null)
{
result.First = result.Last = link;
}
else
{
result.Last.Next = link;
result.Last = link;
}
}
return(result);
}
public void DoublyLinkedList_SwapLinkWithNext_ItemsSwapped()
{
// Arrange
lijst.First = new DoubleLink()
{
Naw = new NAW()
{
Naam = "naam", Adres = "adres", Woonplaats = "woonplaats"
}, Next = lijst.First
};
lijst.First.Next.Previous = lijst.First;
DoubleLink first = lijst.First;
DoubleLink second = lijst.First.Next;
DoubleLink third = second.Next;
DoubleLink fourth = lijst.Last;
// Act
lijst.SwapLinkWithNext(second);
Assert.AreEqual(first, lijst.First, "De eerste is gewijzigd. Dit was niet de bedoeling.");
Assert.AreEqual(fourth, lijst.Last, "De laatste is gewijzigd. Dit was niet de bedoeling.");
Assert.AreEqual(third, lijst.First.Next, "De eerste zou nu naar de derde moeten wijzen, dit doet hij niet.");
Assert.AreEqual(lijst.First, third.Previous, "De derde zou nu naar de eerste terug moeten wijzen, dit doet hij niet.");
Assert.AreEqual(second, third.Next, "De derde zou nu naar de tweede moeten wijzen, dit doet hij niet.");
Assert.AreEqual(third, second.Previous, "De tweede zou nu naar de derde terug moeten wijzen, dit doet hij niet.");
Assert.AreEqual(second, fourth.Previous, "De tweede zou nu naar de vierde moeten wijzen, dit doet hij niet.");
Assert.AreEqual(fourth, second.Next, "De vierde zou nu naar de tweede terug moeten wijzen, dit doet hij niet.");
}
internal void InsertBefore(DoubleLink before)
{
_prev = before._prev;
_next = before;
before._prev = this;
_prev._next = this;
}
internal void InsertAfter(DoubleLink after)
{
_prev = after;
_next = after._next;
after._next = this;
_next._prev = this;
}
public void DoublyLinkedList_InsertInBeginning_FilledList_LastStillValid()
{
DoubleLink oldTail = lijst.Last;
lijst.InsertHead(new_naw);
Assert.AreEqual(oldTail, lijst.Last, "Door het invoegen van het nieuwe element aan het begin van de lijst is de waarde van _last onterecht gewijzigd.");
}
public void InsertAfterTest()
{
DoubleLink currentLink = new DoubleLink(insertNodeValue);
DoubleLink insertLink = new DoubleLink("test2");
list.InsertAfter(list, insertLink, currentLink);
Assert.IsNotNull(list);
}
/// <summary>
/// 处理开始顶点
/// </summary>
/// <param name="point">Point.</param>
private void HandleStartVertex(DoubleLink <Vector2> .Node node)
{
Vector2 current = node.Value;
Vector2 next = node.Next.Value;
LineSegment seg = new LineSegment(current, next);
_Tree.Add(seg);
SetHelpVertex(seg, current);
}
public void DoublyLinkedList_InsertInBeginning_FilledList_ChangesList()
{
DoubleLink oldFirst = lijst.First;
lijst.InsertHead(new_naw);
Assert.AreEqual(new_naw, lijst.First.Naw, "Het nieuwe element is nu niet het eerste element geworden.");
Assert.AreEqual(lijst.First.Previous, null, "De previous van de nieuwe Link wijst niet naar null.");
Assert.AreEqual(lijst.First.Next, oldFirst, "De next van de nieuwe link wijst niet naar de Link die de eerste in de lijst was.");
}
public void DoublyLinkedList_SwapLinkWithNext_ReturnsCorrectLink()
{
// Arrange
DoubleLink second = lijst.Last;
DoubleLink first = second.Previous;
// Act
DoubleLink result = lijst.SwapLinkWithNext(first);
Assert.AreEqual(result, second, "De return-waarde is niet gelijk aan de Link waarmee geswapt is.");
}
public void DoublyLinkedList_SwapLinkWithNext_LastSwapped_LastIsStillValid()
{
// Arrange
DoubleLink second = lijst.Last;
DoubleLink first = second.Previous;
// Act
lijst.SwapLinkWithNext(first);
Assert.AreEqual(lijst.Last, first, "Na het omdraaien van de een na laatste met de laatste link in een lijst wijst last niet naar de juiste link.");
}
public void DoublyLinkedList_SwapLinkWithNext_FirstSwapped_FirstIsStillValid()
{
// Arrange
DoubleLink first = lijst.First;
DoubleLink second = first.Next;
// Act
lijst.SwapLinkWithNext(first);
Assert.AreEqual(lijst.First, second, "Na het omdraaien van de eerste met de tweede link in een lijst wijst first niet naar de juiste link.");
}
public DoubleLink Insert(string Names)
{
//creates a link, sets its link to the first item and then makes this the first item in the list
DoubleLink link = new DoubleLink(Names);
link.NextLink = theFirst;
if (theFirst != null)//inserts the data into the new node and resets the neighbors
{
theFirst.PreviousLink = link;
}
theFirst = link;
return(link);
}
public DoubleLink GetLinkAt(int index)
{
if (index < _length)
{
DoubleLink current = First;
for (int i = 0; i < index; i++)
{
current = current.Next;
}
return(current);
}
return(null);
}
public void getTest()
{
DoubleLink <string> doubleL = new DoubleLink <string>(new Node <string>("B"));
doubleL.prepend("A");
doubleL.append("C");
doubleL.append("D");
doubleL.append("E");
doubleL.append("F");
doubleL.append("G");
doubleL.append("H");
Assert.AreEqual(doubleL.get(5), "F");
}
public void indexOfTest()
{
DoubleLink <string> doubleL = new DoubleLink <string>(new Node <string>("B"));
doubleL.prepend("A");
doubleL.append("C");
doubleL.append("D");
doubleL.append("E");
doubleL.append("F");
doubleL.append("G");
doubleL.append("H");
Assert.AreEqual(doubleL.indexOf("F"), 5);
}
public void prependTest()
{
DoubleLink <string> doubleL = new DoubleLink <string>(new Node <string>("B"));
doubleL.prepend("D");
doubleL.prepend("E");
List <string> result = new List <string>()
{
"E", "D", "B"
};
CollectionAssert.AreEqual(doubleL.display(), result);
}
/// <summary>
/// 将简单多边形划分为y-单调多边形
/// 逆时针
/// </summary>
/// <param name="polygon">Polygon.</param>
public Polygon[] Divide(Polygon polygon)
{
if (polygon == null)
{
return(null);
}
_Vertexes = polygon.Vertexes;
_Helper.Clear();
_VertexType.Clear();
_Tree.Clear();
_ExtSeg.Clear();
Vector2[] points = _Vertexes.ToArray();
if (points == null)
{
return(null);
}
Array.Sort(points, new Vector2Comparer());
/*
* Vector2 first = points [0];
* DoubleLink<Vector2>.Node firstNode = _Vertexes.Find (first);
* DoubleLink<Vector2>.Node node = firstNode;
* if (firstNode.Value.x < firstNode.Next.Value.x) { // 反向
* do {
* HandleVertex (node.Value);
* node = node.Previous;
* } while(node != firstNode);
* } else { // 同向
* do {
* HandleVertex (node.Value);
* node = node.Next;
* } while(node != firstNode);
* }
*/
for (int i = 0; i < points.Length; i++)
{
HandleVertex(points [i]);
}
if (_ExtSeg.Count == 0)
{
return(new Polygon[] { polygon });
}
else
{
return(Monotone(points[0]));
}
}
public void insertTest()
{
DoubleLink <string> doubleL = new DoubleLink <string>(new Node <string>("B"));
doubleL.insert(0, "A");
doubleL.insert(1, "C");
doubleL.insert(2, "S");
List <string> result = new List <string>()
{
"A", "C", "S", "B"
};
CollectionAssert.AreEqual(doubleL.display(), result);
}
public override string ToString()
{
//converts the items that are inserted to strings so that they may be readable
DoubleLink currentLink = theFirst;
StringBuilder builder = new StringBuilder();
while (currentLink != null)
{
builder.Append(currentLink);
currentLink = currentLink.NextLink;
}
return(builder.ToString());
}
public DoubleLink SwapLinkWithNext(DoubleLink link)
{
if (link == Last)
{
return(null);
}
DoubleLink nextLink = link.Next;
DoubleLink secondNextLink = nextLink.Next;
DoubleLink prevLink = link.Previous;
if (link == First)
{
secondNextLink.Previous = link;
link.Next = secondNextLink;
link.Previous = nextLink;
nextLink.Next = link;
nextLink.Previous = null;
First = nextLink;
}
else if (link.Next == Last)
{
link.Next = null;
link.Previous = nextLink;
nextLink.Next = link;
nextLink.Previous = prevLink;
prevLink.Next = nextLink;
Last = link;
}
else
{
secondNextLink.Previous = link;
link.Next = secondNextLink;
link.Previous = nextLink;
nextLink.Next = link;
nextLink.Previous = prevLink;
prevLink.Next = nextLink;
}
return(nextLink);
}
internal void Remove()
{
_prev._next = _next;
_next._prev = _prev;
_next = _prev = this;
}
internal DoubleLink() { _next = _prev = this; }
