public void DodajElement(Osoba.Osoba osoba)
{
if (korzen == null)
{
korzen = new Wezel();
korzen.Dane = osoba;
return;
}
Wezel p = korzen, poprzedni;
do
{
poprzedni = p;
if (osoba.CompareTo(p.Dane) < 0)
{
p = p.Lewy;
}
else
{
p = p.Prawy;
}
}while(p != null);
if (osoba.CompareTo(poprzedni.Dane) < 0)
{
poprzedni.Lewy = new Wezel();
poprzedni.Lewy.Dane = osoba;
}
else
{
poprzedni.Prawy = new Wezel();
poprzedni.Prawy.Dane = osoba;
}
}
public Kwadrat(WezelKontroli _GL, WezelKontroli _GP, WezelKontroli _DP, WezelKontroli _DL)
{
GL = _GL;
GP = _GP;
DP = _DP;
DL = _DL;
SG = GL.prawo;
SP = DP.gora;
SD = DL.prawo;
SL = DL.gora;
if (GL.stan)
{
ksztalt += 8;
}
if (GP.stan)
{
ksztalt += 4;
}
if (DP.stan)
{
ksztalt += 2;
}
if (DL.stan)
{
ksztalt += 1;
}
}
/// <summary>
/// Zamienia stringa ze sciezka na obiekt klasy Sciezka.
/// </summary>
/// <param name="stringPath"></param>
/// <returns></returns>
public static Sciezka stringToPath(string stringPath)
{
if (stringPath == "")
{
return(new Sciezka());
}
var words = stringPath.Split('#');
Wezel w1 = new Wezel(-1, words[0]);
Sciezka sc = new Sciezka();
//Dodanie pierwszego wezla
sc.Wezel1 = w1;
sc.WezlySciezki.Add(w1);
for (int i = 1; i < words.Length; i = i + 2)
{
//Wezel drugi z lacza
Wezel W2 = new Wezel(-1, words[i + 1]);
sc.WezlySciezki.Add(W2);
//Dodanie nowej krawedzi
sc.KrawedzieSciezki.Add(new Lacze(Int32.Parse(words[i]), sc.WezlySciezki[sc.WezlySciezki.Count - 2], W2,
1));
}
//Ostatni wezel
sc.Wezel2 = sc.WezlySciezki[sc.WezlySciezki.Count - 1];
return(sc);
}
public void Dodaj(int liczba)
{
Wezel tmp = new Wezel(liczba);
tmp.nastepny = head;
head = tmp;
}
void rekurencja(Wezel w, out int index)
{
index = iteracja; //*3
bvharr[index].x = Bindex;
iteracja++;
int index1_v = 0;
int index2_v = 0;
if (w.n1 == null && w.n2 == null)
{
bvharr[index].x = w.id;
}
else
{
B.Add(w.boxmin);
B.Add(w.boxmax);
Bindex += 2;
if (w.n1 != null)
{
rekurencja(w.n1, out index1_v);
}
if (w.n2 != null)
{
rekurencja(w.n2, out index2_v);
}
}
bvharr[index].y = index1_v;
bvharr[index].z = index2_v;
}
public void ReadingFromPathFile(string path)
{
string line;
char[] delimiterChars = { '#' };
string[] words;
int id1, id2, pathID, index1, index2;
try
{
using (StreamReader file = new StreamReader(path))
{
while ((line = file.ReadLine()) != null)
{
words = line.Split(delimiterChars);
id1 = Int32.Parse(words[1]);
id2 = Int32.Parse(words[2]);
pathID = Int32.Parse(words[0]);
index1 = nodes_names.Values.ToList().IndexOf(id1);
index2 = nodes_names.Values.ToList().IndexOf(id2);
Wezel w1 = this.topology.network.wezly.Find(x => x.idWezla == id1);
Wezel w2 = this.topology.network.wezly.Find(x => x.idWezla == id2);
Lacze lacze = new Lacze(pathID, w1, w2);
this.topology.network.krawedzie.Add(lacze);
}
}
}
catch (Exception e)
{
Console.WriteLine("Cannot read from file");
}
}
/// <summary>
/// Obsługuje zapytanie NetworkTopology
/// </summary>
/// <param name="words"></param>
public void handleNetworkTopology(string[] words)
{
//Czytanie wiadomosci
string rcIP = words[0];
string ipSource = words[2];
string ipDestination = words[3];
short band = Int16.Parse(words[4]);
short frequency = Int16.Parse(words[5]);
Wezel w1 = this.topology.network.wezly.Find(x => x.ip == ipSource);
Wezel w2 = this.topology.network.wezly.Find(x => x.ip == ipDestination);
//uruchomienie algorytmu najkrotszej sciezki
this.topology.runShortestPathAlgorithm();
//wyznaczenie sciezki
NetworkPath networkPath = this.topology.getNetworkPath(w1.SNPP, w2.SNPP, band, this.topology.network, frequency);
//Dodanie do listy potencjalnych sciezek, o ile nie jest pusta
if (networkPath.snpps.Count != 0)
{
this.topology.pathsCopy.Add(networkPath);
}
//wygenerowanie wiadomosci
string message = this.generateNetworkTopologyRCesponse(networkPath.path);
//wysylanie wiadomosci na porcie 11001
SendMessage(rcIP, message, 11002);
}
public void testWyznaczSciezke()
{
Siec network = new Siec();
Wezel w1 = new Wezel(1, "127.0.0.1");
Wezel w2 = new Wezel(2, "127.0.0.2");
Wezel w3 = new Wezel(3, "127.0.0.3");
network.wezly.Add(w1);
network.wezly.Add(w2);
network.wezly.Add(w3);
network.krawedzie.Add(new Lacze(12, w1, w2));
network.krawedzie.Add(new Lacze(23, w2, w3));
short band = 5;
short frequency = 6;
Sciezka path = new Sciezka(w1, w3);
network.algorytmFloyda();
path.wyznaczSciezke(w1, w2, band, frequency, network);
Assert.AreNotEqual(0, path.WezlySciezki.Count);
Assert.AreNotEqual(0, path.KrawedzieSciezki.Count);
Assert.AreEqual(w1.ip, path.WezlySciezki[0].ip);
Assert.AreEqual(w2.ip, path.WezlySciezki[1].ip);
Assert.AreEqual(w3.ip, path.WezlySciezki[2].ip);
}
/// <summary>
/// Wyswietla dane
/// </summary>
public void WypiszWszystko()
{
for (Wezel tmp = glowa; tmp != null; tmp = tmp.Nastepny)
{
Console.WriteLine(tmp.Dane);
}
}
public void testUpdateCost()
{
Wezel w1 = new Wezel(1, "127.0.0.1");
Wezel w2 = new Wezel(2, "127.0.0.2");
Lacze link = new Lacze(12, w1, w2);
Assert.AreEqual(0, link.Waga);
//Dodanie wpisow do tablic eonowych wezla 1 na wyjsciu (f = 0, B = 17)
link.Wezel1.SNPP.snps[0].eonTable.addRow(new EONTableRowOut(0, 17));
//I na wejsciu wezla 2
link.Wezel2.SNPP.snps[0].eonTable.addRow(new EONTableRowIN(0, 17));
//Aktualizacja wagi krawędzi
link.updateCost(0, 17);
Assert.AreEqual(17 * 17, link.Waga);
//f = 19, B = 5, ale tylko na jednym węźle
link.Wezel1.SNPP.snps[0].eonTable.addRow(new EONTableRowOut(19, 5));
link.updateCost(19, 5);
Assert.AreEqual(17 * 17, link.Waga);
link.Wezel2.SNPP.snps[0].eonTable.addRow(new EONTableRowIN(19, 5));
link.updateCost(19, 5);
Assert.AreEqual(22 * 22, link.Waga);
}
public void Wstaw(T x)
{
liczbaElementow++;
if (korzen == null)
{
korzen = new Wezel(x, null, null);
return;
}
Wezel tmp = korzen, poprzedni;
do
{
poprzedni = tmp;
if (tmp.dane.CompareTo(x) < 0)
{
tmp = tmp.prawy;
}
else
{
tmp = tmp.lewy;
}
}while (tmp != null);
if (poprzedni.dane.CompareTo(x) < 0)
{
poprzedni.prawy = new Wezel(x, null, null);
}
else
{
poprzedni.lewy = new Wezel(x, null, null);
}
}
void init()
{
bvh = null;
var czyZnalezionoDrzewo = treesSetCache.TryGetValue(meshCheckSum, out bvh);
if (czyZnalezionoDrzewo)
{
root = rebuildRootTree(bvh);
updateBoxes();
}
else
{
root = getLogicTree();
rootToTables();
var byteArray = new byte[bvh.Count * sizeof(int) * 3];
var intBvhArray = new int[bvh.Count * 3];
int i = 0;
foreach (var ele in bvh)
{
intBvhArray[i] = ele.x;
i++;
intBvhArray[i] = ele.y;
i++;
intBvhArray[i] = ele.z;
i++;
}
Buffer.BlockCopy(intBvhArray, 0, byteArray, 0, byteArray.Length);
File.WriteAllBytes(folderName + "\\" + meshCheckSum, byteArray);
}
}
public void ReadingFromNodesFile(string path)
{
string line;
char[] delimiterChars = { '#' };
string[] words;
try
{
using (StreamReader file = new StreamReader(path))
{
while ((line = file.ReadLine()) != null)
{
words = line.Split(delimiterChars);
int id = Int32.Parse(words[1]);
Wezel w = new Wezel(id, words[0]);
this.topology.network.wezly.Add(w);
nodes_names.Add(words[0], id);
}
}
}
catch (Exception e)
{
Console.WriteLine("Cannot read from file");
}
}
public void Wyswietl()
{
for (Wezel w = head; w != null; w = w.nastepny)
{
Console.Write(w.dane + " ");
}
Console.WriteLine();
}
/// <summary>
/// Dodaje element do listy
/// </summary>
/// <param name="s"></param>
public void DodajDoGlowy(Towar s)
{
Wezel tmp = new Wezel();
tmp.Dane = s;
tmp.Nastepny = glowa;
glowa = tmp;
}
public void testNodeConstructor()
{
Wezel w1 = new Wezel(1, "127.0.0.1");
Wezel w2 = new Wezel(2, "127.0.0.2");
Assert.AreEqual("127.0.0.1", w1.SNPP.snps[0].ipaddress.ToString());
Assert.AreEqual("127.0.0.2", w2.SNPP.snps[0].ipaddress.ToString());
}
Wezel rebuildRootTree(List <Vector3Int> list)
{
Vector3Int[] bvhTable = list.ToArray();
Wezel w = new Wezel();
rebuildRecurention(bvhTable, w, 0);
return(w);
}
public T Pop()
{
if (IsEmpty)
{
throw new StosEmptyException();
}
szczyt = szczyt.next;
return(default);
public T pop_front()
{
//przy pustej liście powinno wyrzucić wyjątek
T temp = first.Value;
first = first.next;
count--;
return(temp);
}
public void KlonujRekurencyjnie(Wezel wezel)
{
wezel.Dane = Dane;
if (Nastepny != null)
{
wezel.Nastepny = new Wezel();
Nastepny.KlonujRekurencyjnie(wezel.Nastepny);
}
}
private static void zamienNaTablice(Wezel w, T[] tab, ref int n)
{
if (w != null)
{
zamienNaTablice(w.lewy, tab, ref n);
tab[n] = w.dane;
n++;
zamienNaTablice(w.prawy, tab, ref n);
}
}
/// <summary>
/// Usuwa element z listy
/// </summary>
/// <returns>Zwraca usuniety element</returns>
public Towar UsunZGlowy()
{
if (glowa == null) //lista pusta
{
throw new InvalidOperationException("Lista jest pusta. ");
}
Towar x = glowa.Dane;
glowa = glowa.Nastepny;
return(x);
}
/// <summary>
/// Obliczanie sumy cen brutto wsyztskich towarów na liście
/// </summary>
/// <returns>Zwraca calkowitą cenę brutto towarów z faktury</returns>
public double CenaCalkBrutto()
{
double cena = 0;
Wezel tmp = glowa;
while (tmp != null)
{
cena += tmp.Dane.CenaCalkBrutto;
tmp = tmp.Nastepny;
}
return(cena);
}
void UtwTrojkat(Wezel a, Wezel b, Wezel c)
{
trojkaty.Add(a.wierzcholek);
trojkaty.Add(b.wierzcholek);
trojkaty.Add(c.wierzcholek);
Trojkat trojkat = new Trojkat(a.wierzcholek, b.wierzcholek, c.wierzcholek);
DodajDoSlownika(trojkat.wierzcholekA, trojkat);
DodajDoSlownika(trojkat.wierzcholekB, trojkat);
DodajDoSlownika(trojkat.wierzcholekC, trojkat);
}
public bool resolveSNPPS(ref NetworkPath networkPath, short band, short frequency)
{
//topology.getNetworkPath();
foreach (var snpp in networkPath.snpps)
{
//if (canIGoOnAtThisFrequency)
//{
SNandRC sNandRc = SN_RCs.Find(x => x.snpp.snps[0].ipaddress.ToString() == snpp.snps[0].ipaddress.ToString());
if (sNandRc != null)
{
//IP węzła modelującego podsieć
string oldNodeIP = sNandRc.snpp.snps[0].ipaddress.ToString();
//Łącze dochodzące do węzła modelującego podsieć
int previousLink = networkPath.path.KrawedzieSciezki.FindIndex(x =>
x.Wezel2.ip == oldNodeIP);
//Łącze wychodzące z węzła modelującego podsieć
int nextLink = networkPath.path.KrawedzieSciezki.FindIndex(x =>
x.Wezel1.ip == oldNodeIP);
Wezel w1 = networkPath.path.zwroc_ListaKrawedziSciezki[previousLink].Wezel1;
Wezel w2 = networkPath.path.zwroc_ListaKrawedziSciezki[nextLink].Wezel2;
SubNetworkPointPool SNPPFrom = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(w1.ip)));
SubNetworkPointPool SNPPTo = new SubNetworkPointPool(new SubNetworkPoint(IPAddress.Parse(w2.ip)));
// writeLog("Resolving path from " + SNPPFrom.snps[0].ipaddress + " to " + SNPPTo.snps[0].ipaddress);
//Czesciowa sciezka, którą trzeba dodać do nadścieżki
var partOfThePath = this.getPathFromRC(sNandRc.RC_IP.ToString(), SNPPFrom, SNPPTo, band,
frequency);
//Sciezka jest pusta
if (partOfThePath == null || partOfThePath.snpps.Count == 0)
{
//canIGoOnAtThisFrequency = false;
return(false);
}
//Ścieżka jest niepusta
else
{
//insertSubPath(ref networkPath, partOfThePath, previousLink, nextLink);
return(true);
}
}
}
//}
return(true);
}
public Wezel getChildById(Wezel parrent, int childId)
{
foreach (Wezel child in parrent.children)
{
if (child.ID == childId)
{
return(child);
}
}
Console.WriteLine(parrent.name + " hasn't got child with ID: " + childId);
return(null);
}
public void ZdublujWartości(int wartosc)
{
for (Wezel w = head; w != null; w = w.nastepny)
{
if (w.dane == wartosc)
{
Wezel tmp = new Wezel(wartosc);
tmp.nastepny = w.nastepny;
w.nastepny = tmp;
w = w.nastepny;
}
}
}
//ogolnie to nie wiem czy dobrze to jest. Robi³em na oko i sprawdze potem :D
public void KlonujRekurencyjnieGleboko(Wezel wezel)
{
wezel.Dane = new Osoba.Osoba(Dane); // osoby s¹ kopiowane i s¹ niezale¿ne
if (Lewy != null)
{
wezel.Lewy = new Wezel();
Lewy.KlonujRekurencyjnieGleboko(wezel.Lewy);
}
if (Prawy != null)
{
wezel.Prawy = new Wezel();
Prawy.KlonujRekurencyjnieGleboko(wezel.Prawy);
}
}
public void KlonujRekurencyjnie(Wezel wezel)
{
wezel.Dane = Dane; // osoby nie s¹ kopiowane
if (Lewy != null)
{
wezel.Lewy = new Wezel();
Lewy.KlonujRekurencyjnieGleboko(wezel.Lewy);
}
if (Prawy != null)
{
wezel.Prawy = new Wezel();
Prawy.KlonujRekurencyjnieGleboko(wezel.Prawy);
}
}
//metoda która z poprzedników węzła potrafi znaleźć trasę
private List <WierzcholekGrafu> ZnajdzTraseZPoprzednikow(List <Wezel> poprzednicy, WierzcholekGrafu start, WierzcholekGrafu koniec)
{
List <WierzcholekGrafu> trasa = new List <WierzcholekGrafu>();
Wezel nastepny = poprzednicy.Find(obiekt => obiekt.Klucz == koniec);
while (nastepny.Poprzednik != null)
{
trasa.Add(nastepny.Klucz);
nastepny = nastepny.Poprzednik;
}
return(trasa.Reverse <WierzcholekGrafu>().ToList());
}
