private void Executer_inondation_LSA()
{
foreach (Router A in Machine.get_LesRouter())
{
inondation_LSA(A);
}
}
private void Executer_Dijkstra(String Source, int Destination)
{
if (G.GetIndex(Source) == Destination)
{
//nothing
}
else
{
int s = G.GetIndex(Source);
G.TrouverLesChemins(Source);
int i = 0;
int j;
//Dessiner_Lien_Optimal(Machine.get_LesRouter()[Graphe.PathStock[Destination][i]].get_FaceRouter(), Machine.get_LesRouter()[Graphe.PathStock[Destination][i + 1]].get_FaceRouter());
if (G.PathStock[Destination] == null)
{
}
else
{
while (i < G.PathStock[Destination].Count - 1)
{
Dessiner_Lien_Optimal(Machine.get_LesRouter()[G.PathStock[Destination][i]].get_FaceRouter(), Machine.get_LesRouter()[G.PathStock[Destination][i + 1]].get_FaceRouter());
i++;
}
}
}
}
private void Executer_Aleatoire(int Source, int Destination)
{
if (Source == Destination)
{
//nothing
}
else
{
G.TrouverLesChemins(G.MyIndex(Source));
if (G.PathStock[Destination] == null)
{
}
else
{
Aleatoire.cheminAleatoire.Clear();
Aleatoire.le_chemin_aleatoire(Source, Destination);
int i = 0;
while (i < Aleatoire.cheminAleatoire.Count - 1)
{
Dessiner_Lien_Optimal(Machine.get_LesRouter()[Aleatoire.cheminAleatoire[i]].get_FaceRouter(), Machine.get_LesRouter()[Aleatoire.cheminAleatoire[i + 1]].get_FaceRouter());
i++;
}
}
}
}
private void Etablir_Liaisons_Entre_Router()
{
Random rand = new Random();
foreach (Bunifu.Framework.UI.BunifuCheckbox Check in CheckBoxList)
{
int rnd = rand.Next(1, 21);
int lienExistant = 0;
if (Check.Checked)
{
foreach (Lien link in Machine.get_LesLiens())
{
if ((link.get_int_extrem1() == Convert.ToInt32(Check.Tag) && link.get_int_extrem2() == (Convert.ToInt32(Check.Name) - 1)) || (link.get_int_extrem1() == (Convert.ToInt32(Check.Name) - 1) && link.get_int_extrem2() == Convert.ToInt32(Check.Tag)))
{
lienExistant = 1;
//break;
}
else
{
//lienExistant = 0;
}
}
if (lienExistant == 0)
{
Machine.get_LesRouter()[Convert.ToInt32(Check.Tag)].ajouter_lien(Machine.get_LesRouter()[Convert.ToInt32(Check.Name) - 1], rnd);
G.InsertEdge(G.MyIndex(Convert.ToInt32(Check.Tag)), G.MyIndex(Convert.ToInt32(Check.Name) - 1), rnd);
G.InsertEdge(G.MyIndex(Convert.ToInt32(Check.Name) - 1), G.MyIndex(Convert.ToInt32(Check.Tag)), rnd);
}
else
{
//rien
}
}
}
}
private void creation_lien_router(Router A)
{
foreach (Router B in Machine.get_LesRouter())
{
if (A.get_RouterID() != B.get_RouterID())
{
foreach (Lien lien in A.get_ConnecxionsRouter())
{
if ((lien.get_extrem1() == A.get_RouterID() && lien.get_extrem2() == B.get_RouterID()))
{
Dessiner_Lien(A.get_FaceRouter(), B.get_FaceRouter());
Bunifu.Framework.UI.BunifuCustomLabel RouterLinkLabel = new Bunifu.Framework.UI.BunifuCustomLabel();
RouterLinkLabel.Tag = "oneTime";
RouterLinkLabel.Text = "" + lien.get_cout() + "";
RouterLinkLabel.BackColor = Color.Transparent;
RouterLinkLabel.AutoSize = false;
RouterLinkLabel.Width = 22;
RouterLinkLabel.Height = 15;
RouterLinkLabel.BringToFront();
RouterLinkLabel.Location = new Point((A.get_FaceRouter().Location.X + (A.get_FaceRouter().Size.Width / 2) + B.get_FaceRouter().Location.X + (B.get_FaceRouter().Size.Width / 2)) / 2 - 5, (A.get_FaceRouter().Location.Y + (A.get_FaceRouter().Size.Height / 2) + B.get_FaceRouter().Location.Y + (B.get_FaceRouter().Size.Height / 2)) / 2 - 6);
listeLabel.Add(RouterLinkLabel);
espaceRouter.Controls.Add(RouterLinkLabel);
}
}
}
}
}
private void Dessiner_Le_Graphe()
{
foreach (Router A in Machine.get_LesRouter())
{
afficher_machine(A);
creation_lien_router(A);
}
}
private void supprimer_les_router()
{
for (int i = 0; i < Machine.get_LesRouter().Count; i++)
{
Machine.get_LesRouter()[i] = null;
}
Machine.set_LesRouter(new List <Router>());
Machine.set_LesLiens(new List <Lien>());
Machine.index = 0;
Vertex.a = 0;
}
/***************************************
* METHODES
***************************************/
public static void le_chemin_aleatoire(int source, int destination)
{
cheminAleatoire.Add(source);
if (source != destination)
{
int b = 0;
int c = 0;
foreach (Lien lien in Machine.get_LesLiens())
{
if (lien.get_extrem1() == Machine.get_LesRouter()[source].get_RouterID() || lien.get_extrem2() == Machine.get_LesRouter()[source].get_RouterID())
{
b++;
}
}
nbAlea = Alea.Next(b);
foreach (Lien lien in Machine.get_LesLiens())
{
if (lien.get_extrem1() == Machine.get_LesRouter()[source].get_RouterID() || lien.get_extrem2() == Machine.get_LesRouter()[source].get_RouterID())
{
if (c == nbAlea)
{
NextLien = lien;
c++;
}
else
{
c++;
}
}
}
if (NextLien.get_extrem1() == Machine.get_LesRouter()[source].get_RouterID())
{
RouterSuivantID = NextLien.get_int_extrem2();
}
else
{
RouterSuivantID = NextLien.get_int_extrem1();
}
if (RouterSuivantID != destination)
{
le_chemin_aleatoire(RouterSuivantID, destination);
}
else
{
cheminAleatoire.Add(RouterSuivantID);
}
}
else
{
//
}
}
/***********************************************************************
* METHODES D'ALGORITHMES DE ROUTAGES
************************************************************************/
private void inondation_LSA(Router A)
{
foreach (Router B in Machine.get_LesRouter())
{
if (A.get_RouterID() != B.get_RouterID())
{
foreach (Lien lien in A.get_ConnecxionsRouter())
{
if ((lien.get_extrem1() == A.get_RouterID() && lien.get_extrem2() == B.get_RouterID()))
{
Dessiner_Lien_Optimal(A.get_FaceRouter(), B.get_FaceRouter());
}
}
}
}
}
private void BoutonDessinOptimal_Click(object sender, EventArgs e)
{
espaceRouter.Refresh();
foreach (Router A in Machine.get_LesRouter())
{
creation_lien_router(A);
}
switch (algoComboBox.SelectedIndex)
{
case 0:
Executer_Dijkstra(G.MyIndex(algoSource.Value - 1), Convert.ToInt32(algoDestinantion.Value) - 1);
algo_info_modif(dijkstraInfo, dijkstraTitre);
break;
case 1:
Executer_Dijkstra(G.MyIndex(algoSource.Value - 1), Convert.ToInt32(algoDestinantion.Value) - 1);
algo_info_modif(bellmanInfo, bellmanTitre);
break;
case 2:
Executer_inondation_LSA();
algo_info_modif(inondationInfo, inondationTitre);
break;
case 3:
Executer_inondation_Relais(Machine.get_LesRouter()[Convert.ToInt32(algoSource.Value) - 1]);
algo_info_modif(inondationInfo, inondationTitre);
break;
case 4:
Executer_Aleatoire(Convert.ToInt32(algoSource.Value) - 1, Convert.ToInt32(algoDestinantion.Value) - 1);
algo_info_modif(aleatoireInfo, aleatoireTitre);
break;
case 5:
Executer_hot_potato(Machine.get_LesRouter()[Convert.ToInt32(algoSource.Value) - 1], Machine.get_LesRouter()[Convert.ToInt32(algoDestinantion.Value) - 1]);
algo_info_modif(hotInfo, hotTitre);
break;
default:
break;
}
}
private void hot_potato(Router A, Router B)
{
noeudsAtteint.Add(A.get_RouterNumID());
if (meilleur_noeud(A) == -1)
{
}
else
{
Dessiner_Lien_Optimal(A.get_FaceRouter(), Machine.get_LesRouter()[meilleur_noeud(A)].get_FaceRouter());
if (meilleur_noeud(A) == B.get_RouterNumID())
{
noeudsAtteint.Add(B.get_RouterNumID());
}
else
{
hot_potato(Machine.get_LesRouter()[meilleur_noeud(A)], B);
}
}
}
private void inondation_Relais(Router A)
{
noeudsAtteint.Add(A.get_RouterNumID());
foreach (Router B in Machine.get_LesRouter())
{
foreach (Lien l in Machine.get_LesLiens())
{
if ((l.get_int_extrem1() == A.get_RouterNumID() && l.get_int_extrem2() == B.get_RouterNumID()) || (l.get_int_extrem1() == B.get_RouterNumID() && l.get_int_extrem2() == A.get_RouterNumID()))
{
if (noeudsAtteint.Contains(B.get_RouterNumID()))
{
}
else
{
Dessiner_Lien_Optimal(A.get_FaceRouter(), B.get_FaceRouter());
inondation_Relais(B);
}
}
}
}
}
public static void Algorithme_De_Dijkstra(int[,] graph, int source, int destination, int TailleVecteur)
{
int[] distance = new int[TailleVecteur];
bool[] PlusCourtChemin = new bool[TailleVecteur];
int b = 0;
MeilleurRoute = new Router[TailleVecteur];
for (int i = 0; i < TailleVecteur; ++i)
{
distance[i] = int.MaxValue;
PlusCourtChemin[i] = false;
}
distance[source] = 0;
MeilleurRoute[0] = Machine.get_LesRouter()[source];
int save = 0;
int CheminSuivi = 0;
int u;
u = Distance_Minimum(distance, PlusCourtChemin, TailleVecteur);
PlusCourtChemin[u] = true;
while (u != destination)
{
b++;
for (int v = 0; v < TailleVecteur; ++v)
{
if (!PlusCourtChemin[v] && Convert.ToBoolean(graph[u, v]) && distance[u] != int.MaxValue && distance[u] + graph[u, v] < distance[v])
{
distance[v] = distance[u] + graph[u, v];
MeilleurRoute[b] = Machine.get_LesRouter()[Distance_Minimum(distance, PlusCourtChemin, TailleVecteur)];
save = v;
}
}
u = Distance_Minimum(distance, PlusCourtChemin, TailleVecteur);
PlusCourtChemin[u] = true;
CheminSuivi += graph[u, save];
}
save = CheminSuivi;
CheminSuivi = 0;
b = 0;
for (int i = 0; i < TailleVecteur; ++i)
{
PlusCourtChemin[i] = false;
PlusCourtChemin[source] = true;
if (Distance_Minimum(distance, PlusCourtChemin, TailleVecteur) == i)
{
PlusCourtChemin[i] = true;
}
else
{
distance[i] = int.MaxValue;
PlusCourtChemin[i] = false;
}
}
if (distance[destination] != save)
{
save = 0;
u = Distance_Minimum(distance, PlusCourtChemin, TailleVecteur);
PlusCourtChemin[u] = true;
while (CheminSuivi > distance[destination])
{
b++;
for (int v = 0; v < TailleVecteur; ++v)
{
if (!PlusCourtChemin[v] && Convert.ToBoolean(graph[u, v]) && distance[u] != int.MaxValue && distance[u] + graph[u, v] < distance[v])
{
MeilleurRoute[b] = Machine.get_LesRouter()[Distance_Minimum(distance, PlusCourtChemin, TailleVecteur)];
save = v;
}
}
u = Distance_Minimum(distance, PlusCourtChemin, TailleVecteur);
PlusCourtChemin[u] = true;
CheminSuivi += graph[u, save];
}
}
//Affichage(distance, TailleVecteur);
}