Je suis en train de faire une IU pour un programme de pathfinding ;j'utilise PyQt pour cela ; J'ai voulu mettre en place une ProgressBar pour l'utiliser j'utilise des QThreads sinon la fenêtre Qt n'est plus actualisé , Je fais tourné un thread pour savoir quand je dois actualiser la ProgressBar ; j’envoie donc un Signal d'un Thread à un autre car je ne peux pas actualiser la progressBar autre pars que dans son threads où elle a était initialisé ; et là plusieurs problème .
Le premier étant que le programme ne réagit pas toujours pareil , des fois il plante avant que la barre arrive à 100 d'autres quand il arrive à 100 et des fois il continue sans probleme .
Et le code "Objet.py" qui contient le systeme de PathFinding
# -*- coding: utf-8 -*
import os,sys,pickle
from time import sleep
from copy import deepcopy
from random import choice
from math import *
PinEntre = [5,6,12,13,16]
PinSortie = [18,17,27,22,23]
class Objet:
TaillePente = 3
def __init__(self,positionZ,positionY,positionX,orientation,repere):
self.Maze = repere
self.Z = positionZ
self.Y = positionY
self.X = positionX
self.orientation = orientation
self.depart = (positionZ,positionY,positionX)
self.checkPoint = (positionZ,positionY,positionX)
self.Maze.Search((self.Z,self.Y,self.X)).Etat = 2
def Copy(self):
return (self.Z,self.Y,self.X)
class Robot(Objet):
def Deplacement(self,Demande,Fin=0):
print(Demande)
if Demande == "N":
Demande = 1
elif Demande == "E":
Demande = 2
elif Demande == "S":
Demande = 3
elif Demande == "O":
Demande = 4
"""Reorientation des mouvement par rapport a l'orientation
du robot """
def Avancer(self,Fin):
pass
def Arriere(self,Fin):
pass
def RotDroite(self,Fin):
pass
def RotGauche(self,Fin):
pass
def RotArriere(self,Fin):
pass
def PingMur(self):
pass
def PingCam(self):
pass
def PingThermique(self):
pass
def PingSol(self):
pass
class RobFind(Objet):
BonChemin = list()
Registre = list()
N_Instance = 0
N_Success = 0
N_SuccessMax = 0
AnciennePourcent = -1
Profondeur = 0
Stop = 0
def __init__(self,Robcopie,repere,Chemin=list(),Depart=True,Pas=0):
RobFind.N_Instance += 1
self.Matricule = RobFind.N_Instance
self.Z = Robcopie.Z
self.Y = Robcopie.Y
self.X = Robcopie.X
self.plan = repere
self.chemin = deepcopy(Chemin)
self.pas = Pas
if Depart != True:
if Depart == "N":
self.Avancer()
elif Depart == "E":
self.Droite()
elif Depart == "S":
self.Arriere()
elif Depart == "O":
self.Gauche()
self.Pathfinding()
if RobFind.AnciennePourcent != (RobFind.N_Success/RobFind.N_SuccessMax*100//1) or RobFind.N_Instance > 100000 :
AncienneN_Instance = RobFind.N_Instance
RobFind.TriChemin()
RobFind.Avancement(AncienneN_Instance)
def TriChemin():
if RobFind.BonChemin == list():
for I in RobFind.Registre:
I = I.chemin
if I[-1] == 'Success':
RobFind.BonChemin = I
break
else:
decal = 0
for i in range(len(RobFind.Registre)):
i = i - decal
I = RobFind.Registre[i].chemin
if I[-1] == 'Success':
if len(I) == len(RobFind.BonChemin):
o = i
elif len(I) < len(RobFind.BonChemin):
RobFind.BonChemin = I
decal += 1
elif len(I) > len(RobFind.BonChemin):
del RobFind.Registre[i]
decal += 1
else :
del RobFind.Registre[i]
decal += 1
elif I[-1] == 'I':
del RobFind.Registre[i]
decal += 1
def Avancement(AncienneN_Instance):
RobFind.AnciennePourcent = int(RobFind.N_Success/RobFind.N_SuccessMax*100//1)
BonChemin = RobFind.BonChemin
print("{}/100 ".format(RobFind.AnciennePourcent))
def Dupli(self,Depart):
RobFind.Registre.append(RobFind(self,self.plan,self.chemin,Depart,self.pas))
def __del__(self):
RobFind.N_Instance -= 1
def Avancer(self):
#print('Avancer')
self.Y -= 1
self.pas += 1
self.chemin.append("N")
self.plan.Search((self.Z,self.Y,self.X)).Passage = self.pas
def Droite(self):
#print('Droite')
self.X += 1
self.pas += 1
self.chemin.append("E")
self.plan.Search((self.Z,self.Y,self.X)).Passage = self.pas
def Gauche(self):
#print('Gauche')
self.X -= 1
self.pas += 1
self.chemin.append("O")
self.plan.Search((self.Z,self.Y,self.X)).Passage = self.pas
def Arriere(self):
#print('Arriere')
self.Y += 1
self.pas += 1
self.chemin.append("S")
self.plan.Search((self.Z,self.Y,self.X)).Passage = self.pas
def Pathfinding(self):
"""Cherche un chemin vers une case inconnu,
a chaque intersection lance un nouveau RobFind partant de
l'intersection avec les meme information que son model """
while True:
#print( " Z:{} Y:{} X:{} \n ".format(self.Z,self.Y,self.X))
self.Sortie = 0
self.Action = 'Rien'
if self.plan.Etat((self.Z,self.Y,self.X)) == -1 : #Si case inconnue retourne self.Chemin
self.chemin.append("Success")
RobFind.N_Success += 1
return
""" Recherche d'une Sortie """
if self.plan.Etat((self.Z,self.Y-1,self.X)) <= 0 and self.plan.Pas((self.Z,self.Y-1,self.X)) > self.pas :
self.Sortie += 1
if self.Sortie > 1 :
self.Dupli("N")
else:
self.Action = self.Avancer
if self.plan.Etat((self.Z,self.Y,self.X+1)) <= 0 and self.plan.Pas((self.Z,self.Y,self.X+1)) > self.pas :
self.Sortie += 1
if self.Sortie > 1 :
self.Dupli("E")
else:
self.Action = self.Droite
if self.plan.Etat((self.Z,self.Y+1,self.X)) <= 0 and self.plan.Pas((self.Z,self.Y+1,self.X)) > self.pas :
self.Sortie += 1
if self.Sortie > 1 :
self.Dupli("S")
else:
self.Action = self.Arriere
if self.plan.Etat((self.Z,self.Y,self.X-1)) <= 0 and self.plan.Pas((self.Z,self.Y,self.X-1)) > self.pas :
self.Sortie += 1
if self.Sortie > 1 :
self.Dupli("O")
else:
self.Action = self.Gauche
if self.Sortie == 0 :
self.chemin.append("I")
return
else:
self.Action()
class Case:
def __init__(self,positionZ,positionY,positionX,Etat=0):
self.Z = positionZ
self.Y = positionY
self.X = positionX
self.Etat = 0
self.Passage = 10000
def ModifEtat(self,Etat):
self.Etat = Etat
def __repr__(self):
pass
class Tab:#Creation d'un tableau fait de l'objet Case
def __init__(self,tailleZ,tailleY,tailleX):
self.z = tailleZ
self.y = tailleY
self.x = tailleX
self.Tableau = list()
for z in range(tailleZ):
Premiere_D = []
for y in range(tailleY):
Deuxieme_D = []
for x in range(tailleX):
Deuxieme_D.append(Case(z,y,x))
Premiere_D.append(Deuxieme_D)
self.Tableau.append(Premiere_D)
def Search(self,Position):
#print("{} {} {} ".format(Position[0],Position[1],Position[2]))
return self.Tableau[Position[0]][Position[1]][Position[2]]
def Etat(self,Position):
return self.Tableau[Position[0]][Position[1]][Position[2]].Etat
def Pas(self,Position):
return self.Tableau[Position[0]][Position[1]][Position[2]].Passage
Ps : Le compteur pour la Progress bar ne s'arrete pas à 100 car j'ai pas encore de formules fiable pour trouver le nombre de Success_Max .
désolé si c'est pas très digeste à lire ...
PyQt , QThread et QProgressBar
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.