IRESTE/mainLoop.md

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

Comme d'hab les modules de Qt necessaires

from PySide6.QtWidgets import QFileDialog, QToolBox
from PySide6.QtCore import QElapsedTimer, QTimer, QElapsedTimer, QObject, Signal, Slot

classe mainLoop

Notre classe (On remarquera qu'elle ne suit pas la même convention pour le nom que MainWindow)

class mainLoop():

On crée un signal pour la maj de l'affichage des fps. Il y as une bonne raison pour laquelle il ne se trouve pas dans le __init__ mais je m'en souvient plus

    updateFPS = Signal(int)

__init__

La fonction d'initialisation

Ici parent fait reference à notre MainWindow. 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)

On crée le timer qui va s'occuper de maj les deplacements (mais ce coup ci on le demarre pas tout de suite, on va attendre que le thread ai demarré (start)) On instancie aussi le timer qui va nous servir à mesurer le fps

        self.timer = QTimer()
        self.timer.timeout.connect(self.update)
        self.timer.timeout.connect(self.updateFps)
        self.timer.setInterval(1000/60)

        self.fpsTimer = QElapsedTimer()
        self.updateFPS.connect(self.parent.updatePhysicsFps)

start

Fonction appelée quand le thread est demarré (on l'a connecté dans main.py)

    def start(self):
        self.fpsTimer.start()

update

La fonction dans laquelle on fait les maj, elle est appelée periodiquement par le Timer defini dans precedemment __init__

On fait la maj des voitures (deplacement + conduite).

    def update(self):
        self.controller.update()

openNetwork

Fonction appelé quand l'utilisateur click sur le bouton open->network file par le code dans MainWindow

    def openNetwork(self):

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):
        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()

quickLoad

Fonction pour charger rapidement les reseaux, j'avais la flemme d'aller chercher dans le menu à chque fois

    def quickLoad(self):
        self.map.fromPath("test2.net.xml")
        self.painter.generateTransform()
        self.controller.fromPath("test5.rou.xml")
        self.controller.prepareRoute()

updateFps

Fonction pour mesurer/maj le fps. On recupere le temps depuis la dernier maj puis on la passe au Slot dans main.py

    def updateFps(self):
        newFps = self.fpsTimer.restart()
        self.updateFPS.emit(newFps)