Pages

samedi 28 janvier 2012

Mini projet en programmation java : simulation du trafic routier


Pour la réalisation du programme, nous avons décomposé le problème en deux parties, qui ne sont pas entièrement indépendantes l’une de l’autre. La première partie concerne la création d’un réseau routier et la seconde partie concerne le mécanisme de simulation.

Au départ nous avons été lancé au vif du sujet, à établir des spécifications, diagrammes de cas d’utilisation, de classes, d’objets.



Nous nous sommes vite rendu compte que le travail effectué concernait essentiellement un aspect « créatif », à savoir comment gérer la création d’un feu ou bien d’une route, quelle objet dépendait d’un autre, ou bien héritait t-il d’un autre, ou encore aurait il un rôle qui se rapproche du comportement d’un « thread » ? Puis petit à petit, on a commencé à analyser l’aspect simulation du trafic routier, et nous avons détaché les contraintes du système et analyser comment nous allions gérer la simulation.

Nous détaillons donc dans une première partie la façon dont le programme va réagir face aux actions de l’utilisateur, quelle type d’interface va être mis en place et comment se comportera le programme.


Enfin, dans une dernière partie nous analyserons le mode simulation : la gestion des objets avec leur environnement, les choix effectués, la gestion des comportements et les scénarios possibles.

2. Cahier de charge :


Pour le programme que nous réalisons, le langage de programmation retenu est JAVA. La conception est bien entendu orientée objet, et à pour vocation à nous faire développer un programme en passant par les étapes nécessaires de la conception logicielle. Il s’agit d’un simulateur de trafic routier. Une intersection entre deux route est crée par le programme. L’utilisateur pourra y placer des véhicules et  ajouter les feux dans les intersections. De plus, des paramètres seront réglables tels que la durée concernant les feux, les comportements des véhicules sur la route, aux feux, et ainsi de suite.
Pour développer ce programme nous allons utiliser Eclipse.



3. Partie Analyse :                                                              
3.1. Diagramme de classe:
Le diagramme de classe est un élément important dans une démarche de conception orientée objet. Il représente les différentes entités intervenant dans le système.   En identifiant les concepts importants de l'application,  nous avons réalisé un  diagramme de classes pour représenter ces concepts et leurs associations. 


Classe Feu :
Ø La classe Feu hérite de la classe Thread elle aussi, et contient des attributs caractérisant un Feu (le numéro, la couleur et les coordonnées), et le constructeur bien évidemment pour pouvoir créer des objets de la classe.
Ø Les getters pour retourner les attributs.
Ø Les setters pour modifier les attributs.
Ø La redéfinition de la méthode run() qui permet d’alterner les couleurs du feu après une certaine durée.
Classe Vehicule :
Ø Cette classe hérite de la classe Thread, et contient des attributs caractérisant un véhicule, un constructeur d’initialisation des attributs qui sert à la construction d’objets de classe.
Ø Les getters dans la classe servent à retourner les valeurs des attributs de la classe.
Ø Les setters de la classe c’est pour modifier les attributs..
Ø La méthode move() qui retourne void sert à faire avancer le véhicule.
Ø La méthode isRoule() retourne un booléen montrant l’état du véhicule(le véhicule roule ou en état d’arrêt).
Ø La redéfinition de la méthode run() qui permet de faire avancer le véhicule selon l’état voulu.

Classe  Route :
Ø La classe Route contient un vecteur de Feu et un autre de véhicule puisqu’une route possède des feux et des véhicules.
Ø Cette classe contient des attributs servant à la caractérisation d’une route à savoir des véhicules représentés par un vecteur et des feux aussi par des vecteurs, un numéro et un nom.
Ø Les getters servent à retourner les différents attributs.
Ø
La méthode addFeu sert à ajouter un feu qu’elle prend en argument.
Ø La méthode addVehicule sert à ajouter un véhicule qu’elle prend en argument.
Classe Fenetre:
Ø La classe Fenêtre hérite de la classe JFrame, et contient un constructeur qui sert à déterminer les paramètres de la fenêtre à savoir le titre, la taille, et le conteneur qui est bien évidemment un objet de Panneau.
Ø Cette classe est aussi composée de feux, véhicules, et un panneau.
Ø La méthode go ne retourne rien, et sert à créer des feux, et des véhicules, et de les ajouter à une route.
Classe Panneau :
Ø La classe Panneau hérite de la classe JPanel, et sert à remplir l’interface graphique puisqu’elle hérite de JPanel (ses objets servent de conteneurs).
Ø La méthode paintComponent ne retourne rien, et sert à dessiner les composants de l’interface à savoir les formes et les couleurs.
Ø La classe panneau contient des vecteurs de Véhicule et Feu puisqu’elle est associée à la classe Thread qui est la classe mère  de Véhicule et Feu.
Ø La méthode setFeu ne retourne rien, et sert à modifier le vecteur Feu.
Ø La méthode setVéhicule ne retourne rien aussi, et sert à modifier le vecteur Véhicule.
3.2. Diagramme de cas d’utilisation:

Les diagrammes de cas d'utilisation sont des diagrammes UML utilisés pour donner une vision globale du comportement fonctionnel d'un système logiciel. Ils sont utiles pour des présentations auprès de la direction ou des acteurs d'un projet, mais pour le développement, les cas d'utilisation sont plus appropriés. Un cas d'utilisation représente une unité discrète d'interaction entre un utilisateur (humain ou machine) et un système.
3.3. Diagramme de séquence :
Le diagrammes de séquence est la représentation graphique des interactions entre les acteurs et le système selon un ordre chronologique.
Pour notre cas l’application suit l’ordre suivant :
Ø L’instanciation des objets de type route, feu, véhicule et panneau.
Ø Dessiner les formes graphiques présentant ces objets.
Ø  Déplacer les véhicules en respectant la couleur du feu.
Ø Changer les couleurs de feu après une durée bien déterminée.

3.4. Diagramme d’objet:
Un diagramme d’objets représente des objets (instances de classes) et leurs liens (instances de relations) pour donner une vue figée de l’état d’un système à un instant donné.
Ø une route peut contenir plusieurs instances de Feu et Véhicules :












4. Partie pratique :
   4.1. Les interfaces graphiques :
Les paquetages javax.swing  et java.awt contient les classes utilisées pour construire une interface  graphique.
Nous utilisons ici les composants les plus communs d'une interface :

javax.swing.JFrame : la classe javax.swing.JFrame modélise une fenêtre qui peut surgir à l'écran. Elle peut avoir un titre, elle peut posséder une barre de menu, c'est facultatif, elle possède toujours ce qu'on appelle un containeur.
javax.swing.JPanel : la classe javax.swing.JPanel modélise un composant destiné à contenir d'autres composants ou bien à faire des tracés (dessins, images, chaînes de caractères...). Il sera mieux, dans une même instance de JPanel d'à la fois mettre des sous-composants et à la fois faire des tracés.
java.awt.Graphics :  la classe  java.awt.Graphics contient des méthodes permettant de dessiner du texte ou des formes sur un composant graphique comme une Applet ou, dans notre cas, un javax.swing.JPanel.
 java.awt.Color : la classe java.awt.Color nous servira à travailler en Java avec les couleurs ; on y trouve en particulier un ensemble de constantes (Color.BLACK, Color.RED...) qui nous permettront d'attribuer des couleurs soit à une instance de Graphics, soit à l'arrière-plan ou à l'avant-plan d'un composant graphique.
   4.2. Les threads :
Si l’écriture de programmes corrects est un exercice difficile, l’écriture de programmes concurrents corrects l’est encore plus. En effet, par rapport à un programme séquentiel, beaucoup plus de choses peuvent mal tourner dans un programme concurrent.

12
Les threads sont une fonctionnalité incontournable du langage Java et permettent de simplifier le développement de systèmes complexes en transformant du code asynchrone compliqué en un code plus court et plus 
simple. En outre, les threads sont le moyen le plus direct d’exploiter la puissance des systèmes multiprocesseurs. À mesure que le nombre de processeurs augmentera, l’exploitation de la concurrence prendra de plus en plus d’importance.

Pour notre application on a utilisé la notion des threads pour gérer simultanément  les feux, le déplacement des véhicules et le traçage  dans la fenêtre graphique. Pour cela les classes Feu et Véhicules ont hérité à partir de la classe Thread, et en redéfinissant la méthode run()  on a  affecter a chaque thread son fonctionnement :

Classe Feu :
public void run()
 {
       while(true)
       {
       try {
             sleep(5000);
       } catch (InterruptedException e) {
             e.printStackTrace();
       }
       if(clr==Color.red)
             clr=Color.green;
       else
             clr=Color.red;
       try {
             sleep(5000);
       } catch (InterruptedException e) {
             e.printStackTrace();
       }
       if(clr==Color.red)
             clr=Color.green;
       else
             clr=Color.red;
            
       }
       }
Classe Vehicule :
public void run()
 {
        while(true)
        {
       try {
             sleep(100);
       } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
       }
if(isRoule())
        move();
        }
 }


   4.3. Fonctionnement du programme :


Rôle du véhicule:

Son rôle se résume à : Avancer sur la route a l’aide de plusieurs méthodes qui permettent de gérer son déplacement dans la fenêtre.
Le véhicule  doit savoir sur quelle route, avec quelle vitesse il roule et son rapprochement vis-à-vis d’un feu.

Rôle du  feu :

Chaque feu est appartiennent obligatoirement à une intersection entre deux routes et après une durée bien déterminée il change sa couleur.

Rôle de la route :
Chaque route contient deux collection une pour les véhicules et l’autre pour les feux, donc chaque véhicule ou feu  existe dans la fenêtre doit figurer dans la collection.

Rôle du panneau :

Le panneau a pour rôle de récupérer les collections de véhicule et feu pour les tracer selon leurs coordonnées.

5. Conclusion :                  

Le programme présenté dans ce rapport est le fruit de deux mois de travail dont le volume horaire dépasse largement celui fixé par les enseignements.

Ceci résulte d’une volonté forte de réaliser un développement logiciel réfléchi et justifiant l’utilisation de techniques de spécification afin d’acquérir une expérience dans ce domaine et de parfaire nos connaissances aussi bien du langage Java que de Génie Logiciel.

Même si le produit fini présente quelques situations dans lesquelles sont exécution ne répondent  pas totalement au cahier des charges que nous nous étions fixés, nous sommes satisfaits du résultat.

 En effet, pendant le développement, nous avons été amenés à découvrir des nouveaux aspects de programmation (les threads, généricité, composants SWING et AWT) mais aussi des aspects qui relèvent de techniques de conception (intérêt d’encapsulation, polymorphisme, généricité et héritage, visibilité).

Code source

Classe Fenetre :
import java.awt.Color;
import java.util.Vector;

import javax.swing.JFrame;
public class Fenetre extends JFrame{
private Panneau pan = new Panneau();
private Route r1=new Route(1,"national");
public Fenetre(){
this.setTitle("Animation");
this.setSize(720,755);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setContentPane(pan);
this.setVisible(true);

go();
}
private void go(){
       Feu f1=new Feu(20,Color.green,180,450);
    Feu f2=new Feu(20,Color.red,220,180);
    Feu f3=new Feu(20,Color.green,490,220);
       Feu f4=new Feu(20,Color.red,450,490);
    Vehicules v1=new Vehicules(50,Color.red,5,10,400);
    Vehicules v2=new Vehicules(50,Color.red,-5,720,300);
    r1.addFeu(f1);
    r1.addFeu(f2);
    r1.addFeu(f3);
    r1.addFeu(f4);
    r1.addVehicule(v1);
    r1.addVehicule(v2);
    Vector<Feu> f=r1.getF();
    Vector<Vehicules> v=r1.getVehicules();
   
    for(int i=0;i<f.size();i++)
    {
       f.get(i).start();
    }
   
    for(int i=0;i<v.size();i++)
    {
       v.get(i).start();
    }

while(true)
{

       System.out.println(v1.getX());
       System.out.println(f1.getClr());
       try {
             Thread.sleep(60);
       } catch (InterruptedException e) {
             e.printStackTrace();
       }
pan.setFeu(r1.getF());
pan.setVehicule(r1.getVehicules());
v1.setRoule(true);
v2.setRoule(true);
if(v1.getX()==f1.getX()-20 && f1.getClr().equals(Color.red))
       v1.setRoule(false);

if(v2.getX()>f3.getX() && v2.getX()<f3.getX()+20 && f3.getClr().equals(Color.red))
       v2.setRoule(false);

if(v1.getX()>pan.getWidth())
       v1.setX(0);
if(v2.getX()<0)
       v2.setX(pan.getWidth());

pan.repaint();
}
}

public static void main(String[] args) {
       Fenetre f=new Fenetre();
}
}
Classe Panneau :
import java.awt.Color;
import java.awt.Graphics;
import java.util.Vector;

import javax.swing.JPanel;
public class Panneau extends JPanel {
Vector<Feu> f;
Vector<Vehicules> v;
public void paintComponent(Graphics g){
      
       g.setColor(Color.white);
       g.fillRect(0, 0, this.getWidth(), this.getHeight());
      
       /* route  horizontale */
       g.setColor(Color.black);
       g.fillRect(0, 250, 720, 200);
      
       g.setColor(Color.white);
       g.fillRect(10,340,60,20);
      
      

       g.setColor(Color.white);
       g.fillRect(100,340,60,20);
      
       /* passage du pieton */
       g.setColor(Color.white);
       g.fillRect(190,420, 60,20);
      
       g.setColor(Color.white);
       g.fillRect(190,380,60,20);
      
       g.setColor(Color.white);
       g.fillRect(190,340,60,20);
      
       g.setColor(Color.white);
       g.fillRect(190,300, 60,20);
      
       g.setColor(Color.white);
       g.fillRect(190,260,60,20);
      
       /*FIN PASSAGE*/
      
       /* passage du pieton */
       g.setColor(Color.white);
       g.fillRect(450,420, 60,20);
      
       g.setColor(Color.white);
       g.fillRect(450,380,60,20);
      
       g.setColor(Color.white);
       g.fillRect(450,340,60,20);
      
       g.setColor(Color.white);
       g.fillRect(450,300, 60,20);
      
       g.setColor(Color.white);
       g.fillRect(450,260,60,20);
      
       /*FIN PASSAGE*/
       g.setColor(Color.white);
       g.fillRect(540,340,60,20);
      
       g.setColor(Color.white);
       g.fillRect(630,340,60,20);
       /*fin route*/
      
       /*route  verticale*/
       g.setColor(Color.black);
       g.fillRect(250,0,200 ,720 );
      
       g.setColor(Color.white);
       g.fillRect(340,10,20,60);
      
      
       g.setColor(Color.white);
       g.fillRect(340,100,20,60);
      

       /* passage du pieton */
       g.setColor(Color.white);
       g.fillRect(420,190,20,60);
      
       g.setColor(Color.white);
       g.fillRect(380,190,20,60);
      
       g.setColor(Color.white);
       g.fillRect(340,190,20,60);
      
       g.setColor(Color.white);
       g.fillRect(300,190,20,60);
      
       g.setColor(Color.white);
       g.fillRect(260,190,20,60);
      
       /*FIN PASSAGE*/
      
       /* passage du pieton */
       g.setColor(Color.white);
       g.fillRect(420,450,20 ,60);
      
       g.setColor(Color.white);
       g.fillRect(380,450,20,60);
      
       g.setColor(Color.white);
       g.fillRect(340,450,20,60);
      
       g.setColor(Color.white);
       g.fillRect(300,450,20,60);
      
       g.setColor(Color.white);
       g.fillRect(260,450,20,60);
      
       /*FIN PASSAGE*/
       g.setColor(Color.white);
       g.fillRect(340,540,20,60);
      
       g.setColor(Color.white);
       g.fillRect(340,630,20,60);
       /*fin route*/
      
       for(int i=0;i<f.size();i++)
       {
             g.setColor(f.get(i).getClr());
             g.fillOval(f.get(i).getX(),f.get(i).getY(),30,30);
       }
      
       for(int i=0;i<v.size();i++)
       {
             g.setColor(v.get(i).getClr());
             g.fillRect(v.get(i).getX(),v.get(i).getY(),30,30);
       }
      
       }
      

       public void setFeu(Vector<Feu> f1) {
             f=f1;
       }
       public void setVehicule(Vector<Vehicules> v1) {
             v=v1;
       }
       }
Classe  Route :
import java.util.*;
public class Route{

       private int num;
       private String nom;
       private Vector<Feu> f;
       private Vector<Vehicules> v;
      
       public Route(int num, String nom) {
             this.num = num;
             this.nom = nom;
             f= new Vector<Feu>();
             v= new Vector<Vehicules>();
       }
      
       public Vector<Vehicules> getVehicules()
       {
             return v;
       }
      
       public int getNum()
       {
             return num;
       }
      
       public String getString()
       {
             return nom;
       }
      
      
       public Vector<Feu> getF() {
             return f;
       }

       public void addFeu(Feu f1) {
             f.add(f1);
       }


       public void addVehicule(Vehicules v1) {
             v.add(v1);
       }

      

}
Classe Feu :
import java.awt.*;

public class Feu extends Thread {

       private int num;
       private Color clr;
       int x,y,duree;
      
       public Feu(int num, Color clr, int duree, int x, int y) {
             this.num = num;
             this.clr = clr;
             this.x = x;
             this.y = y;
       }
      
       public int getNum() {
             return num;
       }
      
       public void setId(int num) {
             this.num = num;
       }
      
       public Color getClr() {
             return clr;
       }
      
       public void setClr(Color clr) {
             this.clr = clr;
       }
      
       public int getX() {
             return x;
       }
      
       public void setX(int x) {
             this.x = x;
       }
      
       public int getY() {
             return y;
       }
      
       public void setY(int y) {
             this.y = y;
       }
      
      
       public void run()
       {
             while(true)
             {

            
             try {
                    sleep(duree);
             } catch (InterruptedException e) {
                    e.printStackTrace();
             }
             if(clr==Color.red)
                    clr=Color.green;
             else
                    clr=Color.red;
             try {
                    sleep(duree);
             } catch (InterruptedException e) {
                    e.printStackTrace();
             }
             if(clr==Color.red)
                    clr=Color.green;
             else
                    clr=Color.red;
            
             }
       }
}
Classe Vehicule :
import java.awt.*;
public class Vehicules extends Thread{
       private int num;
       private boolean roule=true;
       private Color clr;
       private int vitesse;
       private int x,y;
      
      
       public Vehicules(int num, Color clr, int vitesse, int x, int y) {
             this.num = num;
             this.clr = clr;
             this.vitesse = vitesse;
             this.x = x;
             this.y=y;
       }
      
      
       public int getNum() {
             return num;
       }
      
       public void setId(int num) {
             this.num = num;
       }
      
       public Color getClr() {
             return clr;
       }

       public void setClr(Color clr) {
             this.clr = clr;
       }
       public int getVitesse() {
             return vitesse;
       }
       public void setVitesse(int vitesse) {
             this.vitesse = vitesse;
       }
       public int getX() {
             return x;
       }
       public void setX(int x) {
             this.x = x;
       }
       public int getY() {
             return y;
       }
       public void setY(int y) {
             this.y = y;
       }
      
       public void move()
       {
             x=x+vitesse;
       }
      
      
      
 public boolean isRoule() {
             return roule;
       }


       public void setRoule(boolean roule) {
             this.roule = roule;
       }


public void run()
 {
        while(true)
        {
       try {
             sleep(100);
       } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
       }
       if(isRoule())
        move();
        }
 }
}















9 commentaires:

  1. Bonjour c'est du beau travaille ...
    est ce que vous dessiner les routes ou il son bien defini ?

    RépondreSupprimer
    Réponses
    1. j'ai dessiné les routes et les feux en utilisant les bibliothèques graphique de java comme :awt et swing

      Supprimer
  2. Ce commentaire a été supprimé par l'auteur.

    RépondreSupprimer
  3. Merci pour me réponde j'ai d'autre question si c'est possible:
    est ce que c'est l'utilisateur finale qui dessine la route ?
    est ce que la simulation se fait selon un graphe orienté ?
    ......

    RépondreSupprimer
    Réponses
    1. je t'en prie , l'utilisateur final va lancer l'application mais c'est le programme qui s'occupe de dessiner la route et les feux mais on peut l'ajouter facilement en ajoutant un button et on dessine lors d’évènement de clique.merci.

      Supprimer
  4. comment on peut ajouter des vehicules dans l'autre direction

    RépondreSupprimer
  5. c-à-dire comment les vehicules se deplacent verticalement

    RépondreSupprimer
  6. c'est un travaille excellent mais comment se deplacent les vehicules dans la route verticale

    RépondreSupprimer
  7. pouvez vous m'aidez pour faire ce travail et merci d'avance

    RépondreSupprimer

Partenaires

Computers Blogs

Contactez-nous

Nom

E-mail *

Message *

Tous droits resérvés-www.exercices-corriges.com Seo Blogger Templates