Discussion :

[bm]

Bonjour,

Je veux renouveler un graphique dans une boucle while.
Mais les graphiques s'empilent l'un après l'autre.
Est ce possible ?

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
import matplotlib.pylab as plt
%matplotlib inline
import time
global pulse
pulse=[0]
 
while True:
 
    t = time.strftime("%Hh%M")
    m = int(time.strftime("%M"))
 
    if m%5 ==0 :
        time.sleep(30)
        t = time.strftime("%Hh%M")
        file = !ls ./ima_train
        dd =t+' : '+str(len(file))
        pulse.append(len(file))
        print(dd)
        time.sleep(80)
        plt.plot(pulse)
        plt.show()

pulse compte des fichiers dans ima_train
c'est un traitement d'image que je veux suivre
avec une courbe de temps

@+

[racine carrée]

Il y a sûrement un moyen de fermer la fenêtre (je crois qu'il faudrait regarder du côté d'un module comme tkinter, ou encore pygame) et de rouvrir le nouveau graphique, et cela périodiquement, mais je ne crois pas que l'on puisse modifier un graphique déjà tracé (le module matplotlib n'a pas été conçu pour cela, à ce que je sache, mais je ne suis pas sûr à 100% !).

[lg_53]

Il faut voir le type de tracé que vous faites mais une bonne partie des objets matplotlib possèdent des setters (notamment set_data) pour modifier directement les données sous jacente sans avoir à retracer tout le graphique.

[Julien N]

Il faut voir le type de tracé que vous faites mais une bonne partie des objets matplotlib possèdent des setters (notamment set_data) pour modifier directement les données sous jacente sans avoir à retracer tout le graphique.

Très juste, voici un exemple illustrant set_data

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
import time
import numpy as np
import matplotlib.pyplot as plt
 
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
def gen_random_data(n):
    return np.random.random(n)
 
x = np.linspace(0, 50, 50)
 
# On crée un figure qui sera mise à jour au fur et à mesure
fig, ax = plt.subplots()
ax.grid(True)
ax.set_ylim((0, 1))
 
# On crée un ligne "vide" dont les points seront mis à jours.
l, = ax.plot(x, np.ones_like(x))
 
# Toutes les secondes de nouvelles données sont générées et le graph est
# mis à jour
for i in range(10):
    y = gen_random_data(50)
    l.set_data(x, y)
    # Là réside l'astuce. Il faut demander à retracer la figure, sinon
    # rien ne se passe.
    fig.canvas.draw()
    time.sleep(1)

A noter que dans cet exemple, la figure n'est pas recadrée à chaque update. Donc si les nouvelles valeurs sont en dehors des bornes initialement définies, on ne les voit pas.

J

[racine carrée]

Code :

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

1
2
3
4
...
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
...

Je ne sais pas ce que fait ce programme quand vous le testez, mais chez moi la fenêtre 'figure 1' s'ouvre mais rien ne s'y trace (elle ne répond pas), et au bout de 10 secondes, le tracé apparait d'un coup.

[Julien N]

Je ne sais pas ce que fait ce programme quand vous le testez, mais chez moi la fenêtre 'figure 1' s'ouvre mais rien ne s'y trace (elle ne répond pas), et au bout de 10 secondes, le tracé apparait d'un coup.

Salut,

Intéressant, chez moi ça marche bien (j'ai quand même testé avant de poster :)). J'ai matplotlib en version 2.2.2 pour info et j'execute mon code depuis une console.

J

[bm]

Où placer plt.show() ?
C'est ce qui déclanche l'affichage dans la page Ipython

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
import time
import numpy as np
import matplotlib.pyplot as plt
 
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
def gen_random_data(n):
    return np.random.random(n)
 
x = np.linspace(0, 50, 50)
 
# On crée un figure qui sera mise à jour au fur et à mesure
fig, ax = plt.subplots()
ax.grid(True)
ax.set_ylim((0, 1))
 
# On crée un ligne "vide" dont les points seront mis à jours.
l, = ax.plot(x, np.ones_like(x))
 
# Toutes les secondes de nouvelles données sont générées et le graph est
# mis à jour
for i in range(10):
    y = gen_random_data(50)
    l.set_data(x, y)
    # Là réside l'astuce. Il faut demander à retracer la figure, sinon
    # rien ne se passe.
    fig.canvas.draw()
    time.sleep(10)

# Là réside l'astuce. Il faut demander à retracer la figure, sinon
# rien ne se passe.
fig.canvas.draw()
print(i)
plt.show()
time.sleep(10)

Ipython reste statique avec i=0
La page dynamique dans Ipython est impossible

Merci de votre apport sur ce sujet

Hors Ipython,je ne vois pas les points avec une boucle while :

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
import time
import os
import numpy as np
import matplotlib.pyplot as plt
 
# Fait en sorte que le traçage soit interactif. Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
x = np.linspace(0, 50, 50)
# On crée un figure qui sera mise à jour au fur et à mesure
fig, ax = plt.subplots()
ax.grid(True)
ax.set_ylim((0, 1))
 
# On crée un ligne "vide" dont les points seront mis à jours.
l, = ax.plot(x, np.ones_like(x)) 
 
while True:
 
    t = time.strftime("%Hh%M")
    m = int(time.strftime("%M"))
 
    if m%2 ==0 :
        time.sleep(10)
        t = time.strftime("%Hh%M")
        path = '/..../'
        file = os.listdir(path)
        l.set_data(x, len(file))       
        fig.canvas.draw()
        time.sleep(1)
        print(len(file))

[Julien N]

J'ai pas fait attention au fait que vous utilisiez un notebook IPython. Je ne maitrise pas ce sujet. Je viens de trouver cette réponse sur stackoverflow qui pourrait répondre à votre problème. Je copie le code ci-après:

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
%matplotlib notebook
 
import numpy as np
import matplotlib.pyplot as plt
import time
 
def pltsin(ax, colors=['b']):
    x = np.linspace(0,1,100)
    if ax.lines:
        for line in ax.lines:
            line.set_xdata(x)
            y = np.random.random(size=(100,1))
            line.set_ydata(y)
    else:
        for color in colors:
            y = np.random.random(size=(100,1))
            ax.plot(x, y, color)
    fig.canvas.draw()
 
fig,ax = plt.subplots(1,1)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_xlim(0,1)
ax.set_ylim(0,1)
for f in range(5):
    pltsin(ax, ['b', 'r'])
    time.sleep(1)

Par contre, hors IPython, vous avez un problème avec le contenu de votre boucle while. Vous faites:

Code :

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

l.set_data(x, len(file))

Mais x est un array de 50 éléments alors que len(file) est un entier. C'est étonnant que vous n'ayez pas de message d'erreur. Que cherchez vous à tracer?

J

[bm]

len(file) c'est pour suivre une boucle while qui converti des images dans un dossier
1024x1024 pixels en 128x128 pixels

Cela va bien au début et ensuite python sature
C'est un mix avec PIL , savefig , os.systeme , -resize 128x128\!

Un pré-traitement avant passage dans un réseau de neurones
pour classifier les images

Je vais voir cette fonction set_data plus en détail ...

[bm]

Ajouter 3 points n'est pas actif avec set_data(x,y) :
set_data est une fonction spéciale ...

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
import matplotlib.pyplot as plt
import numpy as np
import time
 
# Fait en sorte que le traçage soit interactif. 
# Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
fig = plt.figure()
 
x = np.array([ 1, 2, 3])
y = np.array([ 10, 20, 30])
 
line, = plt.plot(x, y, color='blue', lw=2)
 
 
def update_points(new_x, new_y):
    global x, y, fig, line1, ax
    x = np.append(x, new_x)
    y = np.append(y, new_y)
    print(x)
    print(y)
    line.set_data(x,y)
    fig.canvas.draw()
 
 
update_points(np.array([4, 5, 6]), np.array([4, 5, 3]))
plt.show()
time.sleep(10)

[racine carrée]

Intéressant, chez moi ça marche bien (j'ai quand même testé avant de poster ). J'ai matplotlib en version 2.2.2 pour info et j'execute mon code depuis une console.

En fait c'est assez étrange car si j'exécute "fig, a = plt.subplots()" dans la console, la fenêtre s'affiche. Si je fais ensuite "a.grid(True)" ça ce met à jour. Si je fais "a.plot(L1,L2)" ça marche aussi.
Par contre si j'exécute tous d'un coup en mettant un "time.sleep(1)" entre chacune de ces actions, la fenêtre ne répond pas et tout s'affiche d'un coup à la fin.
J'ai donc essayer d'exécuter "fig, a = plt.subplots(); time.sleep(1)" dans la console, et la fenêtre attend que le time.sleep soit finis pour se rafraichir.
Dites moi si c'est la même chose pour vous, car ça me parait vraiment étrange.
(remarque: en rajoutant des "fig.canvas.draw()" entre chaque commande, ça ne change rien !)

[lg_53]

A noter que dans cet exemple, la figure n'est pas recadrée à chaque update. Donc si les nouvelles valeurs sont en dehors des bornes initialement définies, on ne les voit pas.

J

Si si, ca fonctionne très bien.
Mais comme on vous la dit précédemment, si les données ajouter sorte du cadre défini lors de la visualisation des toute premières données, alors vous ne voyez rien, car le cadre n'est pas réajusté. Et c'est exactement ce que vous faite ici. Au départ x varie de 0 à 3. Vous rajouter des valeurs 4 5 et 6, qui sont donc hors cadre. Pareil en ordonnée. Pourtant si vous faites un

Code :

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

print(line.get_data())

vous vous rendez bien compte que l'objet à été mis à jour. Et donc le fait que la visualisation ne suivent pas derrière est un autre problème.

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
import matplotlib.pyplot as plt
import numpy as np
import time
 
## Fait en sorte que le traçage soit interactif. 
## Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
fig = plt.figure('toto')
fig.clf()
 
ax = fig.add_subplot(111)
 
x = np.array([ 1, 2, 3])
y = np.array([ 10, 20, 30])
 
line, = ax.plot(x, y, '+', color='blue')
ax.set_ylim([0,40])
ax.set_xlim([0,6])
 
fig.canvas.draw()
fig.canvas.flush_events()
 
 
time.sleep(1)
 
new_x, new_y = np.array([4, 5, 6]), np.array([4, 5, 3])
x = np.append(x, new_x)
y = np.append(y, new_y)
print(line.get_data())
line.set_data(x,y)
print(line.get_data())
fig.canvas.draw()
fig.canvas.flush_events()

Pour la visualisation ce qui se passe en effet sur la plupart des machines ce sont des "problèmes" de bufferisation. C'est à dire que l'ordinateur pour économiser ces ressources va faire les opérations mais n'afficher le résultat qu'à la fin. Ce sujet https://stackoverflow.com/questions/...-in-matplotlib en parle très bien, et aborde la fonction flush_events() qui justement oblige python à ne pas aller à l'économie et à afficher l'état dans lequel c'est.

Le code que je vous présente ci dessus, avec définition des bornes de l'axe dès le début + flush_events() fonctionne très bien.

[lg_53]

@racine_carrée : oui ca fait la même chose chez moi. Le sleep est bufferisé, voila pourquoi tout se fige jusqu'à la résolution complète du code

[bm]

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
import matplotlib.pyplot as plt
import numpy as np
import time
import random 
 
## Fait en sorte que le traçage soit interactif. 
## Sinon la figure est affichée qu'à la toute fin.
plt.ion()
 
fig = plt.figure('toto')
fig.clf()
 
ax = fig.add_subplot(111)
 
x = np.array([ 1, 2, 3])
y = np.array([ 10, 20, 30])
 
line, = ax.plot(x, y, '-', color='blue',lw=8)
ax.set_ylim([0,40])
ax.set_xlim([0,100])
ax.grid()
 
fig.canvas.draw()
fig.canvas.flush_events()
 
time.sleep(1)
 
for i in range(50):
 
    new_x, new_y = x[-1]+2, random.randint(25, 35)
    x = np.append(x, new_x)
    y = np.append(y, new_y)
    print(line.get_data())
    line.set_data(x,y)
    print(line.get_data())
    fig.canvas.draw()
    fig.canvas.flush_events()
    time.sleep(1)

Voici la solution que je cherchais