L3 Dunand Moreau

Sign in or create your account | Project List | Help

L3 Dunand Moreau Commit Details

Date:2010-01-20 01:15:42 (7 months 20 days ago)
Author:Aurélien Dunand
Commit:2c64037a3b8d75869af1bb36e4fa8d3cbec88f29
Message:Ajout de l'algorithme FIXME : Algo non fonctionnel (exception out of memory)
Files: src/controleur/AEtoile.java (2 diffs)
src/controleur/AEtoileCorrespondance.java (1 diff)
src/controleur/AEtoileDepart.java (1 diff)
src/controleur/AEtoileDuree.java (1 diff)
src/controleur/Controleur.java (1 diff)
src/modele/Segment.java (1 diff)

Change Details

src/controleur/AEtoile.java
55
66/**
77 * Classe qui gère l'algorithme A*
8 *
9 * @author Alexandre Moreau
810 */
911abstract class AEtoile
1012{
...... 
2527    private Requete requete;
2628
2729    /**
28     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
29     * l'algorithme
30     */
31    private ArrayList<Station> openList;
32
33    /**
34     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
35     * l'algorithme
36     */
37    private ArrayList<Station> closedList;
38
39    /**
4030     * Démarre l'algorithme
4131     */
4232    void lancement()
src/controleur/AEtoileCorrespondance.java
1package controleur;
2
3import java.util.ArrayList;
4import modele.Station;
5
6/**
7 * Sous classe spécifique pour l'utilisation de l'algorithme A* avec des
8 * correspondances
9 */
10class AEtoileCorrespondance extends AEtoile
11{
12    /**
13     * {@link controleur.Requete Requête} qui contient les informations
14     * nécessaires à l'algorithme
15     */
16    private Requete requete;
17
18    /**
19     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
20     * l'algorithme
21     */
22    private ArrayList<Station> openList;
23
24    /**
25     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
26     * l'algorithme
27     */
28    private ArrayList<Station> closedList;
29
30    /**
31     *
32     */
33    public AEtoileCorrespondance()
34    {
35
36    }
37
38    /**
39     * Démarre l'algorithme
40     */
41    @Override
42    void lancement()
43    {
44
45    }
46
47    /**
48     * Getter du {@link controleur.Trajet trajet}
49     *
50     * @return Trajet correspondant à la requête
51     */
52    public ArrayList<Trajet> getTrajet()
53    {
54        return this.listeTrajet;
55    }
56
57    /**
58     * Récupère le plus court chemin et l'ajoute au {@link controleur.Trajet
59     * trajet}
60     *
61     * @param stationActuelle Point de départ de la recherche du plus court
62     * chemin
63     * @param stationArrivee Point d'arrivée de la recherche du plus court
64     * chemin
65     */
66    private void plusCourtChemin(Station stationActuelle, Station stationArrivee)
67    {
68
69    }
70
71}
src/controleur/AEtoileDepart.java
1package controleur;
2
3import java.util.ArrayList;
4import java.util.TreeMap;
5import java.util.HashMap;
6import java.util.HashSet;
7import modele.Station;
8import modele.Segment;
9
10/**
11 * @author Alexandre Moreau
12 */
13class AEtoileDepart extends AEtoile
14{
15    private Requete requete;
16    private TreeMap<String, Station> listeStation;
17    private Station depart;
18    private Station arrive;
19    private int time;
20    private Trajet meilleurTrajet;
21    private HashMap<Integer, ContraintePosition> etape;
22
23    public AEtoileDepart(Requete requet, TreeMap<String, Station> station)
24    {
25        requete = requet;
26        listeStation = station;
27        depart = listeStation.get(requete.getDepart().getStation());
28        arrive = listeStation.get(requete.getArrivee().getStation());
29        etape = requete.getListeEtape();
30        lancement();
31    }
32
33    public void lancement()
34    {
35        if (etape.size()==0)
36        {
37            cheminPlusCourt(depart, arrive);
38        }
39        else
40        {
41            for (int i=1; i<=etape.size(); i++)
42            {
43                Station etape1 = listeStation.get(etape.get(i).getStation());
44                if (i==1)
45                {
46                    cheminPlusCourt(depart, etape1);
47                }
48                else
49                {
50                    Station etapeprecedente = meilleurTrajet.dernierSegment().getDestination();
51                    cheminPlusCourt(etapeprecedente, etape1);
52                }
53            }
54            Station etapeprecedente = meilleurTrajet.dernierSegment().getDestination();
55            cheminPlusCourt(etapeprecedente, arrive);
56        }
57    }
58
59    public TreeMap<Double, Segment> classement(Station d, Station a, HashSet<Segment> segmentvoisin)
60    {
61        TreeMap<Double,Segment> classementSegment = new TreeMap<Double,Segment>();
62        for(Segment segment: segmentvoisin)
63        {
64            if(segment.getDestination()!=d)
65            {
66                classementSegment.put(distance(segment.getDestination(),a),segment);
67            }
68        }
69        return classementSegment;
70    }
71
72    private void cheminPlusCourt(Station d, Station a)
73    {
74        int vitesse = 50;
75        int tempstrajet;
76        HashSet<Segment> segmentvoisin = d.getDestinations();
77        TreeMap<Double,Segment> classementSegment = classement(d,a, segmentvoisin);
78        Segment voisin = classementSegment.get(classementSegment.firstKey());
79        tempstrajet = (int) (distance(d,voisin.getDestination())/(vitesse*60));
80        tempstrajet += attente(time);
81        meilleurTrajet = new Trajet(voisin,tempstrajet);
82        while(voisin.getDestination()!=a)
83        {
84            int corres=0;
85            classementSegment.clear();
86            segmentvoisin = meilleurTrajet.dernierSegment().getDestination().getDestinations();
87            classementSegment = classement(d,a, segmentvoisin);
88            voisin = classementSegment.get(classementSegment.firstKey());
89            tempstrajet = (int) (distance(d,voisin.getDestination())/(vitesse*60));
90            if(voisin.getNumero()!=meilleurTrajet.dernierSegment().getNumero())
91                {
92                if(voisin.getSens() != meilleurTrajet.dernierSegment().getSens())
93                {
94                    tempstrajet += attente(time);
95                    corres=1;
96                }
97                }
98            meilleurTrajet.addChemin(voisin,tempstrajet,corres);
99        }
100    }
101
102
103    private int attente(int heure)
104    {
105        if((heure>390 && heure<570) || (heure>720 && heure<840) || (heure>1050 && heure<1170))
106        {
107            return 3;
108        }
109        else
110        {
111            return 7;
112        }
113    }
114
115    private double distance(Station a, Station b)
116    {
117        double constante = Math.PI / 180;
118        double latitudeA = a.getLatitude() * constante;
119        double longitudeA = a.getLongitude() * constante;
120        double latitudeB = b.getLatitude() * constante;
121        double longitudeB = b.getLongitude() * constante;
122
123        double t1 = Math.sin(latitudeA) * Math.sin(latitudeB);
124          double t2 = Math.cos(latitudeA) * Math.cos(latitudeB);
125          double t3 = Math.cos(longitudeA - longitudeB);
126          double t4 = t2 * t3;
127          double t5 = t1 + t4;
128          double rad_dist = Math.atan(-t5/Math.sqrt(-t5 * t5 +1)) + 2 * Math.atan(1);
129
130          return (rad_dist * 3437.74677 * 1.1508) * 1.6093470878864446;
131    }
132
133}
src/controleur/AEtoileDuree.java
1package controleur;
2
3import java.util.ArrayList;
4import modele.Station;
5
6/**
7 * Sous classe spécifique pour l'utilisation de l'algorithme A* avec des durées
8 */
9class AEtoileDuree extends AEtoile
10{
11    /**
12     * {@link controleur.Requete Requête} qui contient les informations
13     * nécessaires à l'algorithme
14     */
15    private Requete requete;
16
17    /**
18     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
19     * l'algorithme
20     */
21    private ArrayList<Station> openList;
22
23    /**
24     * Liste de {@link modele.Station stations} nécessaire au fonctionnement de
25     * l'algorithme
26     */
27    private ArrayList<Station> closedList;
28
29    /**
30     *
31     */
32    public AEtoileDuree()
33    {
34
35    }
36
37    /**
38     * Démarre l'algorithme
39     */
40    @Override
41    void lancement()
42    {
43
44    }
45
46    /**
47     * Getter du {@link controleur.Trajet trajet}
48     *
49     * @return Trajet correspondant à la requête
50     */
51    public ArrayList<Trajet> getTrajet()
52    {
53        return this.listeTrajet;
54    }
55
56    /**
57     * Récupère le plus court chemin et l'ajoute au {@link controleur.Trajet
58     * trajet}
59     *
60     * @param stationActuelle Point de départ de la recherche du plus court
61     * chemin
62     * @param stationArrivee Point d'arrivée de la recherche du plus court
63     * chemin
64     */
65    private void plusCourtChemin(Station stationActuelle, Station stationArrivee)
66    {
67
68    }
69
70}
src/controleur/Controleur.java
283283     */
284284    public void initialiserAlgorithme(Requete requete)
285285    {
286
286        algo = new AEtoileDepart(requete,listeStation);
287287    }
288288
289289    /**
src/modele/Segment.java
6262     * @return {@link modele.Station Station} de destination associé à ce
6363     * segment
6464     */
65    public final Station getCoupleStation()
65    public final Station getDestination()
6666    {
6767        return this.destination;
6868    }

Archive Download the corresponding diff file

Branches:
master