Discussion :

[blacksqd]

Bonjour,

Mon problème consiste à la création d'un dessin qui devrait se mettre à jour toutes les 1.5 secondes.
Mon programme utilise Tkinter avec une classe qui gère le tout. Ne sachant pas où m'orienter pour le dessin,
j'ai utilisé matplotlib dans un premier temps.

Voici le code actuel :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def draw(self):
        fig = plt.figure()
        plt.grid(True)
        axes = plt.gca()
        axes.set_ylabel("pH")
        axes.set_xlabel("Temps")
        temp = [self.mypH - 3 + x/2. for x in range(14)]
        axes.set_yticks(temp)
        axes.set_ylim(self.mypH - 3, self.mypH + 3)
        tabx = [x * 1.5 for x in range(len(self.tab))]
        plt.plot(tabx, self.tab)
        plt.show()

J'ai dans ma classe créé un bouton qui m'appelle cette fonction draw. Pour le moment donc,
je clique et il m'affiche le dessin avec les informations actuelles. Cependant, mon "self.tab" se
met à jour toutes les 1.5 secondes et j'aimerais bien que mon dessin en fasse de même tant qu'il
est lancé. J'ai creusé en essayant un code similaire au suivant :

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
 
def draw(self):
    fig = plt.figure()
    ax = fig.add_subplot(111)
 
    li, = ax.plot([], [])
 
    # draw and show it
    fig.canvas.draw()
    plt.show(block=False)
    while True:
        try:
            li.set_xdata([x * 1.5 for x in range(14)])
            li.set_ydata(self.tab)
 
            fig.canvas.draw()
 
            time.sleep(1.5)
        except KeyboardInterrupt:
             break

Mais ici j'ai le souci que je ne peux plus fermer la fenêtre... Au début je n'avais pas mis le try-except
mais même en rajoutant celui-ci, rien n'y fait. J'aimerais juste cliquer sur la croix et que la fenêtre se
ferme.

J'espère avoir été clair.

Merci de votre aide.

[VinsS]

Salut,

Ça ne peut pas fonctionner de cette façon. Tu maintiens ton code prisonnier d'une boucle while sans fin et en le bloquant avec un time.sleep qui plus est.

Je ne sais pas ce que c'est que self.tab mais on devine que ce sont les données qui varient avec le temps. Donc, c'est lors d'un changement de ces données que doit être appelée la fonction de dessin.

Tu peux aussi le faire automatiquement avec un timer, mais en utilisant le Timer du module threading, certainement pas avec time.sleep.

[blacksqd]

Oui il était emprisonné dans une boucle While, mais j'appelais cette fonction via un nouveau thread, donc je me disais que le reste pouvait continuer sans problème.
Il est possible de mettre le dessin à jour toutes les X secondes via les threads si je comprends bien ?

Merci déjà de ta réponse

[wiztricks]

Salut,

Il est possible de mettre le dessin à jour toutes les X secondes via les threads si je comprends bien ?

Peut-être qu'une recherche avec les mots clés "matplotlib+animation" vous donnerait des pistes (plus) intéressantes.

- W

[blacksqd]

Salut,

j'ai essayé de regarder matplotlit+animation. J'y ai trouvé des informations mais je n'arrive toujours pas à les faire fonctionner.
Voici le code, presque recopié d'ailleurs :

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
 
#For drawing
        self.fig = plt.figure()
        self.ax = self.fig.add_subplot(111)
        self.line = matplotlib.lines.Line2D([0], [0])
        self.ax.add_line(self.line)
        plt.grid(True)
        self.ax.set_ylabel("pH")
        self.ax.set_xlabel("Temps")
        temp = [float(PHVALUE.get()) - 3 + x/2. for x in range(14)]
        self.ax.set_yticks(temp)
        self.ax.set_ylim(float(PHVALUE.get()) - 3,\
        float(PHVALUE.get()) + 3)
 
def init(self):
    self.line.set_data([],[])
    return self.line,
 
def update(self, i):
    tabx = [x * 1.5 for x in range(len(self.tab))]
    self.line.set_data(tabx, self.tab)
    return self.line,
 
def callAnimation(self):
    anim.FuncAnimation(self.fig, self.update, init_func = self.init,\
        frames = 200, interval = 20, blit = True)

Quand je clique sur un bouton, cela appelle la fonction "callAnimation". En testant, je rentre bien dans la fonction "self.init" mais
jamais dans la fonction "self.update" et je ne comprends pas pourquoi.

Merci de votre aide

[wiztricks]

Salut,

En supposant que vous vous soyez inspiré de cet exemple là, je peux aussi supposer que vous avez réussi à le faire fonctionner (après l'avoir recopié). A partir de là, il faut voir comment vous avez adapté cela dans votre code à vous...
Et sans poster un code suffisant pour reproduire le soucis rencontré, çà va pas être possible.

- W

[blacksqd]

Je me suis plutôt inspiré de ce code ci.
http://matplotlib.org/examples/anima...hart_demo.html

J'ai essayé de faire un résumé de mon code

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
 
class Interface(Frame):
    #Fenetre principale d'affichage
    def __init__(self, parent):
        global APP
        Frame.__init__(self, parent)
        self.parent = parent
        centrefenetre(APP)
        APP.resizable(width = False, height = False)
        self.grid()
 
        #For drawing
        self.fig = plt.figure()
        self.ax = self.fig.add_subplot(111)
        self.line = matplotlib.lines.Line2D([0], [0])
        self.ax.add_line(self.line)
        plt.grid(True)
        self.ax.set_ylabel("pH")
        self.ax.set_xlabel("Temps")
        temp = [float(7 + x/2. for x in range(14)]
        self.ax.set_yticks(temp)
        self.ax.set_ylim(4, 10)
 
    	Button(self, text = "Graphique", command = self.callAnimation).grid()
    	thread.start_new_thread(self.capture, ())
 
    def capture(self):
    	while True:
	    	mise_a_jour(self.tab)
	    	time.sleep(1.5)
 
    def init(self):
        self.line.set_data([],[])
        return self.line,
 
    def update(self, i):
        tabx = [x * 1.5 for x in range(len(self.tab))]
        self.line.set_data(tabx, self.tab)
        return self.line,
 
    def callAnimation(self):
        anim.FuncAnimation(self.fig, self.update, init_func = self.init,\
            frames = 200, interval = 1500, blit = True)
        plt.show()
 
def main():
    APP = Tk()
    interface = Interface(APP)
    APP.mainloop()

mise_a_jour(self.tab) récupère simplement des informations d'un capture et cela fonctionne bien.
Lorsque je clique sur mon boutton, une fenêtre s'ouvre bien avec les axes et tout. Mais d'autre n'est
affiché. J'ai mis un petit print("ici") dans self.update et il ne s'affiche jamais, je ne rentre donc jamais
dedans. Une autre info (je ne sais si tout ce que je dis est utile mais on ne sait jamais) est que lorsque
je coupe la figure, et que je reclique sur le boutton, j'ai l'erreur suivante :

TclError : This isn't a Tk application

Merci de votre aide

[blacksqd]

Petite mise à jour,

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
import matplotlib.animation as anim
import matplotlib.pyplot as plt
import matplotlib
 
import thread
import time
from Tkinter import *
 
APP = Tk()
 
def centrefenetre(fen):
    fen.withdraw()
    fen.update_idletasks()
    x = (1366 - fen.winfo_reqwidth()) / 2
    y = (678 - fen.winfo_reqheight()) / 2
    fen.geometry("+%d+%d" % (x,y))
    fen.deiconify()
 
 
class Interface(Frame):
    #Fenetre principale d'affichage
    def __init__(self, parent):
        global APP
        Frame.__init__(self, parent)
        self.parent = parent
        centrefenetre(APP)
        APP.resizable(width = False, height = False)
        self.grid()
 
        #For drawing
        self.fig = plt.figure()
        self.ax = self.fig.add_subplot(111)
        self.line = matplotlib.lines.Line2D([0], [0])
        self.ax.add_line(self.line)
        plt.grid(True)
        self.ax.set_ylabel("pH")
        self.ax.set_xlabel("Temps")
        temp = [4 + x/2. for x in range(14)]
        self.ax.set_yticks(temp)
        self.ax.set_ylim(4,10)
    	self.tab = []
 
    	Button(self, text = "Graphique", command = self.callAnimation).grid()
    	thread.start_new_thread(self.capture, ())
 
    def capture(self):
    	cpt = 4.5
    	while True:
    		cpt += 0.1
	    	self.tab += [cpt]
	    	time.sleep(1.5)
 
    def init(self):
        self.line.set_data([],[])
        return self.line,
 
    def updateX(self, i):
        tabx = [x * 1.5 for x in range(len(self.tab))]
        print len(self.tab), len(tabx)
        self.line.set_data(tabx, self.tab)
        return self.line,
 
    def callAnimation(self):
        self.myanim = anim.FuncAnimation(self.fig, self.updateX, init_func = self.init,\
            frames = 200, interval = 1500)
        plt.show()
 
def main():
    interface = Interface(APP)
    APP.mainloop()
 
 
if __name__ == '__main__':
    main()

Afin qu'il affiche quelque chose, il fallait garder une référence à mon animation.
Il rentre donc actuellement dans self.updateX mais par contre, il ne met pas à
jour le graphique.

[blacksqd]

J'ai résolu mon souci.

Voici ma solution si jamais cela arrive à d'autres personnes.

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
71
72
73
74
75
76
77
78
79
 
import matplotlib.animation as anim
import matplotlib.pyplot as plt
import matplotlib
 
import thread
import time
from Tkinter import *
 
APP = Tk()
 
def centrefenetre(fen):
    fen.withdraw()
    fen.update_idletasks()
    x = (1366 - fen.winfo_reqwidth()) / 2
    y = (678 - fen.winfo_reqheight()) / 2
    fen.geometry("+%d+%d" % (x,y))
    fen.deiconify()
 
 
class Interface(Frame):
    #Fenetre principale d'affichage
    def __init__(self, parent):
        global APP
        Frame.__init__(self, parent)
        self.parent = parent
        centrefenetre(APP)
        APP.resizable(width = False, height = False)
        self.grid()
 
    	self.tab = []
 
    	Button(self, text = "Graphique", command = self.callAnimation).grid()
    	thread.start_new_thread(self.capture, ())
 
    def capture(self):
    	cpt = 4.5
    	while True:
    		cpt += 0.1
	    	self.tab += [cpt]
	    	time.sleep(1.5)
 
    def init(self):
    	tabx = [x * 1.5 for x in range(len(self.tab))]
        self.ax.set_xlim(0, 1.5 * len(self.tab))
        self.line.set_data(tabx, self.tab)
        return self.line,
 
    def updateX(self, i):
        tabx = [x * 1.5 for x in range(len(self.tab))]
        self.ax.set_xlim(0, 1.5 * len(self.tab))
        self.line.set_data(tabx, self.tab)
        return self.line,
 
    def callAnimation(self):
    	#For drawing
        self.fig = plt.figure()
        self.ax = self.fig.add_subplot(111)
        self.line = matplotlib.lines.Line2D([0], [0])
        self.ax.add_line(self.line)
        plt.grid(True)
        self.ax.set_ylabel("pH")
        self.ax.set_xlabel("Temps")
        temp = [4 + x/2. for x in range(14)]
        self.ax.set_yticks(temp)
        self.ax.set_ylim(4,10)
 
 
        self.myanim = anim.FuncAnimation(self.fig, self.updateX, init_func = self.init,\
            frames = 200, interval = 1500)
        plt.show()
 
def main():
    interface = Interface(APP)
    APP.mainloop()
 
 
if __name__ == '__main__':
    main()