Bonjour,
C'est sur qu'avec ta boucle while avant le mainloop ton canvas ne s'affiche qu'à la fin.
C'est ta courbe finale ou tu as besoin d'un scrolling ?
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 # -*- coding: cp1252 -*- from Tkinter import * import numpy as np class Graph(Frame): """Barographes""" def __init__(self, maitre=None, hauteur=100, largeur = 200, fond = 'white', dimension=20): Frame.__init__(self) # constructeur de la classe parente # Définition des attributs d'instance : self.hauteur = hauteur self.largeur = largeur self.fond = fond self.dimension = dimension self.tab_old = np.zeros(shape =(self.dimension),dtype=np.float) # Définition du widget graph : self.gr = Canvas (self,height = self.hauteur, width = self.largeur, bg = fond) self.gr.pack() # fonction de tracé def setTrace(self, tab, scale): x=range(self.dimension) y=range(self.dimension) y_old=range(self.dimension) x[0] = 0. y_max = np.max (tab) y_min = np.min (tab) y_old_max = np.max (self.tab_old) y_old_min = np.min (self.tab_old) y_mean = int ((y_max + y_min)/2. + .5) y_old_mean = int ((y_old_max + y_old_min)/2. + .5) y[0] = scale * (y_mean - tab [0] ) + self.hauteur/2 y_old[0] = scale * (y_old_mean - self.tab_old [0] ) + self.hauteur/2 pas = float (self.largeur / self.dimension) i = 1 while (i < self.dimension): x[i] = float (pas * i) y[i] = scale * (y_mean - tab [i] ) + self.hauteur/2 y_old[i] = scale * (y_old_mean - self.tab_old [i]) + self.hauteur/2 self.gr.create_line(x[i-1],y_old[i-1],x[i],y_old[i],fill=self.fond) self.gr.create_line(x[i-1],y[i-1],x[i],y[i]) i +=1 self.gr.create_line(x[self.dimension-1],y_old[self.dimension-1],self.largeur,y_old[0],fill=self.fond) self.gr.create_line(x[self.dimension-1],y[self.dimension-1],self.largeur,y[0]) self.tab_old = np.copy(tab) #### Code pour tester la classe : ### def lancetrace(): i = 0 while (i<n): temp [i] = 120. + .5*(i-5.) if (i > 12): temp[i] += 2. gra.setTrace (temp, 10.) i+=1 if __name__ == '__main__': n = 20 temp = np.ndarray(shape =(20),dtype=np.float) temp.fill (120.) root = Tk() gra = Graph(root,200,400,'cyan') gra.pack(side =TOP) Button(root, text="start", command=lancetrace).pack() #gra.setTrace (temp, 10.) #gra.setTrace (temp, 10.) root.mainloop()
@+
Edit : Je présume que le while est là pour simuler le calcul ?
Merci d'utiliser le forum pour les questions techniques.
Bonjour PauseKawa,
J'ai un tableau de n valeurs physiques qui évoluent dans le temps.
En fait c'est une distribution de température le long d'un tuyau ... Donc les n valeurs sont prises à différentes abscisses le long du tuyau.
Et je veux à chaque seconde, tracer la distribution de températures sur un barographe ..
Donc toutes les valeurs sont à prises au même instant ..
La boucle while est pour aller d'une abscisse à l'abscisse suivante.
les grandeurs sont mémorisées dans tab_old uniquement pour effacer la courbe précédente en retraçant la courbe avec la couleur de fond, il y a peut-être une solution plus astucieuse ... mais je n'ai rien trouvé du genre Canvas.clear ...
Bonne journée
Bonjour,
self.gr.delete(tab ou id) ou self.gr.delete(ALL)
@+
Merci d'utiliser le forum pour les questions techniques.
Merci une fois de plus PauseKawa,
Cela simplifie déjà bien le code et c'est surement plus rapide ...
Par contre ça plante toujours de façon aléatoire
Je me demande si passer un array Numpy (tab) est acceptable ..
Voici le code dépoussiéré :
Merci encore et bonne journée
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 # -*- coding: cp1252 -*- from Tkinter import * import numpy as np class Graph(Frame): """Barographes""" def __init__(self, maitre=None, hauteur=100, largeur = 200, fond = 'white', dimension=20): Frame.__init__(self) # constructeur de la classe parente # Définition des attributs d'instance : self.hauteur = hauteur self.largeur = largeur self.fond = fond self.dimension = dimension # Définition du widget graph : self.gr = Canvas (self,height = self.hauteur, width = self.largeur, bg = fond) self.gr.pack() # fonction de tracé def setTrace(self, tab, scale): # tab est un array numpy ... est ce bien permis ?????? x=range(self.dimension) y=range(self.dimension) x[0] = 0. # calage des données entre min et max y_max = np.max (tab) y_min = np.min (tab) y_mean = int ((y_max + y_min)/2. + .5) pas = float (self.largeur / self.dimension) self.gr.delete (ALL) # destruction du tracé précédent y[0] = scale * (y_mean - tab [0] ) + self.hauteur/2 i = 1 while (i < self.dimension): x[i] = float (pas * i) y[i] = scale * (y_mean - tab [i] ) + self.hauteur/2 self.gr.create_line(x[i-1],y[i-1],x[i],y[i]) i = i+1 self.gr.create_line(x[self.dimension-1],y[self.dimension-1],self.largeur,y[0]) #### Code pour tester la classe : ### if __name__ == '__main__': n = 20 temp = np.ndarray(shape =(20),dtype=np.float) temp.fill (120.) root = Tk() gra = Graph(root,200,400,'cyan') gra.pack(side =TOP) gra.setTrace (temp, 10.) i = 0 while (i<n): temp [i] = 120. + .5*(i-5.) if (i > 12): temp[i] = temp[i] +2. i=i+1 gra.setTrace (temp, 10.) root.mainloop()
Bonjour,
Je ne comprend pas tes calculs (désolé), pour moi ton code fonctionne.
Du moins sous cette forme
Le message d'erreur est ?
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 # -*- coding: cp1252 -*- from Tkinter import * import numpy as np class Graph(Frame): """Barographes""" def __init__(self, maitre=None, hauteur=100, largeur=200, fond='white', dimension=20): Frame.__init__(self) # constructeur de la classe parente # Définition des attributs d'instance : self.hauteur=hauteur self.largeur=largeur self.fond=fond self.dimension=dimension # Définition du widget graph : conteneur=Frame(self) conteneur.pack(side=TOP) self.yscrollbar = Scrollbar(conteneur) self.xscrollbar = Scrollbar(self, orient=HORIZONTAL) self.gr=Canvas(conteneur, height=self.hauteur, width=self.largeur, bg=self.fond, xscrollcommand=self.xscrollbar.set, yscrollcommand=self.yscrollbar.set) self.gr.pack(side=LEFT) self.yscrollbar.pack(side=RIGHT, fill=BOTH) self.yscrollbar.config(command=self.gr.yview) self.xscrollbar.pack(fill=BOTH) self.xscrollbar.config(command=self.gr.xview) # fonction de tracé def setTrace(self, tab, scale): x=range(self.dimension) y=range(self.dimension) x[0]=0. # calage des données entre min et max y_max=np.max (tab) y_min=np.min (tab) y_mean=int((y_max+y_min)/2.+.5) pas=float(self.largeur/self.dimension) self.gr.delete(ALL) # destruction du tracé précédent y[0]=scale*(y_mean-tab[0])+self.hauteur/2 i=1 while (i<self.dimension): x[i]=float(pas*i) y[i]=scale*(y_mean-tab[i])+self.hauteur/2 self.gr.create_line(x[i-1], y[i-1], x[i], y[i]) self.gr.update() i+=1 #self.gr.create_line(x[self.dimension-1], y[self.dimension-1], self.largeur, y[0]) #### Code pour tester la classe : ### def lancetrace(): i=0 while (i<n): print i temp[i]=120.+.5*(i-5.) if (i>12): temp[i]+=2. gra.setTrace(temp, 10.) i+=1 if __name__ == '__main__': n=100 temp=np.ndarray(shape=(n), dtype=np.float) temp.fill(120.) root=Tk() gra=Graph(root, 600, 800, 'cyan', n) gra.pack(side=TOP) Button(root, text="start", command=lancetrace).pack() root.mainloop()
@+
Merci d'utiliser le forum pour les questions techniques.
Merci, je regarde cela ....
Le message d'erreur n'est pas toujours le même ....
Il y a trois possibilités :
- 1ier cas : le programme se termine tout seul sans message d'erreur, sans rien simplement comme si je l'avais arrêté moi même ... et si je retire les barographes cela ne se produit jamais ... j'en conclus donc que le problème est là ...
- second cas : je reçois un message du genre : "la mémoire @%xxxxx ne peut pas être read Python.exe doit être interrompu OK "
- 3ième cas : "erreur dans xxxx.setTrace ....." qui laisse sous entendre un débordement de tableau ... si c'est le cas cela devrait être systématique puisque 10000 fois par seconde le programme fait exactement la même chose
Et si je retire les barographes ... tout fonctionne nickel pendant des heures, une nuit entière sans crash
Avec les barographes, ça peut tourner 1 heure, mais ça peut aussi planter au bout de 10 secondes, ou 10 minutes ...
Je pense qu'il y a quelque part un truc qui déborde ... s'il déborde dans une zone non critique ça passe sans problème ... sinon ça buggue ..
Je regarde ton bout de code et je te tiens informé.
Merci encore
Je vais dormir, il est presque minuit ..
A+
Bonsoir,
Bizarre, on dirais qu'il garde le nom mais perd l'objet... Et encore même pas puisqu'il utilise Tcl. C'est plutôt le type du widget qui est perdu (utilisation du nom pour autre chose ou fatigue mentale de ma part ?).
Dans ce cas autant réduire pour voir ou/si cela bloque
Et encore... Tu peut mettre setTrace dans lancetrace.
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 # -*- coding: cp1252 -*- from Tkinter import * import numpy as np # fonction de tracé def setTrace(tab, scale): x=range(100) y=range(100) x[0]=0. # calage des données entre min et max y_max=np.max (tab) y_min=np.min (tab) y_mean=int((y_max+y_min)/2.+.5) pas=float(200/100) gr.delete(ALL) # destruction du tracé précédent y[0]=scale*(y_mean-tab[0])+100/2 i=1 while (i<100): x[i]=float(pas*i) y[i]=scale*(y_mean-tab[i])+100/2 gr.create_line(x[i-1], y[i-1], x[i], y[i]) gr.update() i+=1 #self.gr.create_line(x[self.dimension-1], y[self.dimension-1], self.largeur, y[0]) #### Code pour tester la classe : ### def lancetrace(): i=0 while (i<n): print i temp[i]=120.+.5*(i-5.) if (i>12): temp[i]+=2. setTrace(temp, 10.) i+=1 if __name__ == '__main__': n=100 temp=np.ndarray(shape=(n), dtype=np.float) temp.fill(120.) root=Tk() conteneur=Frame(root) conteneur.pack(side=TOP) yscrollbar = Scrollbar(conteneur) xscrollbar = Scrollbar(root, orient=HORIZONTAL) gr=Canvas(conteneur, height=600, width=800, bg='cyan', xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set) gr.pack(side=LEFT) yscrollbar.pack(side=RIGHT, fill=BOTH) yscrollbar.config(command=gr.yview) xscrollbar.pack(fill=BOTH) xscrollbar.config(command=gr.xview) Button(root, text="start", command=lancetrace).pack() root.mainloop()
@+
Edit : Tu devrais refaire un sujet. Cela ne correspond plus au titre et tu aurais plus de chance d'avoir une réponse.
Merci d'utiliser le forum pour les questions techniques.
Bonjour,
Il est aussi possible que cela soit le type float de ta liste.
Donc gr.create_line(int(x[i-1]), int(y[i-1]), int(x[i]), int(y[i]))
Les valeurs ? Tu semble avoir une plage grosso modo de -350/+350 pour x/y (principalement y).
Il serait peut etre bon de faire une marge de 400, faire un canvas de 800 et de faire y[i]+400 (donc 400=0). De même pour x.
Enfin, cela iras mieux après le café.
@+
Edit : Fais aussi un print x[i-1], y[i-1], x[i], y[i] avant ton create_line pour vérifier tes données.
Pour l'histoire du 400 c'est juste pour l'affichage. J'ai fais
print x[i-1], y[i-1], x[i], y[i]
#print type(x[i])
gr.create_line(int(x[i-1]), int(y[i-1])+400, int(x[i]), int(y[i])+400)
@++
Merci d'utiliser le forum pour les questions techniques.
Merci encore PauseKawa de t'intéresser à mon cas ..
Effectivement en repassant en pixels, je me retrouve avec des entiers, je n'y avais pas pensé ....
Les valeurs sont bonnes car le programme de simulation fonctionne nickel sans les barographes .... et si par malheur une variable était erronée il se planterait immédiatement ...
J'ai refait un bout de code minimum ... avec la génération de la fenêtre ... un thread minimum qui calcule une distribution de température fictive ... et toujours le même pb évidemment
Je regarde en passant en entiers et en vérifiant bien les valeurs limites ...
Sinon je suivrai ton conseil en ouvrant un autre fil ...
Bonne journée
Bonjour PauseKawa,
Je ne crie pas victoire ...
Mais depuis le passage des coordonnées en entiers dans les appels à create_line je n'ai pas noté de plantage ..
Bonne journée et merci encore
Bonjour,
Une bonne chose pour moi : J'étais en train de revoir cela avec pylab (que je ne connais pas) pour te trouver une soluce.
Je suis donc en Weekend
@+
Merci d'utiliser le forum pour les questions techniques.
Bonjour PauseKawa,
J'avais raison de ne pas crier victoire ...
Il y a encore des plantages, mais très rarement, avec le message:
L'instruction à "0x00db5d23" emploie l'adresse mémoire "0x0000000c" la mémoire ne peut pas être "read" ...
J'imprime les données mais rien d'anormal et Python n'envoie aucun message ..
Le pb est que c'est très rare, il faudrait que je fasse tourner le prog sans les graphes, car le problème est peut-être ailleurs ..
Je ne suis pas très bon en prog objet, je fais beaucoup de chose à tâtons
Bonne journée
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager