Programmation des 24h du Mans

Version imprimable

Voir 40 message(s) de cette discussion en une page

02/02/2021, 16h37
TiT_Flo

Programmation des 24h du Mans

Bonjour,

Bon avant toutes choses, je me présente. Je suis un étudiant de CPGE (classe préparatoire aux grandes écoles) et nous avons, dans le cadre de notre concours, un projet d'informatique à fournir, évaluer.

Ce projet, nous avons décidé de le faire sur les 24h du Mans sous forme de jeu de gestion avec notamment la gestion de divers paramètres. Jusqu'ici pas de problèmes particuliers cependant, on arrive à la représentation graphique de notre circuit et à la gestion de l'accélération et de la vitesse. Et nous bloquons sur ce dernier point.
Nous souhaiterions avoir un interface en 2D et le circuit étant déjà modélisé en image, nous nous sommes dit qu'une représentation du circuit sous forme de matrices pouvait être une solution avec notamment 0 pour le hors circuit et 1 pour l'asphalte du circuit, cependant comment avoir une gestion de la vitesse avec une pareil matrice ?
Existe-il d'autres solutions permettant d'avoir cet interface graphique ? (nous sommes sous tkinter)

Merci de vos réponses
02/02/2021, 17h31
wiztricks

Salut,

Sur une interface graphique la vitesse est fabriquée par persistance rétinienne.
Dit autrement, vous effectuez des mises à jours toutes les 50ms ou plus rapidement... Et la vitesse sera juste le déplacement +/- grand d'un objet entre ce qu'on voit à l'instant T et à T+50ms.

Sous tkinter pour réaliser çà, vous avez le Canvas... mais avant de vous lancer au 24 du mans peut être faudrait il commencer par une balle qui rebondit et deux Boutons pour accélérer/ralentir histoire de voir comment gérer çà.

- W
23/02/2021, 15h07
TiT_Flo

Bonjour,

Désolé de ne revenir que maintenant sur le sujet.

On a eu l'apport de solutions par nos professeurs et autres sources notamment pour faire le tracé de la voiture. Ce tracé se ferait à l'aide de courbes de Bezier dessiné sur inkscape. Voilà le topo de où nous sommes.
Cependant, si on utilise le canvas comme tu le proposes, comment tracé le circuit dessus ?

- F
23/02/2021, 15h25
wiztricks

Salut,

Citation:

Envoyé par TiT_Flo

Cependant, si on utilise le canvas comme tu le proposes, comment tracé le circuit dessus ?

Je ne suis pas sûr que tracer le circuit soit un problème (ouvrez la documentation du Canvas et explorez les différentes solutions) par contre, pour détecter les sorties de route...

- W
23/02/2021, 15h39
TiT_Flo

Pour ce qui est de la sortie de route, je pensais la coder selon une probabilité. Je m'explique: il y a une probabilité p de 0.05% que la voiture sorte de la route sur un tour lorsque la piste est sèche et une probabilité p=5% de sortie de route lorsque la voiture roule sous la pluie (pour exemple)

Est ce qu'on peut dessiner le canvas à partir d'une image ? Je sais qu'on peut tirer une matrice selon les couleurs d'une image donc est-il possible de créer un canvas selon une image ? Le but étant de créer un ensemble de coordonnées qui permettraient de déplacer les voitures selon celle-ci !

- F
23/02/2021, 16h18
wiztricks

Citation:

Envoyé par TiT_Flo

Est ce qu'on peut dessiner le canvas à partir d'une image ? Je sais qu'on peut tirer une matrice selon les couleurs d'une image donc est-il possible de créer un canvas selon une image ?

On peut même afficher l'image directement dans le Canvas.

Après pour utiliser des fonctionnalités avancées du Canvas, la documentation, les exemples que vous allez trouver sur Internet sont vos premières ressources...

Vous voyez qu'entre les animations à réaliser et ce que sait bien faire un Canvas (ou n'importe quel autre outil), il y a un apprentissage, des algos, du code à écrire...
Après, vous avez la chance d'être dans un cursus où vos professeurs sont un peu plus impliqués que dans d'autres: l'idée de partir sur un Canvas n'est peut être pas ce à quoi ils ont pensé (et ce sont eux les maîtres).

- W
02/03/2021, 17h13
TiT_Flo

Merci mais ça ne m'aide pas beaucoup sur ce que je veux faire... Ni même me donne une piste pour avancer mon programme.

Mais peut être ai-je pas été claire dans les questions posées.
C'est un programme de gestion de course avec différent aléa de course.
Le but actuel est de réussir à afficher une image (que l'on va appelé a1 et qui correspondra à la voiture). Cette image sera mobile est suivra une fonction particulière (sûrement calculé à partir de courbes de Béziers) qui la fera tourné sur une image en arrière plan (noté a2). Est ce qu'il y a un moyen de faire en sorte que a1 suive une fonction sur a2 ? Quel sera la fonction tkinter a utilisé ?

-F-
02/03/2021, 17h39
wiztricks

Salut,

Si vous savez placer une forme (image ou autre) en (x₀, y₀) à l'instant T₀ et calculer sa position x₁, y₁ en T₁, le déplacer ne pose pas de problème.

Après côté "animation", les intervalles de temps T₁ - T₀ ou T_n - T_n-1 entre les déplacements doivent être petits pour que la persistence visuelle crée l'illusion d'une continuité (comme au cinéma).

Après si je vous parle de Canvas depuis un certain temps et que vous n'avez pas pris le temps d'ouvrir une documentation ou de chercher des exemples d'animation qu'on peut réaliser avec (çà se trouve en quelques clics sur Internet).... Ben désolé mais je ne peux pas le faire à votre place.

- W

Pour revenir sur la conversation, nous avons beaucoup avancé de notre côté sur différents points.
Cependant, je me retrouve face à un problème. Au préalable, nous avions établi un petit programme pour être sûr que nous pouvions faire les choses, c'est à dire faire bouger un point de manière aléatoire selon des coordonnées x,y qui sont ici aléatoire, joint ci-dessous:

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
 
import random as rd
import tkinter as tk
 
class AppliCanevas(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        self.size = 500
        self.creer_widgets()
        self.x=0
        self.y=0
        self.point = self.canv.create_oval(self.x, self.y,self.x+5,self.y+5,width=2, fill="black")
        self.move()
 
    def creer_widgets(self):
        # création canevas
        self.canv = tk.Canvas(self, bg="white", height=self.size,width=self.size)
        self.canv.pack(side=tk.LEFT)
        self.bouton_quitter = tk.Button(self, text="Quitter",command=self.quit)
        self.bouton_quitter.pack(side=tk.BOTTOM)        
 
    def move(self):
        n=100
        L=[]
        for i in range (n):
            x=rd.randint(1,500)
            y=rd.randint(1,500)
            L.append([x,y])
        m=len(L)
        for i in range(m):
            o=L[i]
            self.x=o[0]
            self.y=o[1]
            self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5)
        self.after(self.x, self.move)
 
if __name__ == "__main__":
    app = AppliCanevas()
    app.mainloop()

Ce programme a été joint à un programme plus large qui permet d'obtenir des points calculés selon des courbes de Béziers permettant la réalisation du circuit et d'un point que l'on associe à une voiture. Cependant, ce point qui bougé sur le programme ci dessus, ne bouge pas sur le progamme plus large et j'ai du mal à comprendre où se situe la faute. J'aimerais bien avoir un petit coup de pouce (programme ci-dessous).

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
 
import tkinter as tk
 
def combinaison_lineaire(A,B,u,v):
    return [A[0]*u+B[0]*v,A[1]*u+B[1]*v]
 
def interpolation_lineaire(A,B,t):
    return combinaison_lineaire(A,B,t,1-t)
 
def vecteur_unitaire(P1,P2):
    Ux = P2[0]-P1[0]
    Uy = P2[1]-P1[1]
    norme = math.sqrt(Ux*Ux+Uy*Uy)
    if norme!=0:
        return [Ux/norme,Uy/norme]
    else:
        return False
 
def test_alignement_4pts(points,epsilon):
    U1 = vecteur_unitaire(points[0],points[1])
    U2 = vecteur_unitaire(points[1],points[2])
    U3 = vecteur_unitaire(points[2],points[3])
    if U2:
        x = 2.0-(U1[0]*U2[0]+U1[1]*U2[1]+U2[0]*U3[0]+U2[1]*U3[1])
    else:
        x = 1.0-(U1[0]*U3[0]+U1[1]*U3[1])
    if abs(x) < epsilon:
        return True
    else:
        return False
 
def division_courbe_bezier_3(points_control):
    P01 = interpolation_lineaire(points_control[0],points_control[1],0.5)
    P12 = interpolation_lineaire(points_control[1],points_control[2],0.5)
    P23 = interpolation_lineaire(points_control[2],points_control[3],0.5)
    P01_12 = interpolation_lineaire(P01,P12,0.5)
    P12_23 = interpolation_lineaire(P12,P23,0.5)
    Q = interpolation_lineaire(P01_12,P12_23,0.5)
    return ([points_control[0],P01,P01_12,Q],[Q,P12_23,P23,points_control[3]])
 
def courbe_bezier_3_recursif(points_control,epsilon,pile_points_courbe):
    if test_alignement_4pts(points_control,epsilon):
        pile_points_courbe.append(points_control[0])
    else:
        (points_1,points_2) = division_courbe_bezier_3(points_control)
        courbe_bezier_3_recursif(points_1,epsilon,pile_points_courbe)
        courbe_bezier_3_recursif(points_2,epsilon,pile_points_courbe)
 
def plot_points(points_courbe,style='-'):
    x = []
    y = []
    for p in points_courbe:
        x.append(p[0])
        y.append(p[1])
    plot(x,y,style)
 
class Courbe:
    def __init__(self,P0,P1,P2,P3,epsilon):
        self.points_courbe = []
        self.epsilon = epsilon
        self.bezier_3_recursif_init([P0,P1,P2,P3])
        self.points_control = [P0,P1,P2,P3]
    def bezier_3_recursif_init(self,points_control):
        courbe_bezier_3_recursif(points_control,self.epsilon,self.points_courbe)
        self.P2 = points_control[2]
        self.P3 = points_control[3]
    def ajouter(self,P2,P3):
        P0 = self.P3
        P1 = [P0[0]+P0[0]-self.P2[0],P0[1]+P0[1]-self.P2[1]]
        self.bezier_3_recursif_init([P0,P1,P2,P3])
        self.points_control.append(P1)
        self.points_control.append(P2)
        self.points_control.append(P3)
        self.dernier_point = P3
    def liste_points(self):
        self.points_courbe.append(self.dernier_point)
        return self.points_courbe
    def liste_points_control(self):
        self.points_control.append(self.dernier_point)
        return self.points_control
 
def CalculeVitesse(L):
    n = len(L)
    V = []
    T = []
    for i in range(0,n):
        x,y = L[i]
        xp, yp = L[i-1]
        xs, ys = L[(i+1)//n] # si i == n-1, remplacer i+1 par 0
        dG = ((x-xp)**2 + (y - yp)**2)**.5
        dD = ((x-xs)**2 + (y - ys)**2)**.5
        v = int(((dG+dD)//2)+1)
        V.append(v)
        T.append(dD/v)
    V.append(50)
    return V, T
 
courbe = Courbe([121,276],[142,246],[169,212],[190,182],5e-3)
courbe.ajouter([269,146],[339,142])
courbe.ajouter([460,161],[491,154])
courbe.ajouter([514,151],[535,149])
courbe.ajouter([562,142],[571,132])
courbe.ajouter([605,112],[637,130])
courbe.ajouter([684,137],[713,96])
courbe.ajouter([782,114],[791,110])
courbe.ajouter([810,140],[815,145])
courbe.ajouter([600,440],[600,445])
courbe.ajouter([300,400],[300,405])
courbe.ajouter([121,275],[121,276])
 
points = courbe.liste_points() # la liste utile
vitesses,durees = CalculeVitesse(points)
 
class Circuit(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        self.size = 750
        self.vitesses,self.durees = CalculeVitesse(points)
        self.creer_widgets()
        self.points=courbe.liste_points()
        m=len(self.points)
        o=self.points[0]
        self.x=o[0]
        self.y=o[1]
        self.point = self.canv.create_oval(self.x, self.y,self.x+5,self.y+5,width=2, fill="black")
        self.move()
 
    def creer_widgets(self):
        self.canv = tk.Canvas(self, bg="white", height=self.size,width=self.size)
        self.canv.pack(side=tk.LEFT)
        self.bouton_quitter = tk.Button(self, text="Quitter",command=self.destroy)
        self.bouton_quitter.pack(side=tk.BOTTOM)        
 
    def stop(self, esc):
        """Quitte l'application."""
        self.quit() 
 
    def move(self):
        m=len(self.points)
        for i in range(m):
            o=self.points[i]
            self.x=o[0]
            self.y=o[1]
            self.g=self.vitesses[i]
            self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5)
        self.after(self.g, self.move)
 
if __name__ == "__main__":
    app = Circuit()
    app.mainloop()

Merci de votre aide !

-F-

Salut,

En écrivant:
Code:

1 2 3 4 5 6 7 8 9 def move(self): m=len(self.points) for i in range(m): o=self.points[i] self.x=o[0] self.y=o[1] self.g=self.vitesses[i] self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5) self.after(self.g, self.move)
à chaque appel de "move", l'item de type "oval" (identifié par self.point) est modifié m fois: seule la dernière modification sera "visible". Si les valeurs restent ce qu'elles sont au prochain appel de "move", on refera la même chose.
Et çà fait beaucoup de boulot pour voir que rien ne se passe.

Ce que vous pourriez confirmer par vous même en ajoutant des "print" pour voir ce que fait votre code.

J'ai essayé de refaire le programme mais j'avoue que j'ai du mal avec la position que doit prendre la fonction after dans cette fonction pour reboucler une fois la fonction move. J'air remarqué une première erreur sur le programme supérieur qui sert de test (et sur laquelle je veux me concentrer pour l'instant) dont voici la correction:
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 import random as rd import tkinter as tk class AppliCanevas(tk.Tk): def __init__(self): tk.Tk.__init__(self) self.size = 500 self.creer_widgets() self.x=0 self.y=0 self.point = self.canv.create_oval(self.x, self.y,self.x+5,self.y+5,width=2, fill="black") self.move() def creer_widgets(self): # création canevas self.canv = tk.Canvas(self, bg="white", height=self.size,width=self.size) self.canv.pack(side=tk.LEFT) self.bouton_quitter = tk.Button(self, text="Quitter",command=self.destroy) self.bouton_quitter.pack(side=tk.BOTTOM) def liste(self): n=100 L=[] for i in range (n): x=rd.randint(1,500) y=rd.randint(1,500) L.append([x,y]) return L def move(self): L1=self.liste() m=len(L1) i=0 while i<m: o=L1[i] self.x=o[0] self.y=o[1] self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5) i=i+1 self.after(self.x, self.move) if __name__ == "__main__": app = AppliCanevas() app.mainloop()
J'ai notamment dissocié la fonction liste (creant une liste aléatoire de valeurs comme on l'aurait sur le vraie programme), qui était dedans et qui faussait la fonction move et donc le fait que le point bouge. Cependant, je n'arrive pas à comprendre l'endroit où doit se placer la fonction after (malgré de nombreuse recherche sur internet). Je sais seulement que, introduit dans un programme avec un canvas provenant de tkinter, elle a pour rôle de le rafraichir selon une fréquence de temps donné.
Merci de votre aide
-F-

(oups, petite faute glissé dans le programme)

Salut,

Je ne sais pas ce que vous cherchez à faire en écrivant:
Code:

1 2 3 4 5 6 7 8 9 10 11 def move(self): L1=self.liste() m=len(L1) i=0 while i<m: o=L1[i] self.x=o[0] self.y=o[1] self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5) i=i+1 self.after(self.x, self.move)
Imaginez after comme étant une fonction qui met à jour l'affichage.
Techniquement, elle a besoin de s'exécuter à une fréquence suffisante pour jouer avec la persistance rétinienne.
Inutile d'avoir autant d'after en cours que d'objets à déplacer: se déplacer plus vite se traduit plus facilement par un plus grand déplacement par unité de temps (donné par la fréquence à laquelle se déclenche after).
self.x étant une abscisse... ce n'est pas une unité de temps (after attends des millisecondes en premier paramètre).

Vous devez apprendre à utiliser tkinter avant de programmer avec.
Faites de petits exemples avec after pour voir comment çà fonctionne.
Regardez les exemples qui trainent sur Internet, jouez avec.

Une fois que vous avez l'impression d'avoir compris quelque chose, vous saurez comment le mettre en oeuvre pour votre programme. Avant vous allez faire des essais hasardeux où vous ne savez pas rop ce que vous testez et encore moins quoi en conclure.

- W

30/05/2021, 20h17
TiT_Flo
Ce que j'arrive pas à comprendre dans la fonction after, c'est le fait que je possède une liste dans laquelle justement je veux récupérer des coordonnées qui sont donnée en liste de liste. C'est notamment ce que je cherche à récupérer avec ces lignes du programme move:
Code:

1 2 3 4 5 while i<m: o=L1[i] self.x=o[0] self.y=o[1]
Le but ensuite est d'actualiser ces coordonnées et donc d'actualiser la position où se trouve le point et la seule solution que je vois à cette idée là, est la fonction after. Alors en effet j'ai mis en toute conscience self.x qui sont des abscisses dans la fonction after car je voulais essayer quelques choses qui va être introduit dans le programme général qui est la notion de vitesses, provenant sous forme de liste. Cette variation de vitesses va donc introduire une variation de rafraichissement (je vous invite à regarder plus correctement le grand programme).

Pour revenir à la première question, dans ce programme, je souhaite récupérer les coordonnées introduites dans une liste et faire se déplacer un point selon cette liste. Il faut donc introduire quelque part une boucle (for ou while) permettant de balayer cette liste, chose que j'introduis avec le while ci-dessus. Cependant, comment placer le after pour que le rafraichissement de l'interface se fasse de manière à ce que le point se déplace bien selon les coordonnées données par cette liste ?
-F-
30/05/2021, 20h48
wiztricks

Citation:

Envoyé par TiT_Flo

Cette variation de vitesses va donc introduire une variation de rafraichissement (je vous invite à regarder plus correctement le grand programme).

Je l'ai regardé et je vous suggère de vous y prendre autrement: un seul after qui pète toutes les 20ms et une mise à jour de toutes les positions suivant la distance parcourue pendant ces 20ms.

Citation:

Cependant, comment placer le after pour que le rafraichissement de l'interface se fasse de manière à ce que le point se déplace bien selon les coordonnées données par cette liste ?

Si le point parcours la liste, çà veut dire qu'a chaque appel de move, il récupère le point suivant (via son index) et positionne l'ovale à cet emplacement. Ce qui fait que l'index doit être attribut (puisque vous utilisez des "class") ou passé en paramètre à move (pour savoir quel index utiliser pour le coup suivant) lors de l'appel à after.
note: et dans ce cas, on n'a toujours pas besoin de lancer autant d'after que de points dans la liste.

- W

Merci beaucoup, j'ai bien avancé ce soir ! Je vais essayer de l'ajouter au programme principal demain !
Pour le moment j'ai cela, qui semble être quelques choses de satisfaisant:

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
 
import random as rd
import tkinter as tk
 
def liste():
        n=1000
        L=[]
        for i in range (n):
            x=rd.randint(1,500)
            y=rd.randint(1,500)
            L.append([x,y])
        return L
 
class AppliCanevas(tk.Tk):
    def __init__(self):
        tk.Tk.__init__(self)
        self.size = 600
        self.creer_widgets()
        self.x=0
        self.y=0
        self.point = self.canv.create_oval(self.x, self.y,self.x+5,self.y+5,width=2, fill="black")
        self.i=-1
        self.L1=liste()
        self.move()
 
    def creer_widgets(self):
        # création canevas
        self.canv = tk.Canvas(self, bg="white", height=self.size,width=self.size)
        self.canv.pack(side=tk.LEFT)
        self.bouton_quitter = tk.Button(self, text="Quitter",command=self.destroy)
        self.bouton_quitter.pack(side=tk.BOTTOM)  
 
    def index(self):
        self.i=self.i+1
        return self.i
 
    def move(self):
        L1=self.L1
        m=len(L1)
        i=self.index()
        print(L1)
        if i<m:
            o=self.L1[i]
            self.x=o[0]
            self.y=o[1]
            print(o)    
        if i>m:
            self.destroy()
        self.canv.coords(self.point, self.x, self.y, self.x+5,self.y+5)
        self.after(20, self.move)
 
 
if __name__ == "__main__":
    app = AppliCanevas()
    app.mainloop()

En vous souhaitant une bonne soirée!

Salut,

L'essentiel de votre code se résume à:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 import tkinter as tk from random import randint L = [ (randint(1,500), randint(1, 500)) for _ in range(10) ] root = tk.Tk() canvas = tk.Canvas(root, width=500, height=500) canvas.pack() point = canvas.create_oval(0, 0, 5, 5,width=2, fill="black") def move(index): x, y = L[index] canvas.coords(point, x, y, x+5, y+5) canvas.after(40, move, (index + 1) % len(L)) move(0) tk.mainloop()
Et c'est bien plus facile de travailler sur les détails d'implémentation sur un code "petit" plutôt que de s'embarrasser de tas de trucs qui ne servent à rien pour s'y noyer.

- W

31/05/2021, 12h03
TiT_Flo

Merci beaucoup ! J'ai tout ajouté dans mon programme principal et cela fonctionne correctement (j'en ai même profité pour créer deux boutons permettant de lancer le script et de l'arrêter à tout moment).
Cependant, j'ai une dernière question. Dans notre programme, nous avons des chemins relatifs or au concours, on nous demande la présence de chemin absolue. J'aimerais donc savoir comment on peut passer d'un chemin relatif, à un chemin absolue ? J'ai trouvé la fonction os.path.abspath(path) mais je n'ai pas compris le but ni l'utilisation.
Merci de votre réponse.

-F-
31/05/2021, 13h53
wiztricks

Salut,

Citation:

Envoyé par TiT_Flo

J'ai trouvé la fonction os.path.abspath(path) mais je n'ai pas compris le but ni l'utilisation.

Pour le reste os.path.abspath fait juste ce que çà dit... si vous ne savoez pas trop pourquoi vous en avez besoin, je ne vais pas l'inventer pour vous.
D'autant quil n'y a pas de noms de fichiers dans votre programme.... donc rien qui permette de savoir pourquoi vous vous posez ce genre de question et encore moins pour savoir quoi y répondre.

- W

Par exemple, sur un programme simple comme celui là, comment est-il possible de passer à un chemin dit absolue ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
from PIL import Image, ImageTk 
import  tkinter as Tk 
root = Tk.Tk() 
 
image = Image.open(r"C:\Users\user\Documents\cours\informatique\prog\proj_info\circuit.png") 
photo = ImageTk.PhotoImage(image) 
 
canvas = Tk.Canvas() 
canvas.create_image(0, 0, anchor='nw', image=photo)
canvas.create_image(1000,1000, image=photo)
canvas.pack() 
 
root.mainloop()

01/06/2021, 19h50
wiztricks

Salut,

"C:\Users\user\Documents\cours\informatique\prog\proj_info\circuit.png" est déjà un nom de chemin absolu.

- W

Voir 40 message(s) de cette discussion en une page