230 lines
7.6 KiB
Markdown
230 lines
7.6 KiB
Markdown
# main.py
|
|
Le fichier principal, charge et contrôle tout les autres éléments du programme
|
|
|
|
## Imports
|
|
imports "classiques" :
|
|
|
|
```python
|
|
import os, sys
|
|
```
|
|
|
|
ajout de sumolib dans le PATH, 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](https://sumo.dlr.de/docs/Tools/Sumolib.html) :
|
|
|
|
```python
|
|
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 :
|
|
|
|
```python
|
|
from PySide6.QtCore import Qt, QTimer, QElapsedTimer, QThread, Slot, Signal
|
|
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel, QFileDialog
|
|
from PySide6.QtGui import QSurfaceFormat, QAction
|
|
```
|
|
|
|
import du fichier contenant la description de interface, generée par uic :
|
|
|
|
```python
|
|
from window import Ui_MainWindow
|
|
```
|
|
|
|
le fichier contenant la boucle principale de maj :
|
|
|
|
```python
|
|
from mainLoop import mainLoop
|
|
```
|
|
|
|
## Classe MainWindow
|
|
On définit la classe MainWindow qui hérite de QMainWindow,
|
|
C'est la classe quio contient notre affichage principal
|
|
|
|
```python
|
|
class MainWindow(QMainWindow):
|
|
```
|
|
|
|
<a id="mainInit"></a>
|
|
### `__init__`
|
|
La fonction `__init__` est la fonction qui est appellée quand on crée l'objet (le constructeur)
|
|
|
|
```python
|
|
def __init__(self):
|
|
```
|
|
|
|
On fait appel à la fonction `__init__` de la superclass, i.e on execute le code d'initialisation de la classe QMainWindow
|
|
|
|
```python
|
|
super().__init__()
|
|
```
|
|
|
|
On genere l'interface à partir du fichier générée par QT Designer
|
|
|
|
```python
|
|
self.ui = Ui_MainWindow()
|
|
self.ui.setupUi(self)
|
|
```
|
|
|
|
De base il met le focus sur les QSpinBox, ducoup on ne recupere pas les events sur le touches ([keyPressEvent](#keyPressEvent)) ducoup pour eviter ça on autorise la fenetre principale à recuperer le focus si elle est cliquée et par defaut on lui donne le focus
|
|
|
|
```python
|
|
self.setFocusPolicy(Qt.StrongFocus)
|
|
self.setFocus()
|
|
```
|
|
|
|
On crée le Qthread qui va s'occuper de faire la mise à jour des déplacements, on crée un instance de notre classe qui gére la maj ([mainLoop](mainLoop.md)) et on la deplace dans le thread fraichement créé. On relie la fonction start de notre fonction au signal started du thread, pour demarrer le timer de la classe après que le thread ai demarré.
|
|
Finalement on demarre le Thread
|
|
|
|
```python
|
|
self.updateThread = QThread()
|
|
|
|
self.mainLoop = mainLoop(self)
|
|
|
|
self.mainLoop.moveToThread(self.updateThread)
|
|
self.updateThread.started.connect(self.mainLoop.start)
|
|
self.updateThread.start()
|
|
|
|
```
|
|
|
|
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.
|
|
```python
|
|
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.openNetwork)
|
|
openMenu.addAction(openNet)
|
|
|
|
openVeh = QAction("&Open Vehicles",self)
|
|
openVeh.setStatusTip("Open Vehicle description (.rou.xml)")
|
|
openVeh.triggered.connect(self.openVehicles)
|
|
openMenu.addAction(openVeh)
|
|
```
|
|
|
|
On crée le timer qui va se charger d'executer peridiodiquement la fct de maj de notre affichage (1000ms/60 = 60fps)
|
|
On la relie aussi à la fct [updateFPS](#updateFPS) qui s'occupe juste de mesurer et de maj le fps suir l'affichage
|
|
|
|
```python
|
|
timer = QTimer(self)
|
|
timer.timeout.connect(self.ui.mainSurf.update)
|
|
timer.timeout.connect(self.updateFPS)
|
|
timer.start(1000/60)
|
|
```
|
|
|
|
On relie les différents bouton et entrées à leurs actions (start, stop, ...)
|
|
|
|
```python
|
|
self.ui.startButton.clicked.connect(self.mainLoop.timer.start)
|
|
self.ui.stopButton.clicked.connect(self.mainLoop.timer.stop)
|
|
|
|
self.ui.mainFPS_set.valueChanged.connect(self.drawTimer.setInterval)
|
|
self.ui.physicsFPS_set.valueChanged.connect(self.mainLoop.timer.setInterval)
|
|
|
|
```
|
|
|
|
Ce timer nous sert juste à mesurer le temps passé entre chaque maj de l'affichage (pour récuperer le fps)
|
|
|
|
```python
|
|
self.fpsTimer = QElapsedTimer()
|
|
self.fpsTimer.start()
|
|
```
|
|
|
|
### keyPressEvent
|
|
Cette fonction est appelée à chaque appui sur le clavier, ici si la touche est Esc ou Q on arrète le programme, si la touche est S on charge le reseau et les vehicules à partir des fichiers dans ./ (si ils existent)
|
|
|
|
```python
|
|
if e.key() == Qt.Key_Escape or e.key() == Qt.Key_Q:
|
|
self.close()
|
|
|
|
elif e.key() == Qt.Key_S:
|
|
self.mainLoop.quickLoad()
|
|
|
|
```
|
|
|
|
### updateFPS
|
|
La fonction chargée de maj l'affichage des fps, appelée par le drawTimer.
|
|
On récupère le QLabel pour l'affichage, on change le texte avec la nouvelle valeur récuperé dans le fpsTimer et finalment on marque le widget pour la maj
|
|
|
|
```python
|
|
def updateFPS(self):
|
|
widget = self.findChild(QLabel,"mainFps")
|
|
widget.setText(f"fps : {1000/self.fpsTimer.restart():.1f}")
|
|
widget.update()
|
|
```
|
|
|
|
### updatePhysicsFps
|
|
Comme pour [updateFps](#updateFPS) mais ce coup ci pour la boucle de maj des déplacements.
|
|
Comme on est dans un thread diférent pour ce timer on fait appel au slot directement avec la valeur mais sinon c'est pareil
|
|
|
|
```
|
|
@Slot(int)
|
|
def updatePhysicsFps(self,t):
|
|
widget = self.findChild(QLabel,"physicsFPS")
|
|
widget.setText(f"ph fps : {1000/t:.1f}")
|
|
```
|
|
|
|
### openNetwork
|
|
La fonction qui ouvre le dialogue d'ouverture de fichier quand on clique sur le menu, on est obligé de la mettre dans ce thread là parce que Qt supporte mal de demarrer le dialoque dans un Thread différent que celui d'affichage.
|
|
Donc on ouvre le dialogue, on récupère le résultat et on le passe à [la fonction d'ouverture dans mainLoop](mainLoop.md#openNetwork)
|
|
|
|
```python
|
|
def openNetwork(self):
|
|
filename = QFileDialog.getOpenFileName(self,"Open Network", "./", "Network File (*.net.xml)")
|
|
self.mainLoop.openNetwork(filename[0])
|
|
```
|
|
|
|
### openVehicle
|
|
Idem à [openNetwork](#openNetwork) mais pour l'ouverture du fichier de description des voyages pour le vehicules
|
|
|
|
```python
|
|
def openVehicles(self):
|
|
filename = QFileDialog.getOpenFileName(self,"Open Vehicle trip description", "./", "Route File (*.rou.xml)")
|
|
self.mainLoop.openVehicles(filename[0])
|
|
```
|
|
|
|
## 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
|
|
|
|
```python
|
|
if __name__ == "__main__":
|
|
```
|
|
|
|
On crée une QApplication, bah c'est Qt
|
|
|
|
```python
|
|
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](https://doc.qt.io/qtforpython/PySide6/QtOpenGLWidgets/QOpenGLWidget.html#PySide6.QtOpenGLWidgets.PySide6.QtOpenGLWidgets.QOpenGLWidget.resized))
|
|
|
|
```python
|
|
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](#Classe-MainWindow)
|
|
|
|
```python
|
|
window = MainWindow()
|
|
window.show()
|
|
```
|
|
|
|
Finalement on lance l'event loop, et on quitte dès qu'elle retourne
|
|
|
|
```python
|
|
sys.exit(app.exec())
|
|
```
|
|
|
|
|