8.9 KiB
DOCUMENTATION
Reseau routier .net.xml de SUMO
Edge
Relie deux nodes, il possède un ID unique le décrivant et les deux ID des nodes composant ses extrémitées. Il ne possède pas directement d'information concernant le tracé de la route, ces données sont fournis par les lanes Un edge est considéré comme "interne" si il est inclus dans une jonction
Lane
Comme le nom l'indique, decris une voie de la route. Possède un ID et un index numéroté de droite à gauche, une vitesse maximale autorisé, une longueur. Le tracé de la route est defini par la propriètée "shape" qui est composée d'une liste de position x,y
Junction/Node
Une jonction entre plusieurs routes. Possède un ID, une position (x,y), une liste des voies qui s'y intersecte, une liste des voies internes qui la compose, un shape qui l'englobe
Implémentation
main.py
Le fichier principal
Imports
imports "classiques" :
import os, sys
import time
imports pour sumo, honnêtement je suis pas sur qu'on en ai besoin si la librairie est installée avec pip mais bon c'était le code recommandé ici :
if 'SUMO_HOME' in os.environ:
tools = os.path.join(os.environ['SUMO_HOME'], 'tools')
sys.path.append(tools)
else:
print("please declare environment variable 'SUMO_HOME'")
imports pour Qt :
from PySide6.QtCore import Qt, QTimer
from PySide6.QtWidgets import QApplication, QMainWindow
from PySide6.QtGui import QSurfaceFormat, QAction
import du fichier contenant la description de interface, generée par uic :
from window import Ui_MainWindow
le fichier contenant la boucle principale de maj :
from mainLoop import mainLoop
Classe MainWindow
On définit la classe MainWindow qui hérite de QMainWindow
class MainWindow(QMainWindow):
__init__
La fonction __init__ est la fonction qui est appellée quand on crée l'objet (le constructeur)
def __init__(self):
On fait appel à la fonction __init__ de la superclass, donc on execute le code d'initialisation de la classe QMainWindow
super(MainWindow, self).__init__()
On genere l'interface à partir du fichier générée par QT Designer
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
On initialise la boucle de mise à jour
self.mainLoop = mainLoop(self)
On donne à la boucle principale le widget qui nous sert à afficher les infos (l'interface avec position, vitesse,... à droite de l'écran). Après il est transmis à chaque voiture qui décident de ce quelles vont afficher
self.mainLoop.addInfosDisplay(self.ui.infos)
On génere le menu (l'interface en haut de l'écran). Avec le menu general, qui as un sous-menu (File), qui as un sous-menu (Open), qui as deux sous-actions (ouvrir le réseau et ouvrir les vehicules). Pour chaque action on les relient (connect) à un fonction qui sera executée quand on cliquera sur le bouton.
fileMenu = self.menuBar().addMenu("&File")
openMenu = fileMenu.addMenu("&Open")
openNet = QAction("&Open Network",self)
openNet.setStatusTip("Open Network file (.net.xml)")
openNet.triggered.connect(self.mainLoop.openNetwork)
openMenu.addAction(openNet)
openVeh = QAction("&Open Vehicles",self)
openVeh.setStatusTip("Open Vehicle description (.rou.xml)")
openVeh.triggered.connect(self.mainLoop.openVehicles)
openMenu.addAction(openVeh)
On crée un timer qui va executer toutes les 1/60s (60fps) la fonction update de notre boucle principale
timer = QTimer(self)
timer.timeout.connect(self.mainLoop.update)
timer.start(1.0/60)
keyPressEvent
Cette fonction est appelée à chaque appui sur le clavier, ici si la touche est Esc ou Q on arrète le programme
def keyPressEvent(self, e):
if e.key() == Qt.Key_Escape or e.key() == Qt.Key_Q:
self.close()
main
__name__ est defini à "__main__" seulement si on est dans le fichier principal (i.e pas dans un module).
Donc cette portion de code est celle executée quand on lance main.py
if __name__ == "__main__":
On crée une QApplication, comme ça Qt se demerde pour gérer l'event loop, le context,...
app = QApplication()
On définie les propriètés par defaut de la surface, j'avais mis ça pour activer l'AA mais ça à l'air foiré (cf)
format = QSurfaceFormat()
format.setDepthBufferSize(24)
format.setVersion(3, 2)
format.setSamples(4)
format.setProfile(QSurfaceFormat.CoreProfile)
QSurfaceFormat.setDefaultFormat(format)
On crée notre objet de fenetre principale défini juste au dessus
window = MainWindow()
window.show()
Finalement on lance l'event loop, et on quitte dès qu'elle retourne
sys.exit(app.exec())
mainLoop.py
Le fichier contenant notre boucle de maj principale, appelé par un QTimer défini dans main.py
imports
Nos deux classes définies dans Map.py et CarController.py chargées de gérer respectivement le reseau (chargement, affichage,...) et les voitures (chargement, calcul de trajet, affichage, deplacements, ...)
from Map import Map
from CarController import CarController
import de QFileDialog pour l'ui d'ouverture des fichiers de reseau et de vehicules
from PySide6.QtWidgets import QFileDialog
classe mainLoop
Notre classe (On remarquera qu'elle ne suit pas la même convention pour le nom que MainWindow)
class mainLoop():
__init__
La fonction d'initialisation
Ici parent fait reference à notre MainWindow parce que QFileDialog veut absolument un QWidget. painter est la surface d'affichage principale, définie dans le fichier mainPainter.py, on s'en sert pour dessiner.
On crée nos objet pour le réseau (Map) et pour les voitures (CarController), pour l'instant ils sont vides, on les remplis après quand l'utilisateur nous donne l'emplacement des fichiers (openNetwork et openVehicles)
def __init__(self, parent):
self.parent = parent
self.painter = parent.ui.mainSurf
self.map = Map()
self.controller = CarController(self.map)
self.painter.addMap(self.map)
self.painter.addCarController(self.controller)
update
La fonction dans laquelle on fait les maj, elle est appelée periodiquement par le Timer defini dans le __init__ de la fenêtre principale
On fait d'abord la maj des voitures (deplacement + conduite). Puis on fait appel à update sur notre painter qui va prévoir un paintEvent dans lequel on fait appel à Map.draw et CarController.draw qui va redessiner les elements de l'affichage
def update(self):
self.controller.update()
self.painter.update()
openNetwork
Fonction appelé quand l'utilisateur click sur le bouton open->network file
def openNetwork(self):
On crée un dialogue d'ouverture de fichier
fileName = QFileDialog.getOpenFileName(self.parent,"Open Network", "./", "Network File (*.net.xml)")
Si le resultat est vide (i.e l'utilisateur à annulé) on abandonne
if(fileName[0] == ''):
return
Sinon on crée le reseau à partir u chemin récupéré
self.map.fromPath(fileName[0])
On génére la matrice de transformation entre coordonnées du réseau->coordonées de l'écran
self.painter.generateTransform()
Maintenant qu'on as le réseau on peut generer les itineraires pour les voitures (si on as pas encore chargé les voitures cette fonction n'a pas d'effet)
self.controller.prepareRoute()
openVehicles
Très similaire à la fonction openNetwork mais ce coup ci pour charger les vehicules
def openVehicles(self):
fileName = QFileDialog.getOpenFileName(self.parent,"Open Vehicle trip description", "./", "Route File (*.rou.xml)")
if(fileName[0] == ''):
return
self.controller.fromPath(fileName[0])
Si le reseau est déjà chargé on peut directement calculer les trajet ici
if(self.map.isLoaded()):
self.controller.prepareRoute()