[Tkinter] Collision de lignes

Version imprimable

04/01/2006, 21h07
frky

[Tkinter] Collision de lignes

Bonjour à tous,

J'ai créé 2 lignes qui tournent et je voudrais savoir qd elles rentrent en collision. J'ai aucune idée sur le sujet tous vos conseils me seront utiles.

merci d'avance
04/01/2006, 21h27
loufoque

2 lignes qui tournent !?
04/01/2006, 21h52
frky

Excuse je complete la description :
c'est en fait deux lignes qui pivotent par rapport a une de leur extrémité. vu qu'elles tourne a des vitesses différentes et n'ont pas la meme longuer elles vont se rentrer dedans au bout d'un moment. Je voudrais savoir si il y a une commande qui peut renseigner sur une eventuelle collision entre deux ligne ou entre deux objet.
merci d'avance
04/01/2006, 22h14
Guigui_

Si tu ne précises par la bibliothèque graphique utilisée, ce sera dur.

http://www.developpez.net/forums/vie...ight=collision ?
04/01/2006, 22h37
frky

en fait c'est sous tkinter
c'est assez interressant mais ca ne fonctionne qu'avec des formes pleines type rond, carré...
Le probleme avec les collisions de lignes c une collision possible en tout point de cette ligne et donc le calcul par rapport au centre marche pas dans ce cas la.
je me sert de create_line pour l'afficher ensuite mais estce qu'il va falloir que je definisse l'équation des deux droites et verifier si elles ont des point commun?
05/01/2006, 00h04
lifido

:) ta de la chance, justement, c'est sur qoui, je refrechits ( pour faits un jeux ,100%Tkinter)
oui, il y aun moyen, de savoi, si l'element 1, va ou a toucher l'element 2
je vais te laisser chercher un peut, car sa ma prits +++++++++ de temps
aide

aide

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def da():
    c.move(1,1,0)
    c.move(2,-1,0)
    a   =c.bbox(1)
    b   =c.bbox(2)
 
    print c.find_enclosed(a[0]-5,a[1]-5,a[2]+5,a[3]+5)
    fen.after(50,da)
 
 
from Tkinter import*
fen =Tk()
c=Canvas()
c.grid()
c.create_text(0,50,text="a")     
c.create_text(300,50,text="b")  
da()
fen.mainloop()

regarde ta sorti de console,

05/01/2006, 11h01
frky

pas mal ca doit pouvoir m'aider

je vous tiens au courant
05/01/2006, 19h06
lifido

si tu veutx, je peut te dailler le scripts, si ta du mal a comprendre
05/01/2006, 19h17
frky

bon je suis toujours pas arrivé
je suis aller voir la definition du find_enclosed(x1,y1,x2,y2)
les coordonnées doivent definir un rectangle mais comment se construit il?
Que definisse les x et y?
et puis ca marche dans ton exemple vu que c'est une ligne droite mais le rectangle suivra t'il une ligne qui pivote par rapport a une des extremité?

rappellle,
dans un fenetres cavas, chaque elements, afficher, lui est affecter, un nureros, celonts l'orde entrees, dans le scripts

.find_enclosed(x1,y1,x2,y2) , oui c'est un rectangle
defini, la zonne, dans le cavas, ou il ya un elements, si no il sorte () si oui, il sorte (x,),
c'est comme un vise, qui de dit oui il y a queque chose, devants lui (x) un ou pluiseur chose (x,x,x,x,x,) image, text, carrer, rectangle, line...., ou no ()
il ya aussi .find_closest, lui, il indique, si il ya un elements a se point

dans mon exemple
j'utulise .bbox(1) pour connaitres les coodornne, instantanner de la lettres "a", le 1 est dornner par canvas, car l'ordres, que j'ai mit etaits
Code:

1 2 c.create_text(0,50,text="a") c.create_text(300,50,text="b")
que sauve sur la variable dans a, qui me donne sous la forme d'une liste (10,20,3,25)
que j'envoits sur

Code:

print c.find_enclosed(a[0]-5,a[1]-5,a[2]+5,a[3]+5)

le -5, que tu voits, on peut dire, que c'est la precition, de la dection du colison
Il noust sorte du (1,), juste a la colision de "b", qui nous sorte (1,2,)
sa veut dire, que 1 et 2, sont ensemble 1="a" et 2="b"
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 def da(): c.move(1,1,0) #deplace le 1(la lettres a), de 1x et 0y c.move(2,-1,0) #depla le 2(b), de -1x,0y a =c.bbox(1) #recuper la taille et emplacement de 1(a) b =c.bbox(2) #idem, juste pour faire beaux #rechercher se qui contients, comment elements sur se retacque, qui et en mouvements, avec le 1(a), et affiche sa sorti print c.find_enclosed(a[0]-5,a[1]-5,a[2]+5,a[3]+5) fen.after(50,da) #veut apres 50ms, retourne sur def da from Tkinter import* fen =Tk() c=Canvas() c.grid() c.create_text(0,50,text="a") #le nombre 1 luis et doner automatiquement c.create_text(300,50,text="b") #le nombre 2 " " " " " da() fen.mainloop()
oui, sa marche dans touts les mouvements les plus foux,
comemnt, j'essai, de faire un boobman, avec cette methode

si no envoits moi ton code,

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
def da():
    c.move(1,1,0)
    c.move(2,-1,0)
    a   =c.bbox(1)
 
    #dessinner le rectangle
    c.coords(3,a[0]-5,a[1]-5,a[2]+5,a[3]+5)
    d   =c.find_enclosed(a[0]-5,a[1]-5,a[2]+5,a[3]+5)
    print d
    if d!=(1,):
        print d,'toucher'
    fen.after(50,da)
 
 
 
from Tkinter import*
fen =Tk()
c=Canvas()
c.grid()
c.create_text(0,50,text="a")     #1
c.create_text(300,50,text="b")      #2
c.create_rectangle(0,0,0,0)     #3
da()
fen.mainloop()

j'ai ajouter, les ligne
pour voir le rectangle desinner autour de la lettre a

Code:

1
2
c.create_rectangle(0,0,0,0)     #3
 c.coords(3,a[0]-5,a[1]-5,a[2]+5,a[3]+5)

alors ca marche pas dans mon cas de figure car le rectangle qui se forme est trop grand et ne colle pas au pivot que je veux.
il prend l'origine de mon pivot puis son extremité et effectue les projeté pour tracé le rectangle ce qui va pas du tout

Mon but est d'afficher un message dans une petit fenetre disant qu'il y a collision entre les deux pivots.
je te donne un version allégé de mon programme pour que tu comprenne comment ca marche.
Si tu connais la solution pour reperer la collision entre les deux merci d'avance de m'expliquer comment. :wink:

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
76
77
 
from Tkinter import *
from math import *
import time, string
import threading
import sys
 
def transfo_ang(angle_degre):
    angle_radian=angle_degre*pi/180
    return angle_radian
 
class MyPivot:
    def __init__(self, orgX, orgY, longueur,  angleBut1, angleDeg, angleBut2, w, sens_rotation, epaisseur, couleur):      #sens_rotation:  taper trigo ou antitrigo 
        self.orgX = orgX                                                                                                                                  #w est exprimé en deg/s                                                                              
        self.orgY = orgY                                                                                                                                  #angleDeg, angleBut1, angleBut2 en degré (angleBut1<angleBut2)
        self.epaisseur = epaisseur
        self.couleur = couleur
        self.longueur = longueur
        self.angleDeg = angleDeg
        self.w = w
        angleRad = transfo_ang(self.angleDeg)
        self.angleBut1 = angleBut1
        self.angleBut2 = angleBut2
        self.extX=self.longueur*cos(angleRad)+orgX
        self.extY=-self.longueur*sin(angleRad)+orgY
        self.ligne=None
        self.sens_rotation=sens_rotation
        if sens_rotation == 'antitrigo':
            self.sens=-1
        else :
            self.sens=1 
 
    def inverse_sens(self):
        if (self.angleBut1 != None) & (self.angleBut2 != None):
            if (self.angleDeg >= self.angleBut2):
                self.angleDeg=self.angleBut2
                self.sens=-self.sens
            if (self.angleDeg <= self.angleBut1):
                self.angleDeg=self.angleBut1
                self.sens=-self.sens
 
    def afficher(self, windowParent):
        windowParent.delete(self.ligne)
        self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur)
 
    def rotation(self, nouvelAngle):
        self.angleDeg = nouvelAngle
        self.inverse_sens()
        self.angleRad = transfo_ang(self.angleDeg)
        self.extX=self.longueur*cos(self.angleRad)+self.orgX
        self.extY=-self.longueur*sin(self.angleRad)+self.orgY
 
class MyWindow(Canvas):
    def __init__(self, boss, longueur, largeur):
        Canvas.__init__(self, width = longueur, height = largeur)
        self.longueur = longueur
        self.largeur = largeur
        self.create_line(2,2,2,100, width=2, fill='black', arrow=LAST)
        self.create_line(2,2,100,2, width=2, fill='black', arrow=LAST)
 
def move():
        delta_t=500  #tps de rafraichissement exprimé en ms 
        myPivot1.afficher(myWindow1)
        myPivot2.afficher(myWindow1)
        myPivot1.rotation(myPivot1.angleDeg + myPivot1.sens*(myPivot1.w*delta_t/1000))
        myPivot2.rotation(myPivot2.angleDeg + myPivot2.sens*(myPivot2.w*delta_t/1000))
        fen.after(delta_t, move)
 
if __name__ == '__main__': 
    fen =Tk()
    fen.title("deux pivots")
    myWindow1 = MyWindow(fen, 800, 600)
    myPivot1 = MyPivot(400, 300, 290, None, 130, None, 2, 'trigo', 3, 'yellow')
    myPivot2 = MyPivot(25, 25, 300, 280, 290, 350, 2, 'antitrigo', 3, 'green')
    move()
    myWindow1.pack(side=LEFT)
    fen.mainloop()

07/01/2006, 00h59
lifido

j'y travaille dessus,
a periorits, ma methode ne marche pas sur ton scripts ;(
07/01/2006, 11h09
duplo

en fait pour que cela puisse fonctionner correctement il faudrait pouvoir definir un poligone plutôt qu'un rectangle
si non tu peut utiliser .find_closest si tu range tes point dans un tableau avec une boucle sa devrait etre assé rapide a verifier
+
07/01/2006, 13h22
frky

Je suis parti sur une autre méthode hier qui consiste a creer 4 droites pour encadrer un pivot et avec une condition qui analyse les coordonnées de l'extremité de l'autre pivot pour savoir si elle est dans la zone defini par les 4 droites.
Je fini de tester ca et je vous montrerai le code.
Si vous avez trouvé une autre solution un peu moins lourde je veux ien la regarder :P
07/01/2006, 13h23
frky

et merci de m'aider !!!!

:(
ton scripts est beaux, et tres compliques, avec touts ces variables a rallonge, :)
Code:

1 2 3 def afficher(self, windowParent): windowParent.delete(self.ligne) self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur)
pour def afficher,
utuliser

Code:

.coords()

pour redessiner la ligne, et ça le deplacer en même temps

si no, pour ma methodes (.find_....) ne marche pas tros dans ton cas
le nom de ta Cavans n'a pas le meme nom,

, il faudras, refaits le scripts, et plus allerger, et plus lineaires en retirrants les class
desoler je ne peuts pas tros d'aide ;(

08/01/2006, 19h47
frky

Ok merci qd meme , j'ai reussi a effectuer la detection avec l'encadrement des pivots et ca marche tres bien meme si c'est un peu lourd et compliqué.
si tu veux le voir je te le posterai
autrement merci de tout l'interet que tu as porté a mon probleme.
@+
09/01/2006, 00h17
lifido

si t'as reusir , c'est bon signe
faist voir, le nouveux scpits
np

bon ben voila ce que ca donne .
je comprendrait les remarque disant que c'est un peu lourd mais je suis pas informaticien de formation, juste un etudiant à qui on a donné un projet.

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
from Tkinter import *
from math import *
import time, string
import threading
import sys
 
def transfo_ang(angle_degre):
    angle_radian=angle_degre*pi/180
    return angle_radian
 
class MyPivot:
    def __init__(self, orgX, orgY, longueur,  angleBut1, angleDeg, angleBut2, w, sens_rotation, epaisseur, couleur):      #sens_rotation:  taper trigo ou antitrigo 
        self.orgX = orgX                                                                                                                                  #w est exprimÃ© en deg/s                                                                              
        self.orgY = orgY                                                                                                                                  #angleDeg, angleBut1, angleBut2 en degrÃ© (angleBut1<angleBut2)
        self.epaisseur = epaisseur
        self.couleur = couleur
        self.longueur = longueur
        self.angleDeg = angleDeg
        self.w = w
        angleRad = transfo_ang(self.angleDeg)
        self.angleBut1 = angleBut1
        self.angleBut2 = angleBut2
        self.extX=self.longueur*cos(angleRad)+orgX
        self.extY=-self.longueur*sin(angleRad)+orgY
        self.ligne=None
        self.sens_rotation=sens_rotation
        if sens_rotation == 'antitrigo':
            self.sens=-1
        else :
            self.sens=1 
 
    def inverse_sens(self):
        if (self.angleBut1 != None) & (self.angleBut2 != None):
            if (self.angleDeg >= self.angleBut2):
                self.angleDeg=self.angleBut2
                self.sens=-self.sens
            if (self.angleDeg <= self.angleBut1):
                self.angleDeg=self.angleBut1
                self.sens=-self.sens
 
    def afficher(self, windowParent):
        windowParent.delete(self.ligne)
        self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur)
 
    def rotation(self, nouvelAngle):
        self.angleDeg = nouvelAngle
        self.inverse_sens()
        self.angleRad = transfo_ang(self.angleDeg)
        self.extX=self.longueur*cos(self.angleRad)+self.orgX
        self.extY=-self.longueur*sin(self.angleRad)+self.orgY
 
    def affiche_message(self):
        msg=Tk()
        Message(msg, width =200, justify =CENTER,text ='attention collision').pack()
 
    def detect_collision(self, parent1):
        delta=5                                                                                              #intervalle de sécurité [-delta;delta] par rapport au pivot collision
        self.angleRad=transfo_ang(self.angleDeg)
        deltaX=delta*sin(self.angleRad)
        deltaY=delta*cos(self.angleRad)
        if (self.extX-self.orgX !=0)&(deltaX!=0):
            a1=(self.extY-self.orgY)/(self.extX-self.orgX)                                            #on calcul les paramètres des équations des droites encadrant le pivot ( Y=aX+b )
            b1=self.extY-a1*self.extX
            bh1=(self.extY+deltaY)-a1*(self.extX+deltaX)
            bb1=(self.extY-deltaY)-a1*(self.extX-deltaX)
            a2=deltaY/deltaX
            bh2=self.extY-a2*self.extX
            bb2=self.orgY-a2*self.orgX
            if (self.angleDeg%360>0)&(self.angleDeg%360<90):    # detection dans le premier cadran
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>90)&(self.angleDeg%360<180):  # detection dans le deuxieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>180)&(self.angleDeg%360<270):  # detection dans le troisieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
            if (self.angleDeg%360>270)&(self.angleDeg%360<360):   # detection dans le quatrieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
        if(self.angleDeg%360==0):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX<self.extX)&(parent1.extX>self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==90):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY>self.extY)&(parent1.extY<self.orgY):
                self.affiche_message()
        if(self.angleDeg%360==180):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX>self.extX)&(parent1.extX<self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==270):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY<self.extY)&(parent1.extY>self.orgY):
                self.affiche_message()
 
class MyWindow(Canvas):
    def __init__(self, boss, longueur, largeur):
        Canvas.__init__(self, width = longueur, height = largeur)
        self.longueur = longueur
        self.largeur = largeur
        self.create_line(2,2,2,100, width=2, fill='black', arrow=LAST)
        self.create_line(2,2,100,2, width=2, fill='black', arrow=LAST)
 
def move():
        delta_t=500  #tps de rafraichissement exprime en ms 
        myPivot1.afficher(myWindow1)
        myPivot2.afficher(myWindow1)
        myPivot1.rotation(myPivot1.angleDeg + myPivot1.sens*(myPivot1.w*delta_t/1000))
        myPivot2.rotation(myPivot2.angleDeg + myPivot2.sens*(myPivot2.w*delta_t/1000))
        myPivot1.detect_collision(myPivot2) # detect si le pivot2 rentre dans le pivot1
        fen.after(delta_t, move)
 
if __name__ == '__main__': 
    fen =Tk()
    fen.title("deux pivots")
    myWindow1 = MyWindow(fen, 800, 600)
    myPivot1 = MyPivot(400, 300, 290, None, 130, None, 2, 'trigo', 3, 'yellow')
    myPivot2 = MyPivot(25, 25, 300, 280, 290, 350, 2, 'antitrigo', 3, 'green')
    move()
    myWindow1.pack(side=LEFT)
    fen.mainloop()

je fais la detection dans chaque cadran car il fallait faire un simulation avec 5 pivots placés aléatoirement
donc voila je pense que j'ai fini
merci encore a toi ++

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
 
# -*- coding: iso-8859-15 -*-
npivot  =[[10,10,50,50,1],[40,40,200,200,-1],[70,70,180,180,1]]
"npivot[[x1,y1,x2,y2,-/+1],[x1,y1,x2,y2,-/+1],[....]...]"
 
def rotation(x1,y1,x2,y2,i,d=0):
    c.create_arc(x1,y1,x2,y2,extent=0,start=i)
                            #extent =ouvrture de arac
                            #start  =ou il se trouve
    a   =c.find_all()       #rechercher touts les tag id de canvas
    ab  =a[len(a)-1]        #recuperer, tad id, qui nous fauts
    c.delete(ab-d)          #effacer effacer tag id inutile, et faits tourner
    print c.find_all()
 
def job():
    global i,d
    i   =i+1
    for ia in range(len(npivot)):
        npi =npivot[ia]
        rotation(npi[0],npi[1],npi[2],npi[3],npi[4]*i,d)
    fen.after(50,job)
 
#   ----- VARIABLE
i   =0                  #i =angle de 0 a 360 degres
d   =len((npivot))      #nombre de pivot au total
from Tkinter import*
fen =Tk()
c=Canvas()
c.grid()
job()
fen.mainloop()

super leger, j'aipa sencore mits les colission :)

11/01/2006, 20h42
frky

merci beaucoup pour ta réponse mais concernant mon prog jai un petit problème:
Je voudrais afficher un message lors de la collision puis l'effacer au bout de 10 s tout en laissant les barres pivoter. Si vous avez quelques idées concernant ce sujet je vous en serai reconnaissant.

Merci d'avance

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
# -*- coding: iso-8859-15 -*-
from Tkinter import *
from math import *
import time, string
import threading
import sys
 
dismsg      =0          #0 pour msg ferme, 1 pour afficher
temp        = 5000     #10s en ms
comp        =0          #compteur de temp
delta_t     =500        #tps de rafraichissement exprime en ms
def transfo_ang(angle_degre):
    angle_radian=angle_degre*pi/180
    return angle_radian
 
class MyPivot:
    def __init__(self, orgX, orgY, longueur,  angleBut1, angleDeg, angleBut2, w, sens_rotation, epaisseur, couleur):      #sens_rotation:  taper trigo ou antitrigo
        self.orgX = orgX                                                                                                                                  #w est exprimÃ© en deg/s                                                                             
        self.orgY = orgY                                                                                                                                  #angleDeg, angleBut1, angleBut2 en degrÃ© (angleBut1<angleBut2)
        self.epaisseur = epaisseur
        self.couleur = couleur
        self.longueur = longueur
        self.angleDeg = angleDeg
        self.w = w
        angleRad = transfo_ang(self.angleDeg)
        self.angleBut1 = angleBut1
        self.angleBut2 = angleBut2
        self.extX=self.longueur*cos(angleRad)+orgX
        self.extY=-self.longueur*sin(angleRad)+orgY
        self.ligne=None
        self.sens_rotation=sens_rotation
        if sens_rotation == 'antitrigo':
            self.sens=-1
        else :
            self.sens=1
 
    def inverse_sens(self):
        if (self.angleBut1 != None) & (self.angleBut2 != None):
            if (self.angleDeg >= self.angleBut2):
                self.angleDeg=self.angleBut2
                self.sens=-self.sens
            if (self.angleDeg <= self.angleBut1):
                self.angleDeg=self.angleBut1
                self.sens=-self.sens
 
    def afficher(self, windowParent):
        windowParent.delete(self.ligne)
        self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur)
 
    def rotation(self, nouvelAngle):
        self.angleDeg = nouvelAngle
        self.inverse_sens()
        self.angleRad = transfo_ang(self.angleDeg)
        self.extX=self.longueur*cos(self.angleRad)+self.orgX
        self.extY=-self.longueur*sin(self.angleRad)+self.orgY
 
    def affiche_message(self):
        global dismsg,msg
        msg=Tk()
        Message(msg, width =200, justify =CENTER,text ='attention collision').pack()
        dismsg   =1
 
    def detect_collision(self, parent1):
        delta=5                                                                                              #intervalle de sécurité [-delta;delta] par rapport au pivot collision
        self.angleRad=transfo_ang(self.angleDeg)
        deltaX=delta*sin(self.angleRad)
        deltaY=delta*cos(self.angleRad)
        if (self.extX-self.orgX !=0)&(deltaX!=0):
            a1=(self.extY-self.orgY)/(self.extX-self.orgX)                                            #on calcul les paramètres des équations des droites encadrant le pivot ( Y=aX+b )
            b1=self.extY-a1*self.extX
            bh1=(self.extY+deltaY)-a1*(self.extX+deltaX)
            bb1=(self.extY-deltaY)-a1*(self.extX-deltaX)
            a2=deltaY/deltaX
            bh2=self.extY-a2*self.extX
            bb2=self.orgY-a2*self.orgX
            if (self.angleDeg%360>0)&(self.angleDeg%360<90):    # detection dans le premier cadran
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>90)&(self.angleDeg%360<180):  # detection dans le deuxieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>180)&(self.angleDeg%360<270):  # detection dans le troisieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
            if (self.angleDeg%360>270)&(self.angleDeg%360<360):   # detection dans le quatrieme cadran
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
        if(self.angleDeg%360==0):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX<self.extX)&(parent1.extX>self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==90):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY>self.extY)&(parent1.extY<self.orgY):
                self.affiche_message()
        if(self.angleDeg%360==180):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX>self.extX)&(parent1.extX<self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==270):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY<self.extY)&(parent1.extY>self.orgY):
                self.affiche_message()
 
class MyWindow(Canvas):
    def __init__(self, boss, longueur, largeur):
        Canvas.__init__(self, width = longueur, height = largeur)
        self.longueur = longueur
        self.largeur = largeur
        self.create_line(2,2,2,100, width=2, fill='black', arrow=LAST)
        self.create_line(2,2,100,2, width=2, fill='black', arrow=LAST)
 
def move():
        global temp,comp,dismsg
        if dismsg   ==1:
            comp    =comp+1
            a   =comp*delta_t
            if temp<a:
                msg.destroy()
                dismsg  =0
 
        myPivot1.afficher(myWindow1)
        myPivot2.afficher(myWindow1)
        myPivot1.rotation(myPivot1.angleDeg + myPivot1.sens*(myPivot1.w*delta_t/1000))
        myPivot2.rotation(myPivot2.angleDeg + myPivot2.sens*(myPivot2.w*delta_t/1000))
        myPivot1.detect_collision(myPivot2) # detect si le pivot2 rentre dans le pivot1
        fen.after(delta_t, move)
 
if __name__ == '__main__':
    fen =Tk()
    fen.title("deux pivots")
    myWindow1 = MyWindow(fen, 800, 600)
    myPivot1 = MyPivot(400, 300, 290, None, 130, None, 2, 'trigo', 3, 'yellow')
    myPivot2 = MyPivot(25, 25, 300, 280, 290, 350, 2, 'antitrigo', 3, 'green')
    move()
    myWindow1.pack(side=LEFT)
    fen.mainloop()

corriger
dans move() je t'ai ajouter

Code:

1
2
3
4
5
6
7
global temp,comp,dismsg
        if dismsg   ==1:
            comp    =comp+1
            a   =comp*delta_t
            if temp<a:
                msg.destroy()
                dismsg  =0

et mits

Code:

delta_t =500 #tps de rafraichissement exprime en ms

au deput du scripts

c'est pour savoir, quand, il ferme ta fenetres
dans affiche_message(), je t'ai ajouter
un global, et dismsg=1

au deputs j'ai ajouter, des new varibales

Code:

1
2
3
4
dismsg      =0          #0 pour msg ferme, 1 pour afficher
temp        = 5000     #10s en ms
comp        =0          #compteur de temp
delta_t     =500        #tps de rafraichissement exprime en ms

le temps de la fermute se mets das tem

12/01/2006, 13h54
frky

Merci beaucoup ca m'aide trop.
je te tiens au courant du résultat plus tard.
a ++

juste un truc, qu ej'avaits oblier, dans

Code:

1
2
3
4
5
6
7
8
def move():
        global temp,comp,dismsg
        if dismsg   ==1:
            comp    =comp+1
            a   =comp*delta_t
            if temp<a:
                msg.destroy()
                dismsg  =0

il fauts ajouter comp =0 apres dismsg =0 ou avants

bon voila la version finale de notre programme avec en pointillé la representation des pivots avec un temps d'avance de 10 sec.

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
#Ce programme permet de simuler les pivots d'arrosage sur fond gif
#from PIL import Image, ImageTk
from math import *
from Tkinter import *
import time, string
import threading
import sys
 
dismsg      =0          #0 pour msg ferme, 1 pour afficher 
temp        = 10000     #10s en ms 
comp        =0 
 
def transfo_ang(angle_degre):
    angle_radian=angle_degre*pi/180
    return angle_radian
 
class MyPivot:
    def __init__(self, orgX, orgY, longueur,  angleBut1, angleDeg, angleBut2, w, sens_rotation, epaisseur, couleur):      #sens_rotation:  taper trigo ou antitrigo 
        self.orgX = orgX                                                                                                                                  #w est exprimé en deg/s                                                                              
        self.orgY = orgY                                                                                                                                  #angleDeg, angleBut1, angleBut2 en degré (angleBut1<angleBut2)
        self.epaisseur = epaisseur
        self.couleur = couleur
        self.longueur = longueur
        self.angleDeg = angleDeg
        self.w = w
        angleRad = transfo_ang(self.angleDeg)
        self.angleBut1 = angleBut1
        self.angleBut2 = angleBut2
        self.extX=self.longueur*cos(angleRad)+orgX
        self.extY=-self.longueur*sin(angleRad)+orgY
        self.ligne=None
        self.sens_rotation=sens_rotation
        if sens_rotation == 'antitrigo':
            self.sens=-1
        else :
            self.sens=1 
 
    def inverse_sens(self):
        if (self.angleBut1 != None) & (self.angleBut2 != None):
            if (self.angleDeg >= self.angleBut2):
                self.angleDeg=self.angleBut2
                self.sens=-self.sens
            if (self.angleDeg <= self.angleBut1):
                self.angleDeg=self.angleBut1
                self.sens=-self.sens
 
    def afficher(self, windowParent):
        windowParent.delete(self.ligne)
        self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur)
 
    def rotation(self, nouvelAngle):
        self.angleDeg = nouvelAngle
        self.inverse_sens()
        self.angleRad = transfo_ang(self.angleDeg)
        self.extX=self.longueur*cos(self.angleRad)+self.orgX
        self.extY=-self.longueur*sin(self.angleRad)+self.orgY
 
class Collision(MyPivot):
    def __init__(self, pivotParent):
        t_avance=10 #tps d'avance du pivot fictif sur le pivot réel (en s)
        self.orgX = pivotParent.orgX
        self.orgY = pivotParent.orgY
        self.epaisseur = 1
        self.couleur = pivotParent.couleur
        self.couleur = pivotParent.couleur
        self.longueur = pivotParent.longueur
        self.w = pivotParent.w
        self.sens_rotation=pivotParent.sens_rotation
        if self.sens_rotation == 'antitrigo':
            self.sens=-1
        else :
            self.sens=1
        self.angleDeg = pivotParent.angleDeg+t_avance*self.sens*pivotParent.w  
        self.angleBut1 = pivotParent.angleBut1
        self.angleBut2 = pivotParent.angleBut2
        if (self.angleBut1 != None) & (self.angleBut2 != None):
            if self.angleDeg>self.angleBut2:
                self.angleDeg=2*self.angleBut2-self.angleDeg
                self.sens=-self.sens
            if self.angleDeg<self.angleBut1:
                self.angleDeg=2*self.angleBut1-self.angleDeg
                self.sens=-self.sens
        angleRad = transfo_ang(self.angleDeg)
        self.extX=self.longueur*cos(angleRad)+pivotParent.orgX
        self.extY=-self.longueur*sin(angleRad)+pivotParent.orgY
        self.ligne=None
 
    def afficher(self, windowParent):
        windowParent.delete(self.ligne)
        self.ligne=windowParent.create_line(self.orgX,self.orgY,self.extX,self.extY, width=self.epaisseur, fill=self.couleur, dash=(4,4))
 
    def affiche_message(self):
        global dismsg,msg 
        if dismsg == 0:
            msg=Tk() 
            Message(msg, width =200, justify =CENTER,text ='attention collision').pack() 
            dismsg   =1 
 
    def detect_collision(self, parent1):
        delta=5                                                                                              #intervalle de sécurité [-delta;delta] par rapport au pivot collision
        self.angleRad=transfo_ang(self.angleDeg)
        deltaX=delta*sin(self.angleRad)
        deltaY=delta*cos(self.angleRad)
        if (self.extX-self.orgX !=0)&(deltaX!=0):
            a1=(self.extY-self.orgY)/(self.extX-self.orgX)                                            #on calcul les paramètres l'équation du pivot collision : Y=aX+b
            b1=self.extY-a1*self.extX
            bh1=(self.extY+deltaY)-a1*(self.extX+deltaX)
            bb1=(self.extY-deltaY)-a1*(self.extX-deltaX)
            a2=deltaY/deltaX
            bh2=self.extY-a2*self.extX
            bb2=self.orgY-a2*self.orgX
            if (self.angleDeg%360>0)&(self.angleDeg%360<90):
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>90)&(self.angleDeg%360<180):
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2>0)&(parent1.extY-a2*(parent1.extX)-bb2<0):
                    self.affiche_message()
            if (self.angleDeg%360>180)&(self.angleDeg%360<270):
                if (parent1.extY-a1*(parent1.extX)-bh1>0)&(parent1.extY-a1*(parent1.extX)-bb1<0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
            if (self.angleDeg%360>270)&(self.angleDeg%360<360):
                if (parent1.extY-a1*(parent1.extX)-bh1<0)&(parent1.extY-a1*(parent1.extX)-bb1>0)&(parent1.extY-a2*(parent1.extX)-bh2<0)&(parent1.extY-a2*(parent1.extX)-bb2>0):
                    self.affiche_message()
        if(self.angleDeg%360==0):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX<self.extX)&(parent1.extX>self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==90):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY>self.extY)&(parent1.extY<self.orgY):
                self.affiche_message()
        if(self.angleDeg%360==180):
            if (parent1.extY<(self.orgY+delta))&(parent1.extY>(self.orgY-delta))&(parent1.extX>self.extX)&(parent1.extX<self.orgX):
                self.affiche_message()
        if(self.angleDeg%360==270):
            if (parent1.extX<(self.orgX+delta))&(parent1.extX>(self.orgX-delta))&(parent1.extY<self.extY)&(parent1.extY>self.orgY):
                self.affiche_message()
 
class MyWindow(Canvas):
    def __init__(self, boss, longueur, largeur):
        Canvas.__init__(self, width = longueur, height = largeur)
        self.longueur = longueur
        self.largeur = largeur
##        self.nom_image = 'champ1.gif'
##        self.photo = PhotoImage(file = self.nom_image)
##        self.image = self.create_image(0,0, anchor = NW, image =self.photo)
        self.create_line(2,2,2,100, width=2, fill='black', arrow=LAST)
        self.create_line(2,2,100,2, width=2, fill='black', arrow=LAST)
 
    def change_image(self, num_p):
        self.delete(self.image)
        if num_p==1:
            self.nom_image= 'champ1.gif'
        if num_p==2:
            self.nom_image= 'champ2.gif'
        if num_p==3:
            self.nom_image= 'champ3.gif'
        self.photo = PhotoImage(file = self.nom_image)
        self.image=self.create_image(2,2, anchor = NW, image =self.photo)
        self.create_line(2,2,2,100, width=2, fill='black', arrow=LAST)
        self.create_line(2,2,100,2, width=2, fill='black', arrow=LAST)
 
 
def change_parcelle1():     #methode un peu lourde car la fonction de "command" ds "Button" (situé ds le main) n'accepte pas de paramètres d'entrée
    myWindow1.change_image(1)
 
def change_parcelle2():
    myWindow1.change_image(2)
 
def change_parcelle3():
    myWindow1.change_image(3)
 
def move():
        delta_t=500  #tps de rafraichissement exprimé en ms 
        global temp,comp,dismsg 
        if dismsg   ==1: 
            comp    =comp+1 
            a   =comp*delta_t 
            if temp<a: 
                msg.destroy() 
                dismsg  =0
                comp = 0 
        myPivot1.afficher(myWindow1)
        myPivot1col.afficher(myWindow1)
        myPivot2.afficher(myWindow1)
        myPivot2col.afficher(myWindow1)
        myPivot3.afficher(myWindow1)
        myPivot3col.afficher(myWindow1)
        myPivot4.afficher(myWindow1)
        myPivot4col.afficher(myWindow1)
        myPivot5.afficher(myWindow1)
        myPivot5col.afficher(myWindow1)
        myPivot1.rotation(myPivot1.angleDeg + myPivot1.sens*(myPivot1.w*delta_t/1000))
        myPivot1col.rotation(myPivot1col.angleDeg + myPivot1col.sens*(myPivot1col.w*delta_t/1000))
        myPivot2.rotation(myPivot2.angleDeg + myPivot2.sens*(myPivot2.w*delta_t/1000))
        myPivot2col.rotation(myPivot2col.angleDeg + myPivot2col.sens*(myPivot2col.w*delta_t/1000))
        myPivot3.rotation(myPivot3.angleDeg + myPivot3.sens*(myPivot3.w*delta_t/1000))
        myPivot3col.rotation(myPivot3col.angleDeg + myPivot3col.sens*(myPivot3col.w*delta_t/1000))
        myPivot4.rotation(myPivot4.angleDeg + myPivot4.sens*(myPivot4.w*delta_t/1000))
        myPivot4col.rotation(myPivot4col.angleDeg + myPivot4col.sens*(myPivot4col.w*delta_t/1000))
        myPivot5.rotation(myPivot5.angleDeg + myPivot5.sens*(myPivot5.w*delta_t/1000))
        myPivot5col.rotation(myPivot5col.angleDeg + myPivot5col.sens*(myPivot5col.w*delta_t/1000))
        myPivot1col.detect_collision(myPivot2col)
        myPivot1col.detect_collision(myPivot3col)
        myPivot1col.detect_collision(myPivot4col)
        myPivot1col.detect_collision(myPivot5col)
        myPivot2col.detect_collision(myPivot1col)
        myPivot3col.detect_collision(myPivot1col)
        myPivot4col.detect_collision(myPivot1col)
        myPivot5col.detect_collision(myPivot1col)
        fen.after(delta_t, move)
 
if __name__ == '__main__': 
    fen =Tk()
    fen.title("Simulation des pivots d'arrrosage")
    myWindow1 = MyWindow(fen, 800, 600)
    myPivot1 = MyPivot(400, 300, 300, None, 320, None, 3, 'trigo', 3, 'yellow')
    myPivot1col=Collision(myPivot1)
    myPivot2 = MyPivot(25, 25, 180, 270, 340, 360, 2, 'trigo', 3, 'black')
    myPivot2col=Collision(myPivot2)
    myPivot3 = MyPivot(775, 25 , 180, 180, 230, 270, 2, 'trigo', 3, 'brown')
    myPivot3col=Collision(myPivot3)
    myPivot4 = MyPivot(775, 575 , 180, 100, 170, 170, 2, 'trigo', 3, 'white')
    myPivot4col=Collision(myPivot4)
    myPivot5 = MyPivot(25, 575 , 180, 10, 20, 90, 2, 'antitrigo', 3, 'red')
    myPivot5col=Collision(myPivot5)
    move()
    myWindow1.pack(side=LEFT)
##    bou1=Button(fen, text='Parcelle 1', command=change_parcelle1).pack()
##    bou2=Button(fen, text='Parcelle 2', command=change_parcelle2).pack()
##    bou3=Button(fen, text='Parcelle 3', command=change_parcelle3).pack()
    fen.mainloop()

merci pour ton aide
Bye @+

18/01/2006, 10h47
frky

pour le comp =0 je m'en était apercu ^^ sinon deux barres qui se rentre dedans affichent deux messages d'erreur et yen a qu'un qui s'effacent sur les deux. Ca permet de bloqué l'affichage d'une seule fenetre a la fois
31/01/2006, 22h05
lifido

desoler, pour mon lonts silence, j'ai eu ++, d eproblemem avec mon pc