mise à jour d'une fenêtre graphique

Version imprimable

Bonjour,

Considérez ce code:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 def resolution(self,etape): #procédure récursive "déplacement de la balle" global x1,y1,dx,dy,flag self.x1,self.y1=self.x1+self.dx,self.y1+self.dy if self.x1>210: self.x1,self.dx,self.dy=210,0,15 if self.y1>210: self.y1,self.dx,self.dy=210,-15,0 if self.x1<10: self.x1,self.dx,self.dy=10,0,-15 if self.y1<10: self.y1,self.dx,self.dy=10,15,0 self.gra.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30) self.fen.after(50,self.resolution(1)) print 'la balle a bougé'
Le morceau de code placé ici n'a pas grande signification, il n'est qu'un problème que j'ai isolé dans un code plus gros.

Quand on lance la fonction self.resolution(1), très vite, j'ai un message d'erreur à rallonge:

Exception in Tkinter callback
Traceback (most recent call last):
File "/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/lib-tk/Tkinter.py", line 1403, in __call__
File "main2.py", line 88, in demarrage
self.resolution(1)
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution

........
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 146, in resolution
self.fen.after(50,self.resolution(1))
File "main2.py", line 144, in resolution
self.gra.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30)
RuntimeError: maximum recursion depth exceeded

Mais quand j'enlève l'argument etape à la fonction, c'est à dire que j'ai déclare
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 def resolution(self): #procédure récursive "déplacement de la balle" global x1,y1,dx,dy,flag self.x1,self.y1=self.x1+self.dx,self.y1+self.dy if self.x1>210: self.x1,self.dx,self.dy=210,0,15 if self.y1>210: self.y1,self.dx,self.dy=210,-15,0 if self.x1<10: self.x1,self.dx,self.dy=10,0,-15 if self.y1<10: self.y1,self.dx,self.dy=10,15,0 self.gra.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30) self.fen.after(50,self.resolution) print 'la balle a bougé'
en l'appelant avec self.resolution(), cette fois, plus de problème, je vois bien ma petite balle se déplacer à l'écran.
Faut-il croire que la fonction passée en argument de la fonction after ne doit pas avoir d'argument?

Mathieu

11/05/2008, 09h23
tyrtamos

Bonjour,

Dans le 1er cas, quand tu appelles self.fen.after(50,self.resolution(1)), tu transmets comme paramètre le résultat de self.resolution(1) qui doit donc être calculé avant de passer la main à self.fen.after. Mais l'appel est récursif et aucune condition d'arrêt de cette récursion n'est prévue, ça boucle jusqu'à ce que la pile soit pleine.

Dans le 2ème cas, tu appelles self.fen.after(50,self.resolution), mais là, tu transmets la référence à la fonction self.resolution() (c'est à dire son adresse). Cela ne boucle plus, mais cela suppose que tu l'utilises à l'intérieur de self.fen.after, sinon, ça ne sert à rien.

Tyrtamos
11/05/2008, 16h27
Mathieu72

Bien bien... et la solution à tout ça? Comment passer par référence avec un argument?

Mathieu

En passant par une fonction lambda, cela devrait fonctionner:
Code:

1 2 3 4 def resolution(self, etape): ... self.fen.after(50, lambda: self.resolution(etape))

11/05/2008, 17h11
_christophe_

Je ne comprends pas quel est l'intérêt de la variable 'etape' dans le code initial... ?
Si c'est un compteur, pourquoi ne pas le déclarer comme attribut de ta classe et l'incrémenter ?

Je ne comprends pas non plus pourquoi une fonction lambda permettrait d'échaper à l'erreur ? Elle va quand même faire appel à self.resolution, et donc induire une boucle infinie ?

##
Christophe

Bonsoir,

en fait, il n'y a pas que le paramètre etape, mais plein d'autres paramètres: c'était juste pour isoler le problème...

J'ai l'impression que le fait d'utiliser une fonction lambda permet bien de rafraîchir la fenêtre graphique à chaque récursion, mais cela ne fonctionne pas avec une boucle for.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 def resolution(self,etape):
        #procédure récursive
        #global compteursolutions
 
 
        "déplacement de la balle"
        global x1,y1,dx,dy,flag
        self.x1,self.y1=self.x1+self.dx,self.y1+self.dy
        if self.x1>210:
            self.x1,self.dx,self.dy=210,0,15
        if self.y1>210:
            self.y1,self.dx,self.dy=210,-15,0
        if self.x1<10:
            self.x1,self.dx,self.dy=10,0,-15
        if self.y1<10:
            self.y1,self.dx,self.dy=10,15,0
        self.gra.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30)
 
        if etape==1:
            for i in range(20):
                self.fen.after(50,lambda:self.resolution(etape+1))
 
                print 'la balle a bougé',etape
        else:
            print 'etape 2'

Ceci provoque directement le déplacement de la balle à sa dernière étape. Pouvez-vous m'éclairer sur ce mystère?

Mathieu

Bonjour,

j'ai de plus en plus de mal à comprendre comment fonctionne la mise à jour des fenêtre graphiques... Pour preuve considérez ces quelques lignes:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def resolution(self):
 
        "déplacement de la balle"
        global x1,y1,dx,dy
        self.x1,self.y1=self.x1+self.dx,self.y1+self.dy
        if self.x1>210:
            self.x1,self.dx,self.dy=210,0,15
        if self.y1>210:
            self.y1,self.dx,self.dy=210,-15,0
        if self.x1<10:
            self.x1,self.dx,self.dy=10,0,-15
        if self.y1<10:
            self.y1,self.dx,self.dy=10,15,0
        self.can.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30)
 
 
        for i in range(20):
                self.fen.after(50,self.resolution)
                print 'la balle a bougé'

Quand on appelle cette fonction, la balle change une fois de position au début, puis après s'arrête de bouger, mais les messages "la balle a bougé" continuent à s'afficher.
Si on remplace la ligne:

Code:

self.fen.after(50,self.resolution)

par
[CODE]

Code:

self.fen.after(50,resolution)

,
alors le message "la balle a bougé" ne s'affiche que 20 fois...

Mais ce qui est étonnant, c'est que sans la boucle for, avec simplement:

Code:

1
2
self.fen.after(50,self.resolution)
        print 'la balle a bougé'

,
on a bien le résultat escompté: la balle bouge régulièrement par petits intervalles et est synchronisé avec l'affichage sur la fenêtre bash.

(Le fait d'utiliser une boucle ici n'est que l'isolement d'un certain problème: le programme qui m'intéresse est autre, et une telle boucle y est vraiment nécessaire.)

Comment faire pour que l'affichage dans la fenêtre graphique soit le même avec et sans la boucle for?

Pour vous permettre de faire des tests, voici le programme complet du problème isolé:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
# -*- coding:Latin-1 -*-
 
 
from Tkinter import *
 
class Main:
 
 
    def __init__(self,boss=None):
        """Constructeur de la fenêtre principale"""        
        self.fen=Tk()
        self.fen.title('Jeu fou du chien')
 
        self.can=Canvas(self.fen,bg='dark grey')
        self.can.configure(width=620,height=620,bg='ivory')
 
        self.x1,self.y1=10,10    #coordonnées initiales
        self.dx,self.dy=15,0     #'pas' du déplacement
 
        self.oval1=self.can.create_oval(self.x1,self.y1,self.x1+30,self.y1+30,width=2,fill='red')
        self.can.pack(side=TOP,pady=5)
 
        self.fen.after(50,self.resolution)
 
        self.fen.mainloop()
 
 
 
    def demarrage(self):
 
        self.resolution()
 
 
 
 
    def resolution(self):
 
        "déplacement de la balle"
        global x1,y1,dx,dy
        self.x1,self.y1=self.x1+self.dx,self.y1+self.dy
        if self.x1>210:
            self.x1,self.dx,self.dy=210,0,15
        if self.y1>210:
            self.y1,self.dx,self.dy=210,-15,0
        if self.x1<10:
            self.x1,self.dx,self.dy=10,0,-15
        if self.y1<10:
            self.y1,self.dx,self.dy=10,15,0
        self.can.coords(self.oval1,self.x1,self.y1,self.x1+30,self.y1+30)
 
 
        for i in range(20):
                self.fen.after(50,self.resolution)
                print 'la balle a bougé'
 
        #avec lambda: tout bouge dés le début et s'arrête
        #sans lambda: continue à boucler car "la balle a bougé" s'affiche à l'écran, mais affichage graphique change soudainement au début puisse reste fixe
 
 
 
 
 
 
 
        #self.fen.after(50,self.resolution)
        #print 'la balle a bougé'
 
 
 
 
 
 
#programme principal:
if __name__=='__main__':
    Main()

Merci
Mathieu

16/05/2008, 11h20
Guigui_
c'est normal que ca bogue:
resolution est une fonction récursive (vue que tu l'as rapelle dans la boucle for) et tournue indéfiniment

La mise à jour d'une fenêtre graphique ne se réalise qu'à la fin du déroulement de la fonction sauf si tu lui forces le raffraichissement self.fen.update()

=>
Code:

1 2 3 4 5 6 ... for i in range(20): self.fen.after(50,self.resolution) self.fen.update() print 'la balle a bougé'

Bonjour,

Comme je n'avais jamais fait cela, j'ai recodé ton pb à ma manière. Peut-être pourras-tu t'en inspirer:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from Tkinter import *
import time
 
class Application(Frame):
 
    def __init__(self, master=None, larg=None, haut=None, diam=None):
        Frame.__init__(self, master)
 
        # sauvegarde des paramètres
        self.master = master
        self.larg = larg
        self.haut = haut
        self.diam = diam
 
        # création d'un layout_manager sur self
        self.grid()
 
        # création du canvas
        self.can = Canvas(self, width=self.larg, height=self.haut, bg='ivory')
        self.can.grid(sticky="nsew")
 
        # Création de la boule
        self.x, self.y = self.larg/2-self.diam/2, self.haut/2-self.diam/2    #coordonnées initiales
        self.dx, self.dy = 1, 2.2     #'pas' du déplacement
        self.boule = self.can.create_oval(self.x, self.y, self.x+self.diam, self.y+self.diam, width=2, fill='red')
 
    def demarre(self):
        # lancement
        while True:
            try:
                # calcule la nouvelle position    
                if self.x>self.larg-self.diam:
                    self.dx = -self.dx
                if self.y>self.haut-self.diam:
                    self.dy = -self.dy
                if self.x<0:
                    self.dx = -self.dx
                if self.y<0:
                    self.dy = -self.dy
                self.x, self.y = self.x+self.dx, self.y+self.dy
 
                # dessine la boule à la nouvelle position
                self.can.move(self.boule, self.dx, self.dy)
                self.master.update()
 
                # temporisation pour ralentir l'affichage
                time.sleep(0.003)
            except:
                break
 
########## => programme principal:
if __name__=='__main__':
    try:
        fen = Tk()
        fen.title('Jeu fou du chien')
        app = Application(fen, 600, 600, 50)
        fen.after(50,app.demarre)
        fen.mainloop()
    except:
        fen.destroy()
    finally:
        print "bye!"

Tyrtamos

17/05/2008, 15h42
Mathieu72
Merci à tous pour vos réponses...
Un problème connexe est alors la suspension temporaire d'une procédure complexe jusqu'à ce que l'utilisateur appuie sur un bouton. On dispose pour ça des 2 précédures, appelés par des boutons, rendus sensibles avec mainloop:
Code:

1 2 3 4 5 6 7 8 def stop_it(): "arret de l'animation" self.flag =0 def start_it(): "démarrage de l'animation" if self.flag ==0: # pour ne lancer qu'une seule boucle self.flag =1
J'avais bien pensé à quelque chose du genre:

Code:

while (self.flag==0):

inséré judicieusement dans la procédure à arrêter, mais sans grand succès... Pouvez-vous m'aider?

Mathieu
17/05/2008, 15h43
Mathieu72

Bien sûr, on souhaite que la procédure à arrêter reparte exactement là où on l'avait laissée, c'est là la difficulté.