animation qui accélère...

**FOCCUS** · 14/04/2018, 19h22

Bonjour,

J'ai écrit un programme Python de déplacement de billes dans un cadre avec rebondissement sur les bords du cadre. J’ai voulu placer le nombre de billes N en paramètre pouvant être modifié par l’utilisateur ( bouton Entry). Ca marche, sauf que lorsque l’utilisateur change la valeur de N, on obtient un message d’erreur :

Exception in Tkinter callback
Traceback (most recent call last):
File "/usr/local/Cellar/python3/3.6.4_2/Frameworks/Python.framework/Versions/3.6/lib/python3.6/tkinter/init.py", line 1699, in __call_
return self.func(*args)
File "/usr/local/Cellar/python3/3.6.4_2/Frameworks/Python.framework/Versions/3.6/lib/python3.6/tkinter/init.py", line 745, in callit
func(*args)
File "/Users/foccus/Desktop/Python/Code2/tes1.py", line 13, in deplace
self.x=canvas.coords(balle[self.i])[2]
IndexError: list index out of range

Le programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
from tkinter import *
from random import *
 
class bille:
    def __init__(self):
        self.i=0
        self.x=0
        self.y=0
        self.dx=0
        self.dy=0
    def deplace(self,balle):
        canvas.move(balle[self.i],self.dx,self.dy)
        self.x=canvas.coords(balle[self.i])[2]
        self.y=canvas.coords(balle[self.i])[3]
        bille.mur(self)
        tk.after(20,bille.deplace,self,balle)
 
    def mur(self):
        i=self.i
        if not(20 < self.y < 310):
            self.dy=(-1)*self.dy
        if not(20 < self.x < 470):
            self.dx=(-1)*self.dx
 
def demarrer():
    global N,tx,ty,tdx,tdy,balle
    canvas.delete(ALL)
    EN=entree_N.get()
    N=int(EN)
    tx,ty,tdx,tdy,balle=[1]*N,[1]*N,[1]*N,[1]*N,[1]*N
    for l in range(N):
        tx[l],ty[l]=randint(30,420),randint(30,250)
        tdx[l],tdy[l]=4,4
    for i in range(N):
        balle[i]=canvas.create_oval(tx[i],ty[i],tx[i]+15,ty[i]+15,fill='red',outline='black')
    for i in range(N):
        p=bille()
        p.i=i
        p.x=tx[i]
        p.y=ty[i]
        p.dx=tdx[i]
        p.dy=tdy[i]
        p.deplace(balle)
 
#Programme Principal
tk=Tk()
canvas=Canvas(tk,width = 480, height = 320 , bd=0, bg="white")
canvas.pack()
#Creation d'un bouton "Démarrer"
Boutton_Demarrer=Button(tk,text="Démarrer",command=demarrer)
Boutton_Demarrer.pack(side=LEFT)
#Creation d'un bouton "Detruire":
Bouton_Detruire=Button(tk, text ='Quitter', command = tk.destroy)
#Ajouter l'affichage du bouton dans la fenêtre tk:
Bouton_Detruire.pack(side=RIGHT)
 
 
# Nombre de balles N
entree_N=Entry(tk,width=3)
entree_N.pack()
 
#Boucle principale:
tk.mainloop()

**wiztricks** · 14/04/2018, 22h13

Salut,

Envoyé par FOCCUS

Ca marche, sauf que lorsque l’utilisateur change la valeur de N, on obtient un message d’erreur :

Exception in Tkinter callback
...
IndexError: list index out of range_

L'erreur est due à cette instruction: self.x=canvas.coords(balle[self.i])[2].
Lorsque canvas.delete(ALL) a détruit toutes les balles, les "callbacks" lancés via
tk.after(20, bille.deplace, self, balle) existent toujours et référencent les anciens bille et balle. balle[self.i] a garder l'identifiant d'un item qui n'existe plus et canvas.coords retourne une liste vide. Et si la liste est vide, son deuxième élément est "out of range".
Pour regarder çà, lancer l'interpréteur Python:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> import tkinter as tk
>>> canvas = tk.Canvas()
>>> iid = canvas.create_oval(0, 0, 100, 100)
>>> iid
1
>>> canvas.coords(iid)
[0.0, 0.0, 100.0, 100.0]

Juste là çà fonctionne normalement.
Puis on détruit l'item 1:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
>>> canvas.delete(iid)
>>> canvas.coords(iid)
[]
>>>

Et voilà.

- W

**FOCCUS** · 14/04/2018, 22h48

Merci! Mais alors, comment corriger svp !

**wiztricks** · 15/04/2018, 10h57

Comment çà comment corriger?
Vous pourriez simplement tester que la liste retournée par .coords(...) n'est pas vide avant d'essayer de piocher dedans.
Ou bien, puisque c'est l'effet de bord des "callbacks" qui survivent au canvas.delete('ALL'), vous pourriez regarder comment les supprimer avec .after_cancel. Ce qui vous obligerait à avoir une liste de billes (et reconsidérer l'intérêt de vos autres listes "globales").
Et partant d'une liste de billes, pourquoi ne pas avoir un seul callback qui fasse bouger tous les éléments de cette liste plutôt qu'un callback par élément.

Ce ne sont pas les solutions à explorer qui manquent...

- W

**FOCCUS** · 16/04/2018, 12h06

Merci. J'ai corrigé par un test. J'ai pas encore le courage d'utiliser after.cancel et tout revoir

**wiztricks** · 16/04/2018, 16h57

Envoyé par FOCCUS

J'ai pas encore le courage d'utiliser after.cancel et tout revoir

Ah ben, combien de fois avez vous jetez vos brouillons lors de la préparation de vos devoirs de français? Il faut apprendre à refaire mieux:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
from tkinter import *
from random import *
 
class Ball:
    def __init__(self, x, y, dx, dy):
        self.iid = canvas.create_oval(
            x, y, x + 15, y + 15,
            fill='red',
            )
        self.x = x
        self.y = y
        self.dx = dx
        self.dy = dy
 
    def move(self):
        canvas.move(self.iid, self.dx, self.dy)
        # si collision avec les bords, rebond élastique.
        self.x += self.dx
        if not(20 < self.x < 470):
            self.dx = -self.dx
        self.y += self.dy
        if not(20 < self.y < 310):
            self.dy = -self.dy
 
 
balls = []
 
def move_balls(delay=20):
    if balls: # s'il reste des Ball...
        for b in balls:
            b.move()
        root.after(delay, move_balls)
 
def demarrer():
    count = int(entree.get())
    canvas.delete(ALL)
    balls[:] = [] # on vide la liste.
    for _ in range(count):
        balls.append(Ball(randint(30,420),randint(30,250), 4, 4))
    move_balls()
 
if __name__ == '__main__':
    root = Tk()
    canvas = Canvas(root,width = 480, height = 320 , bd=0, bg="white")
    canvas.pack()
 
    Button(root,text="Démarrer",command=demarrer).pack(side=LEFT)
 
    Button(root, text ='Quitter', command = root.destroy).pack(side=RIGHT)
 
    entree = Entry(root,width=3)
    entree.pack()
    mainloop()

- W

**FOCCUS** · 17/04/2018, 11h53

Merci, c'est riche, c'est sympa !!!

Le programme que vous m'avez envoyé ne tourne pas. Il y a un problème d'argument à Ball, manque canvas. Ensuite tk n'existe pas.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
from tkinter import *
from random import *
 
class Ball:
    def __init__(self,canvas, x, y, dx, dy):
        self.iid = canvas.create_oval(
            x, y, x + 15, y + 15,
            fill='red',
            )
        self.x = x
        self.y = y
        self.dx = dx
        self.dy = dy
 
    def move(self):
        canvas.move(self.iid, self.dx, self.dy)
        # si collision avec les bords, rebond élastique.
        self.x += self.dx
        if not(20 < self.x < 470):
            self.dx = -self.dx
        self.y += self.dy
        if not(20 < self.y < 310):
            self.dy = -self.dy
 
 
balls = []
 
def move_balls(delay=20):
    if balls: # s'il reste des Ball...
        for b in balls:
            b.move()
        root.after(delay, move_balls)
 
def demarrer():
    count = int(entree.get())
    canvas.delete(ALL)
    balls[:] = [] # on vide la liste.
    for _ in range(count):
        balls.append(Ball(canvas, randint(30,420),randint(30,250), 4, 4))
    move_balls()
 
if __name__ == '__main__':
    root = Tk()
    canvas = Canvas(root,width = 480, height = 320 , bd=0, bg="white")
    canvas.pack()
 
    Button(root,text="Démarrer",command=demarrer).pack(side=LEFT)
 
    Button(root, text ='Quitter', command = root.destroy).pack(side=RIGHT)
 
    entree = Entry(root,width=3)
    entree.pack()
    root.mainloop()

**FOCCUS** · 17/04/2018, 12h03

Le programme que vous m'avez envoyé ne répond pas vraiment au problème posé. Ici, les balles se déplacent d'une manière groupée. Il n'y a pas de dynamique individuelle, sporadique. Par ailleurs, quand on change N, le mouvement s'accélère.

**wiztricks** · 17/04/2018, 12h33

J'ai corrigé les fautes de frappes précédentes (l'argument en trop et le tk. qui traînait).

Le mouvement qui s'accélère et sporadique est volontaire: à vous de trouver pourquoi et réfléchir à la chronologie des évènements. Si vous ne vous en sortez pas je posterai une correction.

Pour ce qui est des balles groupées, c'est un détail qui n'a aucun intérêt (il suffit d'avoir des vitesses différentes mais çà ne change pas grand chose au code ni à la compréhension de tkinter).

- W

**FOCCUS** · 17/04/2018, 13h00

Pour la vitesse Ok :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
def demarrer():
    count = int(entree.get())
    canvas.delete(ALL)
    balls[:] = [] # on vide la liste.
    for _ in range(count):
        balls.append(Ball(canvas, randint(30,420),randint(30,250), randint(1,4), randint(1,4)))
    move_balls()

**FOCCUS** · 18/04/2018, 17h09

J’ai terminé le code que je voulais faire en me basant sur les grandes améliorations apportées pas wiztricks que je remercie.
En fait, le but du code c’était de créer une dynamique d’interaction entre les individus, afin de simuler les situations décrites dans l’article*:

https://foccus-carthage.com/modelisa...es-oligarchie/

On considère donc un ensemble de particules en interaction selon les règles suivantes*:
1- Chaque particule i dispose d’une énergie vitale E(i).
2- A chaque pas de temps, l’énergie de la particule augmente légèrement.
3- Quand la particule rebondit sur le bord, son énergie diminue un peu.
4- Les particules sont en interactions : Quand elles rentrent en collision, la plus forte (celle dont l’énergie est plus grande) prend de l’énergie sur l’autre.

Pour visualiser les interactions, on colore les particules en fonction de l’intensité de leur énergie.

L’objet de l’étude est de comprendre pourquoi certaines particules deviennent riches et d’autres restent pauvres et d’étudier les différentes situations.

Voici le code correspondant, bonne lecture.

J’espère qu’on m’aidera à l’améliorer. (Surtout comment faire pour que les vitesses n’augmentent pas quand N augmente).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
76
77
78
79
80
81
82
83
84
85
86
 
from tkinter import *
from random import *
from math import *
 
class Ball:
    def __init__(self, x, y, dx, dy, E):
        self.iid = canvas.create_oval(
            x, y, x + 15, y + 15,
            fill='red',
            )
        self.x = x
        self.y = y
        self.dx = dx
        self.dy = dy
        self.E=E
 
    def move(self):
        global color,NC
        canvas.move(self.iid, self.dx, self.dy)
        #alimenter régulièremment la particule
        a=0.002
        self.E=min(self.E+a,NC-1)
        # si collision avec les bords, rebond élastique.
        p=0.15
        self.x += self.dx
        if not(20 < self.x < 470):
            self.dx = -self.dx
            self.E=max(self.E-p,0)
        self.y += self.dy
        if not(20 < self.y < 310):
            self.dy = -self.dy
            self.E=max(self.E-p,0)
        canvas.itemconfigure(self.iid, fill = color[int(self.E)])
 
#Couleur des balles
color=['azure','alice blue','lavender','yellow' ,'gold','gold2','gold3','goldenrod','deep sky blue','dodger blue','cornflower blue', 'blue','cadet blue','spring green','green','green2','green3','green4','peru', 'chocolate', 
       'orange', 'violet', 'HotPink1',  'HotPink2',  'HotPink3', 'HotPink4',  'purple',  'red',   'firebrick1',   'firebrick2',  'firebrick3', 'firebrick4', 'violet red',   'medium violet red',  'maroon',  'maroon1', 'maroon2', 'maroon3',              
       'maroon4',  'magenta4',  'VioletRed4',   'plum4',  'orchid4',  'MediumOrchid4','DarkOrchid4' ,  'purple4'] 
NC=len(color)
 
balls = []
 
def move_balls(delay=20):
    if balls: # s'il reste des Ball...
        for b in balls:
            b.move()
        col_balls()
        root.after(delay, move_balls)
 
# fonction gérant les collisions entre les particules
def col_balls():
    global NC
    r=0.001
    for i in balls:
       for j in balls:
         d=sqrt((i.x-j.x)**2+(i.y-j.y)**2)
         if d>0 and d<10:
              i.dx=-i.dx
              i.dy=-i.dy
              j.dx=-j.dx
              j.dy=-j.dy
              S=copysign(1,i.E-j.E)
              i.E=min(max(i.E+S*(r/d),0),NC-1)
              j.E=min(max(j.E-S*(r/d),0),NC-1)
 
def demarrer():
    count = int(entree.get())
    canvas.delete(ALL)
    balls[:] = [] # on vide la liste.
    for _ in range(count):
        balls.append(Ball(randint(30,420),randint(30,250), randint(1,4), randint(1,4),0))
    move_balls()
 
if __name__ == '__main__':
    root = Tk()
    canvas = Canvas(root,width = 480, height = 320 , bd=0, bg="white")
    canvas.pack()
 
    Button(root,text="Démarrer",command=demarrer).pack(side=LEFT)
 
    Button(root, text ='Quitter', command = root.destroy).pack(side=RIGHT)
 
    entree = Entry(root,width=3)
    entree.pack()
    root.mainloop()

**wiztricks** · 19/04/2018, 08h42

Envoyé par FOCCUS

J’espère qu’on m’aidera à l’améliorer. (Surtout comment faire pour que les vitesses n’augmentent pas quand N augmente).

La vitesse augmente pour la même raison: les callbacks en cours survivent et on en crée d'autres à chaque fois.
Ca se passe dans demarrer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
def demarrer():
    count = int(entree.get())
    canvas.delete(ALL)
    balls[:] = [] # on vide la liste.
    for _ in range(count):
        balls.append(Ball(canvas, randint(30,420),randint(30,250), 4, 4))
    move_balls()

Car la condition if balls: dans le callback:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def move_balls(delay=20):
    if balls: # s'il reste des Ball...
        for b in balls:
            b.move()
        root.after(delay, move_balls)

n'est jamais vraie puisque lorsque démarrer se termine, il y aura de nouvelles balles et move_balls n'a aucune chance de s'exécuter "pendant" que démarrer s’exécute.

La solution est d'appeler move_balls une seule fois (juste avant d'entrer dans la mainloop) et de supprimer le "if balls".

- W

**FOCCUS** · 19/04/2018, 11h06

Ca marche,Merci!

animation qui accélère...

Tkinter Python

Discussions similaires

Partager

Partager