Browse Source

On branch master

Jdihadi Ahamdy 3 years ago
parent
commit
46722fd591

+ 153
- 22
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/shortestpath/DijkstraAlgorithm.java View File

@@ -1,15 +1,17 @@
1 1
 package org.insa.graphs.algorithm.shortestpath;
2
-
3
-import java.util.ArrayList;
4
-import java.util.Arrays;
5 2
 import java.util.Collections;
6
-import java.util.Iterator;
3
+import java.util.List;
4
+import java.util.ArrayList;
7 5
 
6
+import org.insa.graphs.algorithm.AbstractInputData;
7
+import org.insa.graphs.algorithm.AbstractSolution.Status;
8
+import org.insa.graphs.algorithm.utils.BinaryHeap;
9
+import org.insa.graphs.algorithm.utils.Label;
8 10
 import org.insa.graphs.model.Arc;
9 11
 import org.insa.graphs.model.Graph;
10
-import org.insa.algo.AbstractSolution.Status;
11
-import org.insa.algo.utils.*;
12
-import org.insa.graph.*;
12
+import org.insa.graphs.model.Node;
13
+import org.insa.graphs.model.Path;
14
+
13 15
 
14 16
 public class DijkstraAlgorithm extends ShortestPathAlgorithm {
15 17
 
@@ -19,29 +21,158 @@ public class DijkstraAlgorithm extends ShortestPathAlgorithm {
19 21
 
20 22
     @Override
21 23
     protected ShortestPathSolution doRun() {
22
-        ShortestPathSolution solution = null;
23
-        
24
-        			// Initialisation
25
-    	// du graphe
26
-    	final ShortestPathData data = getInputData();
24
+    	
25
+    	// Récupération des différentes données du graph
26
+    	
27
+        ShortestPathData data = getInputData();
27 28
         Graph graph = data.getGraph();
29
+        List<Node> nodes = graph.getNodes();
28 30
         final int nbNodes = graph.size();
29
-        // des couts 
30
-        double[] distances = new double[nbNodes];
31
-        Arrays.fill(distances, Double.POSITIVE_INFINITY);
32
-        distances[data.getOrigin().getId()] = 0;
33 31
         
34
-        // Notify observers about the first event (origin processed).
32
+        //On récupère l'index du node origine du chemin à déterminer
33
+        int index_origine = data.getOrigin().getId();
34
+        //On récupère l'index du node destination
35
+        int index_dest = data.getDestination().getId();
36
+        
35 37
         notifyOriginProcessed(data.getOrigin());
38
+
39
+        /////////////////////////////////////////////////////////////////////////////////////////////////
40
+        //////////////////////////////////////INITIALISATION/////////////////////////////////////////////
41
+        /////////////////////////////////////////////////////////////////////////////////////////////////
42
+        BinaryHeap<Label> tas = new BinaryHeap<Label>();
43
+        ArrayList<Label> labels = new ArrayList<Label>();
44
+        //On initialise tous les labels à +infini, avec marque à false et pere à NULL
45
+        for (int i = 0; i < nbNodes; i++) {
46
+        	labels.add(new Label(nodes.get(i)));
47
+        }
48
+        //On actualise le cout du label correspondant au node d'origine
49
+        labels.get(index_origine).setCost(0);
50
+        //On insère le label actualisé dans le tas
51
+        tas.insert(labels.get(index_origine));
52
+		/////////////////////////////////////////////////////////////////////////////////////////////////
53
+		//////////////////////////////////////INITIALISATION/////////////////////////////////////////////
54
+		/////////////////////////////////////////////////////////////////////////////////////////////////
36 55
         
37
-        // Initialize array of predecessors.
38
-        Arc[] predecessorArcs = new Arc[nbNodes];
56
+		/////////////////////////////////////////////////////////////////////////////////////////////////
57
+		/////////////////////////////////////////ITERATIONS//////////////////////////////////////////////
58
+		/////////////////////////////////////////////////////////////////////////////////////////////////
39 59
         
40
-
41
-        while (solution == null) { //Tant qu'il y a pas de solution 
60
+        //Définition d'une variable pour compter le nombre d'itérations pour le debogage
61
+        int nbIterations = 0;
62
+        
63
+        while (!labels.get(index_dest).isMarked() && tas.size() != 0) {
64
+        	//On récupère le label minimal dans le tas
65
+        	Label label_min = tas.deleteMin();
66
+        	//On marque le label minimal
67
+        	labels.get(label_min.getNode().getId()).mark();
68
+        	
69
+        	//Vérification du coût croissant des labels marqués
70
+        	System.out.println("Coût du label marqué : " + label_min.getCost());
71
+        	//Vérification de la taille du tas
72
+        	System.out.println("Taille du tas : " + tas.size());
73
+        	
74
+        	//Debogage
75
+        	//Incrémentation du nombre d'itérations
76
+        	nbIterations++;
77
+        	//Verification du tas
78
+        	if (tas.isValid()) {
79
+        		System.out.println("Tas valide");
80
+        	}
81
+        	else {
82
+        		System.out.println("Tas non valide");
83
+        	}
42 84
         	
85
+        	
86
+        	//On récupère les arcs successeurs du label minimal
87
+        	List<Arc> arcs = label_min.getNode().getSuccessors();
88
+        	
89
+        	//Debogage
90
+        	System.out.println("Nb successeurs du label : " + arcs.size());
91
+        	
92
+        	for (int i = 0; i < arcs.size(); i++) {
93
+        		//On vérifie que le chemin est autorisé
94
+                if (!data.isAllowed(arcs.get(i))) {
95
+                    continue;
96
+                }
97
+                //On récupère l'index de la destination de l'arc actuel
98
+        		int index_suiv = arcs.get(i).getDestination().getId();
99
+        		
100
+        		if (!labels.get(index_suiv).isMarked())
101
+        		{
102
+        			double oldDistance = labels.get(index_suiv).getCost();
103
+        			double newDistance = label_min.getCost() + data.getCost(arcs.get(i));
104
+        			
105
+        			//Coloration des chemins au fur et à mesure
106
+        			if (Double.isInfinite(oldDistance) && Double.isFinite(newDistance)) {
107
+                        notifyNodeReached(arcs.get(i).getDestination());
108
+                    }
109
+        			
110
+        			if (newDistance < oldDistance) {
111
+        				labels.get(index_suiv).setCost(newDistance);
112
+        				labels.get(index_suiv).setFather(arcs.get(i));
113
+        				if (Double.isFinite(oldDistance)) {
114
+        					tas.remove(labels.get(index_suiv));
115
+        				}
116
+        				tas.insert(labels.get(index_suiv));
117
+        			}
118
+        		}
119
+        	}
120
+        }
121
+		/////////////////////////////////////////////////////////////////////////////////////////////////
122
+		/////////////////////////////////////////ITERATIONS//////////////////////////////////////////////
123
+		/////////////////////////////////////////////////////////////////////////////////////////////////
124
+        
125
+        /////////////////////////////////////////////////////////////////////////////////////////////////
126
+        //////////////////////////////////CREATION DE LA SOLUTION////////////////////////////////////////
127
+        /////////////////////////////////////////////////////////////////////////////////////////////////
128
+        ShortestPathSolution solution = null;
129
+        
130
+        //La destination n'a pas de prédécesseur, le chemin est infaisable
131
+        if (!labels.get(index_dest).isMarked()) {
132
+            solution = new ShortestPathSolution(data, Status.INFEASIBLE);
133
+        }
134
+        else {
135
+
136
+            //La destination a été trouvée. On en informe l'utilisateur.
137
+            notifyDestinationReached(data.getDestination());
138
+
139
+            //On crée un nouveau chemin à partir des prédécesseurs
140
+            ArrayList<Arc> chemin = new ArrayList<>();
141
+            Arc arc = labels.get(index_dest).getFather();
142
+            while (arc != null) {
143
+                chemin.add(arc);
144
+                arc = labels.get(arc.getOrigin().getId()).getFather();
145
+            }
146
+            
147
+            //Affichages pour le debogage
148
+            System.out.println("Nombre d'itérations : " + nbIterations);
149
+            System.out.println("Nombre d'arcs dans le plus court chemin : " + chemin.size());
150
+            
151
+            //On inverse ce chemin
152
+            Collections.reverse(chemin);
153
+
154
+            //On crée la solution finale
155
+            solution = new ShortestPathSolution(data, Status.OPTIMAL, new Path(graph, chemin));
156
+            
157
+            //Debogage
158
+            if (!solution.getPath().isValid()) {
159
+            	System.out.println("Chemin trouvé non valide.");
160
+            }
161
+            else {
162
+            	System.out.println("Chemin trouvé valide.");
163
+            }
164
+            if (data.getMode() == AbstractInputData.Mode.TIME) {
165
+            	System.out.println("Durée chemin Path : " + solution.getPath().getMinimumTravelTime() + ", Dijkstra : " + labels.get(index_dest).getCost());
166
+            }
167
+            else {
168
+            	System.out.println("Longueur chemin Path : " + solution.getPath().getLength() + ", Dijkstra : " + labels.get(index_dest).getCost());
169
+            }
170
+            
43 171
         }
44
-        // TODO:
172
+		/////////////////////////////////////////////////////////////////////////////////////////////////
173
+		//////////////////////////////////CREATION DE LA SOLUTION////////////////////////////////////////
174
+		/////////////////////////////////////////////////////////////////////////////////////////////////
175
+
45 176
         return solution;
46 177
     }
47 178
 

+ 44
- 21
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/utils/BinaryHeap.java View File

@@ -138,25 +138,30 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
138 138
     @Override
139 139
     public void remove(E x) throws ElementNotFoundException {
140 140
     	int index;
141
-    	int lastindex;
142
-    	E lastItem;
143
-    	if(this.isEmpty())
144
-    		throw new ElementNotFoundException(x);
145
-    	else {
146
-    		index = this.array.indexOf(x);
147
-    		if(index == -1 || index >= this.currentSize) {
148
-    			throw new ElementNotFoundException(x);
149
-    		}
150
-    		else {
151
-    			lastindex=--this.currentSize;
152
-	    		lastItem = this.array.get(lastindex);
153
-	    		this.array.set(index, lastItem);
154
-	    		this.percolateDown(index);
155
-	    		this.percolateUp(index);
156
-    			}
157
-    		}
158
-    	}   
159
-    
141
+    	int indexLast;
142
+    	E lastElement;   	
143
+        if (this.isEmpty())
144
+            throw new ElementNotFoundException(x);
145
+        else {
146
+        	index = this.array.indexOf(x);
147
+        	/* Si on n'a pas trouve l'element, on souleve une exception */
148
+        	if (index == -1 || index >= this.currentSize) {
149
+        		throw new ElementNotFoundException(x);
150
+        	}
151
+        	/* Si l'element a ete trouve, on le supprime */
152
+        	else {
153
+        		indexLast=--this.currentSize;
154
+        		/* Si l'element supprime n'etait pas le dernier */
155
+        		if (indexLast>index) {
156
+	        		lastElement = this.array.get(indexLast);
157
+	        		this.array.set(index, lastElement);
158
+	        		this.percolateDown(index);
159
+	        		this.percolateUp(index);	        		
160
+        		}
161
+        	}
162
+        	
163
+        }
164
+    }
160 165
 
161 166
     @Override
162 167
     public E findMin() throws EmptyPriorityQueueException {
@@ -172,8 +177,7 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
172 177
         this.arraySet(0, lastItem);
173 178
         this.percolateDown(0);
174 179
         return minItem;
175
-    }
176
-
180
+    }    
177 181
     /**
178 182
      * Creates a multi-lines string representing a sorted view of this binary heap.
179 183
      * 
@@ -219,5 +223,24 @@ public class BinaryHeap<E extends Comparable<E>> implements PriorityQueue<E> {
219 223
     public String toString() {
220 224
         return BinaryHeapFormatter.toStringTree(this, 8);
221 225
     }
226
+    
227
+    public boolean isValid() {
228
+        boolean valide = true;
229
+        for (int i = 0; i < this.currentSize && valide; i++) {
230
+            if (this.indexLeft(i) <= this.currentSize) {
231
+                if (this.array.get(this.indexLeft(i)).compareTo(this.array.get(i)) == -1) {
232
+                    valide = false;
233
+                }
234
+                else {
235
+                    if (this.indexLeft(i) + 1 < this.currentSize) {
236
+                        if (this.array.get(this.indexLeft(i) + 1).compareTo(this.array.get(i)) == -1) {
237
+                            valide = false;
238
+                        }
239
+                    }
240
+                }
241
+            }
242
+        }
243
+        return valide;
244
+    }
222 245
 
223 246
 }

+ 49
- 19
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/utils/Label.java View File

@@ -1,38 +1,68 @@
1 1
 package org.insa.graphs.algorithm.utils;
2 2
 
3
+
4
+import org.insa.graphs.model.Arc;
3 5
 import org.insa.graphs.model.Node;
4 6
 
5
-public class Label {
7
+public class Label  implements Comparable<Label> {
8
+	private Node sommet_courant;
9
+	private boolean marque;
10
+	protected double cout;
11
+	private Arc pere;
6 12
 	
7
-	private boolean mark;
8
-	private int cost;
9
-	private Node father;
10
-	private Node nodes;
13
+	public Label(Node sommet_courant) {
14
+		this.sommet_courant = sommet_courant;
15
+		marque = false;
16
+		cout = Double.POSITIVE_INFINITY;
17
+		pere = null;
18
+	}
11 19
 	
12
-	public Label(Node noeud) {
13
-		this.nodes=noeud;
14
-		this.mark=false;
15
-		this.cost=100000;
16
-		this.father=null;
20
+	public double getCost() {
21
+		return this.cout;
17 22
 	}
18
-		
19
-	public int getCost() {
20
-		return this.cost;
23
+	
24
+	public double getTotalCost() {
25
+		return this.getCost();
21 26
 	}
22 27
 	
23
-	public boolean getMark() {
24
-		return this.mark;
28
+	public Node getNode() {
29
+		return this.sommet_courant;
25 30
 	}
26 31
 	
27
-	public Node getfather() {
28
-		return this.father;
32
+	public Arc getFather() {
33
+		return this.pere;
29 34
 	}
30 35
 	
31
-	public boolean setMark() {
32
-		return this.mark=true;
36
+	public boolean isMarked() {
37
+		return marque;
33 38
 	}
34 39
 	
40
+	public void setFather(Arc pere) {
41
+		
42
+		this.pere = pere;
43
+	}
35 44
 	
45
+	public void mark() {
46
+		this.marque = true;
47
+	}
36 48
 	
49
+	public void setCost(double cout) {
50
+		this.cout = cout;
51
+	}
37 52
 	
53
+	/* Compare les Labels selon leur coût */
54
+	public int compareTo(Label autre) {
55
+		int resultat;
56
+		if (this.getTotalCost() < autre.getTotalCost()) {
57
+			resultat = -1;
58
+		}
59
+		else if (this.getTotalCost() == autre.getTotalCost()) {
60
+			resultat = 0;
61
+		}
62
+		else {
63
+			resultat = 1;
64
+		}
65
+		return resultat;
66
+	}
38 67
 }
68
+

+ 29
- 0
be-graphes-algos/src/main/java/org/insa/graphs/algorithm/utils/LabelStar.java View File

@@ -0,0 +1,29 @@
1
+package org.insa.graphs.algorithm.utils;
2
+
3
+import org.insa.graphs.model.Node;
4
+import org.insa.graphs.model.Point;
5
+import org.insa.graphs.algorithm.AbstractInputData;
6
+import org.insa.graphs.algorithm.shortestpath.ShortestPathData;
7
+
8
+public class LabelStar extends Label {
9
+	private float inf;
10
+	
11
+	public LabelStar(Node sommet_courant, Node node_dest, ShortestPathData data) {
12
+		super(sommet_courant);	
13
+
14
+		if (data.getMode() == AbstractInputData.Mode.LENGTH) {
15
+			this.inf = (float)Point.distance(sommet_courant.getPoint(),data.getDestination().getPoint());
16
+		}
17
+		else {
18
+			int vitesse = Math.max(data.getMaximumSpeed(), data.getGraph().getGraphInformation().getMaximumSpeed());
19
+			this.inf = (float)Point.distance(sommet_courant.getPoint(),data.getDestination().getPoint())/(vitesse*1000.0f/3600.0f);
20
+		}
21
+	}
22
+
23
+	/* Renvoie le coût de l'origine jusqu'au noeud + coût à vol d'oiseau du noeud jusqu'à la destination */
24
+	public double getTotalCost() {
25
+		return this.inf+this.cout;
26
+	}
27
+
28
+
29
+}

+ 89
- 49
be-graphes-model/src/main/java/org/insa/graphs/model/Path.java View File

@@ -30,36 +30,56 @@ public class Path {
30 30
      * @throws IllegalArgumentException If the list of nodes is not valid, i.e. two
31 31
      *         consecutive nodes in the list are not connected in the graph.
32 32
      * 
33
-     * @deprecated Need to be implemented.
33
+     *  Need to be implemented.
34 34
      */
35 35
     public static Path createFastestPathFromNodes(Graph graph, List<Node> nodes)
36 36
             throws IllegalArgumentException {
37 37
         List<Arc> arcs = new ArrayList<Arc>();
38
-        if(nodes.size()==1) {
38
+        
39
+        
40
+        if (nodes.size() > 1) {
41
+        
42
+	        for (int num_node = 0; num_node < nodes.size()-1; num_node++) {
43
+	        	
44
+	        	//On recupere les arcs partant du node actuel
45
+	        	List<Arc> successeurs = nodes.get(num_node).getSuccessors();
46
+	        	
47
+	        	//On definit un booleen pour determiner si on a deja trouve un arc entre les deux nodes
48
+	        	boolean arc_trouve = false;
49
+	        	
50
+	        	for (int num_arc = 0; num_arc < successeurs.size(); num_arc++) {
51
+	        		
52
+	        		//On verifie que l'arc partant du node actuel arrive au suivant
53
+	        		if (successeurs.get(num_arc).getDestination().compareTo(nodes.get(num_node+1)) == 0) {
54
+	        			
55
+	        			//Si cet arc arrive au node suivant, si aucun arc n'a encore ete trouve, on le choisit
56
+	        			if (!arc_trouve) {
57
+	        				arcs.add(successeurs.get(num_arc));
58
+	        				arc_trouve = true;
59
+	        			}
60
+	        			//Si un autre arc a deja ete trouve, on le remplace si la temps de trajet du nouvel arc est plus court
61
+	        			else if (arcs.get(num_node).getMinimumTravelTime() > successeurs.get(num_arc).getMinimumTravelTime())
62
+	        			{
63
+	        				arcs.set(num_node, successeurs.get(num_arc));
64
+	        			}
65
+	        		}
66
+	        	}
67
+	        	
68
+	        	//Si, en ayant parcouru tous les successeurs, on ne trouve pas le node suivant, on renvoie une exception
69
+	        	if (!arc_trouve) {
70
+	        		throw(new IllegalArgumentException());
71
+	        	}
72
+	        }
73
+        }
74
+        //Si le path passé en argument ne contient qu'un ou aucun node,
75
+        //on ne peut créer de path avec des arcs
76
+        else if (nodes.size() == 1){
39 77
         	return new Path(graph, nodes.get(0));
40 78
         }
41
-        for(int i=0; i<nodes.size()-1; i++) { // Parcours des noeuds dans l'orde 
42
-        	Node node_actuel= nodes.get(i);
43
-        	if(node_actuel.hasSuccessors()) { // Véridie si le noeud a une succeseur
44
-        		List<Arc> arc_suiv = node_actuel.getSuccessors();
45
-        		double travel_time = 10000000;
46
-        		int num=0;
47
-        		boolean successor_found = false ;
48
-        		for(int j=0; j<arc_suiv.size();j++) {
49
-        			if((arc_suiv.get(j).getDestination().compareTo(nodes.get(i+1)) == 0 ) && (arc_suiv.get(j).getMinimumTravelTime()< travel_time)) {
50
-        				num=j;
51
-        				travel_time=arc_suiv.get(num).getMinimumTravelTime();
52
-        				successor_found = true;
53
-        			}	
54
-        		}
55
-        		if(successor_found== false) {
56
-        			throw new IllegalArgumentException();
57
-        		}
58
-        		arcs.add(arc_suiv.get(num));
59
-        	}else {
60
-        		throw new IllegalArgumentException();
61
-        	}
79
+        else {
80
+        	return new Path(graph);
62 81
         }
82
+        
63 83
         return new Path(graph, arcs);
64 84
     }
65 85
 
@@ -75,36 +95,56 @@ public class Path {
75 95
      * @throws IllegalArgumentException If the list of nodes is not valid, i.e. two
76 96
      *         consecutive nodes in the list are not connected in the graph.
77 97
      * 
78
-     * @deprecated Need to be implemented.
98
+     *  Need to be implemented.
79 99
      */
80 100
     public static Path createShortestPathFromNodes(Graph graph, List<Node> nodes)
81 101
             throws IllegalArgumentException {
82 102
         List<Arc> arcs = new ArrayList<Arc>();  
83
-        if(nodes.size()==1) {
103
+        
104
+        
105
+        if (nodes.size() > 1) {
106
+            
107
+	        for (int num_node = 0; num_node < nodes.size()-1; num_node++) {
108
+	        	
109
+	        	//On recupere les arcs partant du node actuel
110
+	        	List<Arc> successeurs = nodes.get(num_node).getSuccessors();
111
+	        	
112
+	        	//On definit un booleen pour determiner si on a deja trouve un arc entre les deux nodes
113
+	        	boolean arc_trouve = false;
114
+	        	
115
+	        	for (int num_arc = 0; num_arc < successeurs.size(); num_arc++) {
116
+	        		
117
+	        		//On verifie que l'arc partant du node actuel arrive au suivant
118
+	        		if (successeurs.get(num_arc).getDestination().compareTo(nodes.get(num_node+1)) == 0) {
119
+	        			
120
+	        			//Si cet arc arrive au node suivant, si aucun arc n'a encore ete trouve, on le choisit
121
+	        			if (!arc_trouve) {
122
+	        				arcs.add(successeurs.get(num_arc));
123
+	        				arc_trouve = true;
124
+	        			}
125
+	        			//Si un autre arc a deja ete trouve, on le remplace si la distance du nouvel arc est plus courte
126
+	        			else if (arcs.get(num_node).getLength() > successeurs.get(num_arc).getLength())
127
+	        			{
128
+	        				arcs.set(num_node, successeurs.get(num_arc));
129
+	        			}
130
+	        		}
131
+	        	}
132
+	        	
133
+	        	//Si, en ayant parcouru tous les successeurs, on ne trouve pas le node suivant, on renvoie une exception
134
+	        	if (!arc_trouve) {
135
+	        		throw(new IllegalArgumentException());
136
+	        	}
137
+	        }
138
+        }
139
+        //Si le path passé en argument ne contient qu'un ou aucun node,
140
+        //on ne peut créer de path avec des arcs
141
+        else if (nodes.size() == 1){
84 142
         	return new Path(graph, nodes.get(0));
85 143
         }
86
-        for(int i=0; i<nodes.size()-1; i++) { // Parcours des noeuds dans l'orde 
87
-        	Node node_actuel= nodes.get(i);
88
-        	if(node_actuel.hasSuccessors()) { // Véridie si le noeud a une succeseur
89
-        		List<Arc> arc_suiv = node_actuel.getSuccessors();
90
-        		int num=0;
91
-        		double length = 1000000;
92
-        		boolean successor_found = false ;
93
-        		for(int j=0; j<arc_suiv.size();j++) {
94
-        			if((arc_suiv.get(j).getDestination().compareTo(nodes.get(i+1)) == 0) && (arc_suiv.get(j).getLength() < length)) {
95
-                        num = j;
96
-                        length = arc_suiv.get(num).getLength();
97
-                        successor_found = true;
98
-                    }	
99
-        		}
100
-        		if(successor_found== false) {
101
-        			throw new IllegalArgumentException();
102
-        		}
103
-        		arcs.add(arc_suiv.get(num));
104
-        	}else {
105
-        		throw new IllegalArgumentException();
106
-        	}
144
+        else {
145
+        	return new Path(graph);
107 146
         }
147
+        
108 148
         return new Path(graph, arcs);
109 149
     }
110 150
 
@@ -246,7 +286,7 @@ public class Path {
246 286
      * 
247 287
      * @return true if the path is valid, false otherwise.
248 288
      * 
249
-     * @deprecated Need to be implemented.
289
+     *  Need to be implemented.
250 290
      */
251 291
     public boolean isValid() {
252 292
     	   if (this.isEmpty()) {
@@ -292,7 +332,7 @@ public class Path {
292 332
      * @return Time (in seconds) required to travel this path at the given speed (in
293 333
      *         kilometers-per-hour).
294 334
      * 
295
-     * @deprecated Need to be implemented.
335
+     *  Need to be implemented.
296 336
      */
297 337
     public double getTravelTime(double speed) {
298 338
         double temps = 0.0;
@@ -307,7 +347,7 @@ public class Path {
307 347
      * 
308 348
      * @return Minimum travel time to travel this path (in seconds).
309 349
      * 
310
-     * @deprecated Need to be implemented.
350
+     *  Need to be implemented.
311 351
      */
312 352
     public double getMinimumTravelTime() {
313 353
         double temps = 0;

Loading…
Cancel
Save