[Tkinter] Collision de lignes

**frky** · 09/01/2006, 13h11

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 :

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
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 ++

**lifido** · 09/01/2006, 19h19

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
 
# -*- 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

**frky** · 11/01/2006, 21h42

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

**lifido** · 12/01/2006, 01h43

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
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 :

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

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 :

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

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 :

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

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

**frky** · 12/01/2006, 14h54

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

**lifido** · 12/01/2006, 18h32

juste un truc, qu ej'avaits oblier, dans

Code :

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

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

**frky** · 18/01/2006, 11h43

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

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
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 @+

**frky** · 18/01/2006, 11h47

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

**lifido** · 31/01/2006, 23h05

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

[Tkinter] Collision de lignes

Tkinter Python

Discussions similaires

Partager

Partager