tracé en animations

Version imprimable

tracé en animations

je cherche à tracer deux droites en animation: d'abord l'une puis l'autre. Mais seule la deuxième ligne est tracée. Si je supprime le tracé de la deuxième, il trace bien la première. Impossible de tracer d'abord la première, puis la seconde et d'obtenir deux droites parallèles.
Merci de votre aide.

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
from tkinter import *
''' tracer deux lignes horizontales parallèles en animation'''
def anim1():
    global xo,yo,x1,y1,x2,y2,dx,dy,flag
    x1=x1+dx                                    
    if x1>x2:flag=0
    y1=y1+dy
    if y1>y2:flag=0
    can1.create_line(xo,yo,x1,y1)
    if flag>0:
        fen1.after(10,anim1)                            
 
fen1=Tk()                                         # creation du widget principal
fen1.title("essai d'animation")
can1=Canvas(fen1,bg='ivory',height=600,width=800) # widget enfant
can1.pack(side=LEFT)
 
# première ligne
xo,yo=10,10                                      # coordonnées de l'origine
x1,y1=10,10                                      # coordonnées intermédiaires
x2,y2=400,100                                    # coordonnées du point à atteindre
dx,dy,flag=5,0,1                                 # pas du déplacement et commutateur
anim1()
 
# deuxième ligne
xo,yo=10,50
x1,y1=10,50
x2,y2=400,100
dx,dy,flag=5,0,1    
anim1()
 
fen1.mainloop()

Bonjour,

after() n'est pas bloquant pour l'interpréteur donc lorsque vous passez le premier anim1() et que vous sortez de la fonction Python continu à lire le code et vos valeurs (xo etc) sont remplacée par celles de la seconde ligne.
Un simple input entre les deux bloque l'interpréteur (il attend votre entrée) et vous montre que .after() est 'indépendant', comprendre par là que c'est l'interpréteur tcl/tk qui gère les événements.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 # première ligne xo,yo=10,10 # coordonnées de l'origine x1,y1=10,10 # coordonnées intermédiaires x2,y2=400,100 # coordonnées du point à atteindre dx,dy,flag=5,0,1 # pas du déplacement et commutateur anim1() #################### ici v = input() # deuxième ligne xo,yo=10,50 x1,y1=10,50 x2,y2=400,100 dx,dy,flag=5,0,1 anim1()
vous devez attendre la fin d'une ligne pour commencer l'autre.

@+

Ps: Pensez à la balise code (# en haut au dessus du texte)

26/06/2012, 14h50
develuc

Non, je suis désolé, mais ça ne fonctionne pas. J'obtiens la même chose...

Bonjour,

Citation:

Envoyé par develuc

Non, je suis désolé, mais ça ne fonctionne pas. J'obtiens la même chose...

Sans doute du fait que je ne vous apporte pas une 'solution' mais une 'explication'. Pour la 'solution' j'attendais la votre.
Pour l'explication voici quelques print pour essayer de vous rendre cela plus visuel.
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 from tkinter import * ''' tracer deux lignes horizontales parallèles en animation''' def anim1(): global xo, yo, x1, y1, x2, y2, dx, dy, flag print(xo, yo, x1, y1) ########################## < x1 += dx if x1 > x2: flag = 0 y1 += dy if y1 > y2: flag=0 can1.create_line(xo, yo, x1, y1) if flag > 0: fen1.after(10, anim1) fen1=Tk() # creation du widget principal fen1.title("essai d'animation") can1=Canvas(fen1, bg='ivory', height=600, width=800) # widget enfant can1.pack(side=LEFT) # première ligne xo, yo = 10, 10 # coordonnées de l'origine x1, y1= 10, 10 # coordonnées intermédiaires x2, y2= 400, 100 # coordonnées du point à atteindre dx, dy, flag = 5, 0, 1 # pas du déplacement et commutateur anim1() print('new line') ########################################### < # deuxième ligne xo, yo = 10, 50 x1, y1 = 10, 50 x2, y2 = 400, 100 dx, dy, flag = 5, 0, 1 anim1() fen1.mainloop()
Sortie
Code:

1 2 3 4 5 6 7 8 10 10 10 10 new line 10 50 10 50 10 50 15 50 10 50 20 50 10 50 25 50 10 50 30 50 ...
A vous de comprendre avec ce qui est dit plus haut.

Pour la solution, et il en existe pas mal, je pense que je passerais par une liste de liste (vos xo...) ou je traiterais chaque élément avant de le supprimer.

@+

26/06/2012, 19h44
PauseKawa

Re,

Je parle de liste de liste pour un traitement séquentiel (Qui le sera de toute manière: Par séquentiel ici comprendre traiter ligne après ligne).
Pour du 'simultané' je passerai par une instance de classe par ligne, ou même plus, une poller_routine avec une visit_method pour le tracé.

@+

Bon, ok: C'est pas cool comme réponse mais je préfère un 'je ne comprend pas' à 'cela ne fonctionne pas'.

Une réponse 'simple' à votre question sur base de liste:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from tkinter import *
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1(l):
    l[2] += l[6]
    l[3] += l[7]
    can1.create_line(l[0], l[1], l[2], l[3])
    if l[2] < l[4] and l[3] < l[5]:
        fen1.after(10, lambda: anim1(l))
 
fen1=Tk() # creation du widget principal
fen1.title("essai d'animation")
can1=Canvas(fen1, bg='ivory', height=600, width=800) # widget enfant
can1.pack(side=LEFT)
anim1([10, 10, 10, 10, 400, 100, 5, 0])
anim1([10, 50, 10, 50, 400, 100, 5, 0])
fen1.mainloop()

@+ et bon code.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from tkinter import *
 
''' tracer deux lignes horizontales parallèles en animation'''
def anim1(l):
    l[2] += l[6]
    l[3] += l[7]
    can1.create_line(l[0], l[1], l[2], l[3])
    if l[2] < l[4] and l[3] < l[5]:
        fen1.after(10, lambda: anim1(l))
 
fen1 = Tk()
fen1.title("essai d'animation")
can1 = Canvas(fen1, bg='ivory', height=600, width=800)
can1.pack(side=LEFT)
for l in ([10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]):
    anim1(l)
fen1.mainloop()

28/06/2012, 15h29
develuc

Merci pour ces réponses détaillées.
Ok pour 'comprendre' et 'fonctionne'.
J'ai réussi à tracer les deux courbes en même temps comme ce que vous me proposer, tout simplement par une boucle for...next, mais j’apprécie votre façon très élégante d'utiliser une liste.
Mais mon problème n'est pas là:
Je n'arrive pas à tracer les deux lignes L'UNE APRES L'AUTRE.
Il trace le début de la première et aussitôt passe à la seconde, et je ne comprends pas pourquoi!
Si je rajoute, sur vos conseils, une ligne input, il me demande tout de suite l'input AVANT de tracer LES courbes.
Je ne comprends pas pourquoi il ne trace pas la première courbe et me pose ensuite la question?
28/06/2012, 15h39
develuc

Ce que je ne comprends pas, c'est ceci:
Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!
Donc, ça , je ne comprends pas pourquoi ni comment!
Si je comprenais ça, je trouverais sans doute une solution à mon problème!

Cordialement
28/06/2012, 20h07
wiztricks
Salut,

Citation:

Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!

Ok, relisez le code:
Code:

1 2 for l in ([10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]): anim1(l)
çà appelle 2 fois anim1 avec des listes différentes...
La magie est dans "anim1":
Code:

1 2 3 def anim1(l): ... fen1.after(10, lambda: anim1(l))
qui se rappelle lui même tant que le tracé n'est pas terminé.
Comme chaque passage dans anim1 ne fait qu'un petit boût et attend 10ms pour tracer le bout suivant, les tracés se font "en même temps".
- W
28/06/2012, 21h19
PauseKawa

Bonsoir,

Maintenant que wiztricks vous a répéter que .after() n'est pas géré par Python si l'on a : l = [[10, 10, 10, 10, 400, 100, 5, 0], [10, 50, 10, 50, 400, 100, 5, 0]] (pour rester dans les listes)
Vous comprendrez que si vous traitez l[x] à chaque fois (l[x][y]) et que lorsque vous en avez fini avec l[x] vous le supprimez (l.pop(x)/l.pop() > (Stacks & Queues)) vous pouvez utiliser votre liste comme file d'attente pour votre animation.

A vous ;)
28/06/2012, 21h33
wiztricks
Salut,

Citation:

Envoyé par PauseKawa

Maintenant que wiztricks vous a répéter que .after() n'est pas géré par Python

Etre géré par Python ou d'autres indiens n'a pas grande importance.

L'important est qu'il s'agit d'un "timer".
Son appel va déclencher dans 10 ms un nouvel appel à une "chose".
La "chose" construite par "lambda" est une nouvelle fonction.
Elle est construite à partir d'anim1 et d'une liste de valeurs en paramètres.

Il est certes plus rapide et bien plus précis d'écrire cela ainsi:
Code:

1 2 3 def anim1(l): ... fen1.after(10, lambda: anim1(l))
Je ne suis pas certain qu'on ne puisse pas raconter cela avec une partition musicale, mais c'est pas le bon forum ;-(

- W
28/06/2012, 22h00
PauseKawa

Bonsoir,

Citation:

Envoyé par wiztricks

Je ne suis pas certain qu'on ne puisse pas raconter cela avec une partition musicale, mais c'est pas le bon forum ;-(

En gros oui: La gestion des événements programmés est une partition lue par le(les) gestionnaire(s) d’événement (que cela soit l'interpréteur Python ou Tcl).
J'aime bien cette métaphore ;) (Et cela apporte une touche musicale à mon approche zen attitude de Python).

Le gros problème de develuc c'est ici:

Citation:

Envoyé par develuc

Ce que je ne comprends pas, c'est ceci:
Dans votre code vous avez deux appels de fonction anim1 en ligne 15 et 16.
Donc le programme lit la première qui lui demande de tracer une droite, puis ENSUITE lit la deuxième qui lui demande de tracer une deuxième droite.
Or il trace les deux ensemble!
Donc, ça , je ne comprends pas pourquoi ni comment!
Si je comprenais ça, je trouverais sans doute une solution à mon problème!

Sauf 'blocage' (if, pile comme dit plus haut, etc) le 'code' (dans ce cas, passons outre pour le PO) est lu 'ligne par ligne': Comme vous ne bloquez pas le départ de la seconde ligne le code 'suit son cours'.

J'espère que cela est assez imagé.

@+
29/06/2012, 01h48
develuc

Un grand merci à vous deux, et pour les explications, et pour la patience!
Je vais méditer tout cela.

Bonjour,

Un petit coup de pouce basé sur les listes (puisque j'étais parti sur cela).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 from tkinter import * ''' tracer deux lignes horizontales parallèles en animation''' def anim1(): if l: l[0][2] += l[0][6] l[0][3] += l[0][7] can1.create_line(l[0][0], l[0][1], l[0][2], l[0][3]) if l[0][2] >= l[0][4] and l[0][3] >= l[0][5]: l.pop(0) fen1.after(10, anim1) fen1 = Tk() fen1.title("essai d'animation") can1 = Canvas(fen1, bg='ivory', height=600, width=800) can1.pack(side=LEFT) l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0], [10, 100, 10, 100, 400, 10, 5, 0], [10, 150, 10, 150, 400, 10, 5, 0]] anim1() fen1.mainloop()
Comme vous le voyez ici anim1 ne travaille que sur le premier élément (liste[index]) de la liste et le retire (pop(0)) lorsque la condition est atteinte (if l[0][2] >= l[0][4] and l[0][3] >= l[0][5]). Cela tourne jusqu'au moment ou la liste est vide (if l).
Vous noterez la dépendance de la condition au contenu de la liste (...400, 10...) et cela fonctionne ici car nous savons qu'il c'est une incrémentation (>=)
Code:

1 2 l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0], [10, 100, 10, 100, 400, 100, 5, 5], [10, 150, 10, 150, 400, 100, 5, 5]]
Maintenant il est aussi possible d'utiliser lambda pour la condition
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 from tkinter import * ''' tracer deux lignes horizontales parallèles en animation''' def anim1(): if l: l[0][2] += l[0][6] l[0][3] += l[0][7] can1.create_line(l[0][0], l[0][1], l[0][2], l[0][3]) if cond(l): l.pop(0) fen1.after(10, anim1) fen1 = Tk() fen1.title("essai d'animation") can1 = Canvas(fen1, bg='ivory', height=600, width=800) can1.pack(side=LEFT) l = [[10, 10, 10, 10, 400, 10, 5, 0], [10, 50, 10, 50, 400, 10, 5, 0], [10, 100, 10, 100, 400, 100, 5, 5], [10, 150, 10, 150, 400, 100, 5, 5]] cond = lambda lst: lst[0][2] >= lst[0][4] and lst[0][3] >= lst[0][5] anim1() fen1.mainloop()
A noter:
Je n'utilise pas ici d'arguments pour anim1 car cond et l sont dans son espace de nom global.
Nous travaillons ici sur une même et seule liste l. Pas bien grave puisque seul la fonction anim1 la modifie. Attention si vous utilisez plusieurs fonctions pour un même objet.

Voila pour ce qui est des listes.

@+ et bon code

29/06/2012, 16h22
develuc

Je viens, grâce à vous de faire un bond prodigieux dans mes capacités en Python!
Le vieux débutant est très contant!
Merci
29/06/2012, 21h18
PauseKawa

Bonsoir,

Dans ce cas puis je vous recommander d'éviter une erreur que j'ai commis en tant qu’autodidacte ? Ne pas suivre un tuto.
Vous allez me dire qu'avec notre expérience (j'ai encore le temps pour la retraite mais je suis bien loin de la période fac :roll:) nous n'en avons pas besoin mais c'est une erreur: Plus que de présenter le langage cela apporte aussi la 'philosophie du langage' (Je suis trop 'zen' ? Je sais.).
Puisque vous partez sur Tkinter je me permet de vous proposer celui de Gérard Swinnen.

Bon code et @+
01/07/2012, 21h41
develuc

merci pour vos encouragements.
J'ai 'avalé' le G.Swinnen avec grand plaisir. J'ai démarré Python au début de 2010 et je me régale! J'ai déjà "écrit" de très nombreux scripts et je trouve toujours de quoi me décrasser les méninges!. Mai c'est parfois difficile pour un débutant âgé!.
Merci et A+ avec plaisir.
01/07/2012, 21h48
PauseKawa

Citation:

Envoyé par develuc

Mai c'est parfois difficile pour un débutant âgé!.

C'est bien souvent plus dur pour les jeunes ;)

@+ et bon code