From bc6e91b21da02b78bcf06368ffabc764284b7837 Mon Sep 17 00:00:00 2001
From: Bafo <fofana@insa-toulouse.fr>
Date: Fri, 19 May 2023 18:11:20 +0200
Subject: [PATCH] Test junit prblm dijkstra

---
 .vscode/launch.json                           |  35 ----
 be-graphes-algos/.classpath                   |  27 ---
 .../.settings/org.eclipse.jdt.apt.core.prefs  |   2 +
 .../.settings/org.eclipse.jdt.core.prefs      |   1 +
 .../shortestpath/AStarAlgorithm.java          |  23 +--
 .../shortestpath/DijkstraAlgorithm.java       |  60 ++----
 .../algorithm/utils/AStarAlgorithmTest.java   |  14 ++
 .../utils/DijkstraAlgorithmTest.java          | 179 ++++++++++++++++++
 .../shortestpath/AStarAlgorithm.class         | Bin 3504 -> 1666 bytes
 .../shortestpath/DijkstraAlgorithm.class      | Bin 7629 -> 5411 bytes
 .../org/insa/graphs/gui/simple/Launch.java    |   2 +
 .../org/insa/graphs/gui/simple/Launch.class   | Bin 2570 -> 2570 bytes
 12 files changed, 213 insertions(+), 130 deletions(-)
 delete mode 100644 .vscode/launch.json
 delete mode 100644 be-graphes-algos/.classpath
 create mode 100644 be-graphes-algos/.settings/org.eclipse.jdt.apt.core.prefs
 create mode 100644 be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/AStarAlgorithmTest.java
 create mode 100644 be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/DijkstraAlgorithmTest.java

diff --git a/.vscode/launch.json b/.vscode/launch.json
deleted file mode 100644
index 1f4257f..0000000
--- a/.vscode/launch.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "java",
-            "name": "Current File",
-            "request": "launch",
-            "mainClass": "${file}"
-        },
-        {
-            "type": "java",
-            "name": "BinaryHeapFormatter",
-            "request": "launch",
-            "mainClass": "org.insa.graphs.algorithm.utils.BinaryHeapFormatter",
-            "projectName": "be-graphes-algos"
-        },
-        {
-            "type": "java",
-            "name": "MainWindow",
-            "request": "launch",
-            "mainClass": "org.insa.graphs.gui.MainWindow",
-            "projectName": "be-graphes-gui"
-        },
-        {
-            "type": "java",
-            "name": "Launch",
-            "request": "launch",
-            "mainClass": "org.insa.graphs.gui.simple.Launch",
-            "projectName": "be-graphes-gui"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/be-graphes-algos/.classpath b/be-graphes-algos/.classpath
deleted file mode 100644
index 5e8a55f..0000000
--- a/be-graphes-algos/.classpath
+++ /dev/null
@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-			<attribute name="test" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>
diff --git a/be-graphes-algos/.settings/org.eclipse.jdt.apt.core.prefs b/be-graphes-algos/.settings/org.eclipse.jdt.apt.core.prefs
new file mode 100644
index 0000000..d4313d4
--- /dev/null
+++ b/be-graphes-algos/.settings/org.eclipse.jdt.apt.core.prefs
@@ -0,0 +1,2 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.apt.aptEnabled=false
diff --git a/be-graphes-algos/.settings/org.eclipse.jdt.core.prefs b/be-graphes-algos/.settings/org.eclipse.jdt.core.prefs
index 2f5cc74..1b6e1ef 100644
--- a/be-graphes-algos/.settings/org.eclipse.jdt.core.prefs
+++ b/be-graphes-algos/.settings/org.eclipse.jdt.core.prefs
@@ -4,5 +4,6 @@ org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
 org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.processAnnotations=disabled
 org.eclipse.jdt.core.compiler.release=disabled
 org.eclipse.jdt.core.compiler.source=1.8
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
index a53c721..716a314 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.java
@@ -1,8 +1,6 @@
 package org.insa.graphs.algorithm.shortestpath;
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Node;
-import org.insa.graphs.model.Path;
-import java.util.ArrayList;
 import org.insa.graphs.model.Point;
 public class AStarAlgorithm extends DijkstraAlgorithm {
 
@@ -17,24 +15,5 @@ public class AStarAlgorithm extends DijkstraAlgorithm {
         return new LabelStar(x,cout,parent,Point.distance(data.getGraph().get(x.getId()).getPoint(), data.getDestination().getPoint()));
     }
     
-    @Override
-    public void ShortestVerif(ShortestPathSolution solution,ArrayList<Node> solutionNodes , ShortestPathData data)
-    {
-        Path p = Path.createShortestPathFromNodes(data.getGraph(), solutionNodes);
-        System.out.println("shortest path : " + p.getLength());
-        if (p.getLength()-solution.getPath().getLength() < 1.00){
-            System.out.println("le chemin Astar bien est le shortest");
-        }
-
-    }
-
-    @Override
-    public void fastestVerif(ShortestPathSolution solution,ArrayList<Node> solutionNodes,ShortestPathData data){
-        Path p= Path.createFastestPathFromNodes(data.getGraph(), solutionNodes);
-        System.out.println("fastest path : " + p.getMinimumTravelTime());
-        if (p.getMinimumTravelTime()-solution.getPath().getMinimumTravelTime() < 1.00){
-            System.out.println("le chemin Astar est bien le fastest");
-        }
-
-    }
+   
 }
diff --git a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
index 226c8ea..6b02464 100644
--- a/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
+++ b/be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java
@@ -8,7 +8,6 @@ import org.insa.graphs.algorithm.utils.BinaryHeap;
 import org.insa.graphs.model.Arc;
 import org.insa.graphs.model.Node;
 import org.insa.graphs.model.Path;
-import org.insa.graphs.model.Point;
 
 public class DijkstraAlgorithm extends ShortestPathAlgorithm {
 
@@ -29,7 +28,6 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
         ArrayList<Label> List_Label = new ArrayList<Label>(data.getGraph().size()); //Liste de labels
         BinaryHeap<Label> Tas = new BinaryHeap<Label>();
         ArrayList<Arc> Arcs = new ArrayList<Arc>();
-
         
         /* Initialise nos label */
         for (Node x: data.getGraph().getNodes())
@@ -90,58 +88,28 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
         }
         //On récupère le chemin (liste d'arcs) de la destination vers la source
         Label dest =List_Label.get(data.getDestination().getId());    
-        while (dest.getParent() != null){
-            Arcs.add(dest.getParent());
-            dest = List_Label.get(dest.getParent().getOrigin().getId());
+
+        if (dest.getParent() == null || data.getOrigin()==data.getDestination()) {
+             return solution = new ShortestPathSolution(data, Status.INFEASIBLE);
         }
+        else {
+
+            // The destination has been found, notify the observers.
+            notifyDestinationReached(data.getDestination());
+            while (dest.getParent() != null){
+                Arcs.add(dest.getParent());
+                dest = List_Label.get(dest.getParent().getOrigin().getId());
+            }
+        }
+
         //On inverse la liste d'arcs
         Collections.reverse(Arcs);
         //On construit la solution
         solution = new ShortestPathSolution(data, Status.OPTIMAL, new Path(data.getGraph(), Arcs));
 
 
-        ArrayList<Node> solutionNodes = new ArrayList<Node>();
-        //On récupère la liste de nodes du Path solution
-        for (Arc a : Arcs){
-            solutionNodes.add(a.getOrigin());
-        }
-        solutionNodes.add(data.getDestination());
-
-
-        //Vérifications de la validité de la solution
-        ShortestVerif(solution, solutionNodes, data);
-        fastestVerif(solution, solutionNodes, data);
-        volDoiseauVerif(data, solution);
+        
         return solution;
 
     }
-    //Permet de vérifier si le chemin obtenu par la solution est bien le plus court
-    public void ShortestVerif(ShortestPathSolution solution,ArrayList<Node> solutionNodes , ShortestPathData data)
-    {
-        Path p = Path.createShortestPathFromNodes(data.getGraph(), solutionNodes);
-        System.out.println("shortest path : " + p.getLength());
-        if (p.getLength()-solution.getPath().getLength() < 1.00){
-            System.out.println("le chemin Dijkstra est bien le shortest");
-        }
-
-    }
-
-    // Permet de vérifier si le temps de parcours de la solution est bien le plus rapide
-    public void fastestVerif(ShortestPathSolution solution,ArrayList<Node> solutionNodes,ShortestPathData data){
-        Path p= Path.createFastestPathFromNodes(data.getGraph(), solutionNodes);
-        System.out.println("fastest path : " + p.getMinimumTravelTime());
-        if (p.getMinimumTravelTime()-solution.getPath().getMinimumTravelTime() < 1.00){
-            System.out.println("le chemin Dijkstra est bien le fastest");
-        }
-
-    }
-    // Permet de vérifier si la distance de la solution est plus long que la distance à vol d'oiseau
-    public void volDoiseauVerif(ShortestPathData data, ShortestPathSolution solution){
-        double distanceV = Point.distance(data.getGraph().get(data.getOrigin().getId()).getPoint(), data.getDestination().getPoint());
-        if (distanceV > solution.getPath().getLength()){
-            System.out.println("La solution n'est pas réalisable");
-        } else {
-            System.out.println("La solution est réalisable");
-        }
-    }
 }
\ No newline at end of file
diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/AStarAlgorithmTest.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/AStarAlgorithmTest.java
new file mode 100644
index 0000000..2bf54f5
--- /dev/null
+++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/AStarAlgorithmTest.java
@@ -0,0 +1,14 @@
+package  org.insa.graphs.algorithm.utils;
+import org.insa.graphs.algorithm.shortestpath.AStarAlgorithm;
+import org.insa.graphs.algorithm.shortestpath.ShortestPathAlgorithm;
+import org.insa.graphs.algorithm.shortestpath.ShortestPathData;
+
+public class AStarAlgorithmTest extends DijkstraAlgorithmTest{
+
+	@Override
+	protected ShortestPathAlgorithm doAlgo(ShortestPathData data)
+	{
+		return new AStarAlgorithm(data);
+	}
+
+}
\ No newline at end of file
diff --git a/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/DijkstraAlgorithmTest.java b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/DijkstraAlgorithmTest.java
new file mode 100644
index 0000000..0ad5ab8
--- /dev/null
+++ b/be-graphes-algos/src/test/java/org/insa/graphs/algorithm/utils/DijkstraAlgorithmTest.java
@@ -0,0 +1,179 @@
+package org.insa.graphs.algorithm.utils;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+
+
+import org.insa.graphs.model.*;
+import org.insa.graphs.model.RoadInformation.RoadType;
+import java.io.BufferedInputStream;
+import java.io.DataInputStream;
+import java.io.FileInputStream;
+import org.insa.graphs.algorithm.ArcInspectorFactory;
+import org.insa.graphs.algorithm.shortestpath.*;
+import org.insa.graphs.model.io.BinaryGraphReader;
+import org.insa.graphs.model.io.GraphReader;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public abstract class DijkstraAlgorithmTest {
+
+    // Small graph use for tests
+    private static Graph graph;
+
+    // List of nodes
+    private static Node[] nodes;
+
+    // List of arcs in the graph, a2b is the arc from node A (0) to B (1).
+    @SuppressWarnings("unused")
+    private static Arc a2b, a2c, a2e, b2c, c2d_1, c2d_2, c2d_3, c2a, d2a, d2e, e2d;
+
+    @BeforeClass
+    public static void initAll() throws IOException {
+        final String map = "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/carre-dense.mapgr";
+        final GraphReader reader = new BinaryGraphReader(
+        new DataInputStream(new BufferedInputStream(new FileInputStream(map))));
+        graph = reader.read();
+
+        // 10 and 20 meters per seconds paramètres des chemins emprunter
+        RoadInformation speed10 = new RoadInformation(RoadType.MOTORWAY, null, true, 36, ""),
+                speed20 = new RoadInformation(RoadType.MOTORWAY, null, true, 72, "");
+
+        // Create nodes
+        nodes = new Node[6];
+        // for (int i = 0; i < nodes.length; ++i) {
+        //     nodes[i] = new Node(i, null);
+        // }
+
+        nodes[0] = new Node(0, new Point(0, 20));
+        nodes[1] = new Node(0, new Point(20, 0));
+        nodes[2] = new Node(0, new Point(15, 43));
+        nodes[3] = new Node(0, new Point(12, 16));
+        nodes[4] = new Node(0, new Point(17, 89));
+        nodes[5] = new Node(0, new Point(43, 45));
+        
+        // Add arcs...
+        a2b = Node.linkNodes(nodes[0], nodes[1], 10, speed10, null);
+        a2c = Node.linkNodes(nodes[0], nodes[2], 15, speed10, null);
+        a2e = Node.linkNodes(nodes[0], nodes[4], 15, speed20, null);
+        b2c = Node.linkNodes(nodes[1], nodes[2], 10, speed10, null);
+        c2d_1 = Node.linkNodes(nodes[2], nodes[3], 20, speed10, null);
+        c2d_2 = Node.linkNodes(nodes[2], nodes[3], 10, speed10, null);
+        c2d_3 = Node.linkNodes(nodes[2], nodes[3], 15, speed20, null);
+        d2a = Node.linkNodes(nodes[3], nodes[0], 15, speed10, null);
+        d2e = Node.linkNodes(nodes[3], nodes[4], 22.8f, speed20, null);
+        e2d = Node.linkNodes(nodes[4], nodes[0], 10, speed10, null);
+
+        graph = new Graph("ID", "", Arrays.asList(nodes), new GraphStatistics (null,9,1,72,1));
+
+        
+
+    }
+
+    protected ShortestPathAlgorithm doAlgo(ShortestPathData data) {
+        
+        return new DijkstraAlgorithm(data);
+    }
+
+    @Test
+    public void Chemin_Valide() throws Exception{
+        final String map_c = "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/carre-dense.mapgr";
+        final GraphReader reader = new BinaryGraphReader(new DataInputStream(new BufferedInputStream(new FileInputStream(map_c))));
+        Graph graph_c = reader.read();
+        ShortestPathData data = new ShortestPathData(graph_c,graph_c.get(120084),graph_c.get(191086),ArcInspectorFactory.getAllFilters().get(0));
+        ShortestPathAlgorithm Dijkstra = doAlgo(data);
+        ShortestPathSolution solution = Dijkstra.run();
+        assertTrue(solution.getPath().isValid());
+    }
+
+    
+    @Test
+    public void Chemin_Inexistant(){
+        ShortestPathData data = new ShortestPathData(graph,nodes[0],nodes[5],ArcInspectorFactory.getAllFilters().get(0));
+        ShortestPathAlgorithm Bellman_ford= new BellmanFordAlgorithm(data);
+        ShortestPathAlgorithm Dijkstra = doAlgo(data);
+        ShortestPathSolution solution = Dijkstra.run();
+        ShortestPathSolution soluce_Bellma= Bellman_ford.run();
+        assertEquals(soluce_Bellma.getStatus(),solution.getStatus());
+    }
+
+    @Test
+    public void Comparaison_Bell() throws IOException{
+        final String map_c = "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/carre.mapgr";
+        final GraphReader reader = new BinaryGraphReader(new DataInputStream(new BufferedInputStream(new FileInputStream(map_c))));
+        Graph graph_c = reader.read();
+        ShortestPathData data = new ShortestPathData(graph_c,graph_c.get(1),graph_c.get(23),ArcInspectorFactory.getAllFilters().get(0));
+        ShortestPathAlgorithm Dijkstra = doAlgo(data);
+        ShortestPathAlgorithm Bellman_ford= new BellmanFordAlgorithm(data);
+        ShortestPathSolution soluce_Dijkstra= Dijkstra.run();
+        ShortestPathSolution soluce_Bellma= Bellman_ford.run();
+        //Verifie la difference entre Bellman et djkstra avec une difference max de 1e-6
+        assertEquals(soluce_Dijkstra.getPath().getLength(),soluce_Bellma.getPath().getLength(),1e-6);
+    }
+
+    @Test
+    public void Chemin_Null(){
+        ShortestPathData data = new ShortestPathData(graph,nodes[0],nodes[0],ArcInspectorFactory.getAllFilters().get(0));
+        ShortestPathAlgorithm Dijkstra = new DijkstraAlgorithm(data);
+        ShortestPathAlgorithm Bellman_ford= new BellmanFordAlgorithm(data);
+        ShortestPathSolution solution = Dijkstra.run();
+        ShortestPathSolution soluce_Bellma= Bellman_ford.run();
+        assertEquals(solution.getStatus(),soluce_Bellma.getStatus());
+    }
+
+
+    @Test
+    public void Carte_Length() throws IOException{
+
+        //Nous allons cherche lee chemin et la carte a analyser
+        final String map_c = "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/carre-dense.mapgr";
+        final GraphReader reader = new BinaryGraphReader(new DataInputStream(new BufferedInputStream(new FileInputStream(map_c))));
+        Graph graph_c = reader.read();
+        ShortestPathData data = new ShortestPathData(graph_c,graph_c.get(120084),graph_c.get(191086),ArcInspectorFactory.getAllFilters().get(0));
+        ShortestPathAlgorithm Dijkstra = doAlgo(data);
+        ShortestPathSolution solution = Dijkstra.run();
+        ArrayList<Node> solutionNodes = new ArrayList<Node>();
+        //On récupère la liste de nodes du Path solution
+        for (Arc a : solution.getPath().getArcs()){
+            solutionNodes.add(a.getOrigin());
+        }
+        solutionNodes.add(data.getDestination());
+        Path solution_final = Path.createShortestPathFromNodes(graph_c, solutionNodes);
+        assertEquals(solution.getPath().getLength(), solution_final.getLength(),1e-6);
+    }
+    
+    @Test
+    public void Carte_Time() throws Exception{
+
+        //Nous allons cherche lee chemin et la carte a analyser
+        final String map_c = "/mnt/commetud/3eme Annee MIC/Graphes-et-Algorithmes/Maps/carre-dense.mapgr";
+        final GraphReader reader = new BinaryGraphReader(new DataInputStream(new BufferedInputStream(new FileInputStream(map_c))));
+        Graph graph_c = reader.read();
+        ShortestPathData data = new ShortestPathData(graph_c,graph_c.get(120084),graph_c.get(191086),ArcInspectorFactory.getAllFilters().get(2));
+        ShortestPathAlgorithm Dijkstra = doAlgo(data);
+        ShortestPathSolution solution = Dijkstra.run();
+        ArrayList<Node> solutionNodes = new ArrayList<Node>();
+        //On récupère la liste de nodes du Path solution
+        for (Arc a : solution.getPath().getArcs()){
+            solutionNodes.add(a.getOrigin());
+        }
+        solutionNodes.add(data.getDestination());
+        Path solution_final = Path.createFastestPathFromNodes(graph_c, solutionNodes);
+        assertEquals(solution.getPath().getMinimumTravelTime(), solution_final.getMinimumTravelTime(),1e-6);
+
+    }
+
+
+
+
+    
+}
+
+
diff --git a/be-graphes-algos/target/classes/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.class b/be-graphes-algos/target/classes/org/insa/graphs/algorithm/shortestpath/AStarAlgorithm.class
index b12bbb46176ef6b0795f4f0eeee60d295029679c..ba7f53868ba98d9f607ad7de29d1c365532e8110 100644
GIT binary patch
delta 64
zcmdlW-NY+!>ff$?3=9k=44&)^OpFYs6DO)~G&f_N{Dw=1k!i9dw>B#W11kgPWKZsV
UR$c}+2L8!=x$RjQ7?>D503GcO?f?J)

literal 3504
zcmb_eYjYD-7=BJ0x@lOb6ev(`0jjhV8kBoenigWQ60n-uiuY~0O%{^fxY;1}enGr~
ze)NMs!4K+(z{rd<`qAIyI6mj>CT+Tn#?k3ay1VDR@B2LO<vHi~KY#uOz)5_gp+n%5
z<K`2VT`>}Q*C-b%38R>IT+1tz5|x7EdS=Bd8(twXne_~Jvc9GvB5<}%)3kN{M#XcD
zhP6P~m}OhuxWL$8rcE!|0L={1qz%tV4$TQfE;@^544vrKu>oBIJsHb3uU1P7raNma
z6itENjFU5pbB1fl_uym1D_9kQGwlX%W}jr>MM4lb*RF#QdVx(BUDNO^$IciFW>H`{
zoQe|J6%$wao6KA{ZW@WAVdoQRr%EQtP-uVmq?=0)h1ObBRfSH*Ah1=(Hf$Hr^QJd#
zm#d!4u|RULZC@dZ8g>XAZ?n7#iR`f$c44=Met}2UQr58tdj&Qwsszj##VYIDIXIM#
zVLuLNh_j+?hFc3($3Ywth?4y!IR^s!*J18wSZ!d^9>rk|j|udzjk!`b9fKGW*dUX-
zsIX4QFpOgwjtcBv-%h#LF@gjQXegmfhpVs>L_v96#}hc=GnjEKTbZ@8QX6QtAE$Jj
z#u<Ul43y@qTefORfqgCMt9Fdx9FiJFTe46gbd2FVF)dmZ&#-f>*7;UV?n4Uot<Tb5
zly&YyN>2L3y2`OCCFvHP<aDH^a)?_3ds=K#3_0UDr^+<;hDVPARyJHyCV6)YA2JYU
zyxwPXrfV$;+zZohF`0EkDR)_?Sd~H%hyb69iAmQrmNU$2SO?nh*bva}td(cUt1fHv
z{r?YctVMQIhR6R4^cXU@s^Ln@@so+u@eF2IqnuP)b9G9mT&E;K@DR8hrtLS9Kj(h+
zRnAqqTh0{YCA;w)W;JA+#4Ed8@ywEr=fS?~R6Vub_i8zb8JDw~^$4)Ud3r%$$BOFl
zvt{QmRITEo=|=G)y;g!#FfI?}_-H(adAuwq;uV4IgR45#x8)%z6ZM*o*FiP!=9Fhl
zJMU57sGC#LI;Ue1tbUhKE}J$*YR}-*P{>gLf|@apyp94aj<x6bQ3SS8E!N`Z-Ww=s
z;L)~Ktu?dNVN1|jStg)p$54i=;SC-+Yh|&Gey&f5jtV%G8hOh4|DBA<^<)$`1qO;{
zJXbJFmK~p@PPy>~%e3PZ!#Ee}2`Al3FosmIP+R{Cj8Ycru7VZ}+F{LLQ>4nRMM~ip
z=xe^-ESKw7oD+UQntlGmJW9dxjNFYYMme}B=}QKix8f=NlCAWSj*sO`_4_k5<u6Mx
zjggAt6JEpu!<9zO;8Pu+$pd^F%X5Vnz*4m|>l!!B;;dETEp8rP$X@(XwqQEkPxTgz
z;;z7<wKbFFQg!1(5LzIXb*gU8oU-IaaBK4=ZbbGZ4)E&J$?Gr>;S;Zr{MGn2jt>3-
zT}OuRBl;tsIuPS;Onr@U=SKd4=aJe49h>;Z{n(5i`rxQyOW^A^qTCOR9I2sqH1ZIA
z*M^VQu=CiiNDcdjYZ$13OULEwN&bI;v-dIn11(m^?4j>1D&|SwTO;NOCUJqW7y%cN
zR)|LMB&Nu$ix&`yNV2<xr?@t){64K%{>JYT*~BpdIr;#XM<YMs*@u|F)_d(fUXp-b
ztzn^tr5diQH==d;ap`W)x8GqSH}_V#B=Zwd`RP;scJO&826&S@gMOs2cNOl52JQ*G
ziCYTy1eWoZ!abqTcGCVd-o`uh`YwIzja~0?*Zceuh4=$0jSVUAL5SC{0k2fR>%$dZ
zw*y{xYWRGG*BzhNoqU7VSL@I^Kv)M!>kz>Wutg59qLpgUN;PPu8njXkTBky^<gO-K
N<36o>q}hS5{{o4=>p=hj

diff --git a/be-graphes-algos/target/classes/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.class b/be-graphes-algos/target/classes/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.class
index 5bdcedf5f04a2ef5fe206ac130767792363fb1a7..2094a1d4c33d30005ccbcb08efc01edbdf3ac916 100644
GIT binary patch
delta 1124
zcmZvbdr;I>6vsd37t0TRyDVUfvWq|%=JFaOBrPaGAthOGgt4KdW?i=tWx$b@nVcH@
ztN!RQ+5NA7YjPTO26WpkK+7Ihq|y6r^zxBC&6@GA=&Ul(AN_I9z2}^JzUQ3px%YJa
zv*kIH|BM|6R&d$I5>}ZK_cGHUxufe>XQtb{DAcQ|_UWt)cP2?*ws}dYQB%O&@5?cV
z9eaU?F~$X_wf)YPrq0$iZ7pWlxy9=c=a>f<$Ay8QIpGbOeUfWVc?xDDGiu5<I|#3O
zIKe?7zkeXs`@n<E(ZN`6e>m1V(7!1fj%<%^b136=4-wul`!kDs-r^mbw}reN;h}K#
zo>*^R_1b~HzGx&BGU#EFcLjTQbSS!eFe+RhY@5H>);k!hFWa1I<+O+QQgz!M8@pOV
zO>H*s3juQ}H{du-@nNd;kIb}F=ZW)4O8HcH?0@?(kGqSGy0h}d)O!E+W_8BGk)5IN
zuCDObzNlI4TVe5w+2gBsaY-n@O5K#NRMN~}z6w{i0_U32ybkf1SYCsZc8(0(U{xO-
z%bSo!znx&@B;JYyn{*v|p4@Tb-4#bjB$?<Ajg+UX30^tC62I%}?F6sgT{U}p(>$?g
z(eTOHkW=GKb?f~KzbnZHNj?r$j_B~ya8yomvr50#6ToIM3n`?SB7&6A!i}_3N)Jof
z&Q0u8>t3D8qw3pF70<Dp1Jp387)fe5Mjc<Vk{?;cd4}t`!tDZgNIH#DK$DcvEM>Gv
z9qXil^%A00y0}a3WrN&DyA04FLu{0X>6AyPlc!iNhqy;3*dkN($QicESt4?QZE~5Y
zWfQTo*<tzUv#QvYVvr~Crg+3NOqQxHt6UA)`rvFU$Y*?x#X`%^7ktTe6k9o3@z=^l
zP{Gcq&81zhQ4Weo*S_6+!?ccOuVP(0jjCR#D_!Fb@-0i0wJVzRJGEtMqx<-tA8@qf
zwS!8;w7Sn~88>LMYiZBTr9D5F_JXGU36!Ip8Ez%RMr<l=;^v}%vBZrXC|Vh}DYLmv
zr9y6i86A^;)!B>lPIW9JbIxJ51d0{mp+Kd|7XroW{)0oojMhJ&Z63sC0c1HvInDY6
nE~d!S9+v8^<HS{-;AitpVL?8>s%r5Yzw4g*)Jgu}&qn{h3f==I

delta 2822
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
K`sj{c-@gD_Z<O%>

diff --git a/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/Launch.java b/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/Launch.java
index 46c7181..413fa94 100644
--- a/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/Launch.java
+++ b/be-graphes-gui/src/main/java/org/insa/graphs/gui/simple/Launch.java
@@ -76,6 +76,8 @@ public class Launch {
         // TODO: Draw the path.
         drawing.drawPath(path,Color.green);
 
+        
+
     }
 
 }
diff --git a/be-graphes-gui/target/classes/org/insa/graphs/gui/simple/Launch.class b/be-graphes-gui/target/classes/org/insa/graphs/gui/simple/Launch.class
index a6f0fb0655a370c27203fbaa24586fb6dc4a5a2a..1171ea4051c96fa7898994d565e2fdaf0f3d2fca 100644
GIT binary patch
delta 13
UcmeAY=@Qv6os%(e@(j)*03Z(pg#Z8m

delta 13
UcmeAY=@Qv6os-dj@(j)*03Zbfg8%>k