doc mainLoop.py

DOC.md

@@ -21,6 +21,8 @@ Possède un ID, une position (x,y), une liste des voies qui s'y intersecte, une
 
 ## Implémentation
 ### main.py
+Le fichier principal
+
 #### Imports
 imports "classiques" :
 
@@ -67,6 +69,8 @@ On définit la classe MainWindow qui hérite de QMainWindow
 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
@@ -92,16 +96,16 @@ 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)
+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
 
 ```python
         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 serat executée quand on cliquerat sur le bouton 
+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")
@@ -125,6 +129,7 @@ On crée un timer qui va executer toutes les 1/60s (60fps) la fonction update de
         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
 
 ```python
@@ -134,7 +139,7 @@ Cette fonction est appelée à chaque appui sur le clavier, ici si la touche est
 ```
 
 #### main
-`__name__` est defini à `"__main__"` seulement si on est dans le fichier principal (i.e pas dans un module)
+`__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
@@ -170,3 +175,118 @@ Finalement on lance l'event loop, et on quitte dès qu'elle retourne
 ```python
     sys.exit(app.exec())
 ```
+
+### mainLoop.py
+Le fichier contenant notre boucle de maj principale, appelé par un QTimer défini dans [main.py](#Classe-MainWindow)
+
+#### imports
+Nos deux classes définies dans [Map.py](#Map.py) et [CarController.py](#CarController.py) chargées de gérer respectivement le reseau (chargement, affichage,...) et les voitures (chargement, calcul de trajet, affichage, deplacements, ...)
+
+```python
+from Map import Map
+from CarController import CarController
+```
+
+import de QFileDialog pour l'ui d'ouverture des fichiers de reseau et de vehicules
+
+```python
+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)
+
+```python
+class mainLoop():
+```
+
+<a id="mainLoopInit"></a>
+##### \_\_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](#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](#openNetwork) et [openVehicles](openVehicles))
+
+```python
+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__`](#mainInit) 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](#paintEvent) dans lequel on fait appel à [Map.draw](#mapDraw) et [CarController.draw](#CCDraw) qui va redessiner les elements de l'affichage
+
+```python
+def update(self):
+        self.controller.update()
+        self.painter.update()
+```
+
+##### openNetwork
+Fonction appelé quand l'utilisateur click sur le bouton open-\>network file
+
+```python
+def openNetwork(self):
+```
+
+On crée un dialogue d'ouverture de fichier
+
+```python
+        fileName = QFileDialog.getOpenFileName(self.parent,"Open Network", "./", "Network File (*.net.xml)")
+```
+
+Si le resultat est vide (i.e l'utilisateur à annulé) on abandonne
+
+```python
+        if(fileName[0] == ''):
+            return
+```
+
+Sinon on crée le reseau à partir u chemin récupéré
+
+```python
+        self.map.fromPath(fileName[0])
+```
+
+On génére la matrice de transformation entre coordonnées du réseau-\>coordonées de l'écran
+
+```python
+        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)
+
+```python
+        self.controller.prepareRoute()
+```
+
+##### openVehicles
+Très similaire à la fonction [openNetwork](#openNetwork) mais ce coup ci pour charger les vehicules
+
+```python
+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
+
+```python
+        if(self.map.isLoaded()):
+            self.controller.prepareRoute()
+```