Discussion :

[nicogigo]

Bonjour,

Je me plonge dans la création de graphiques avec pythons. Je veux juste faire un graphique tout con en 2D avec un axe x et un axe y. Une évolution dans le temps en x et une évolution en pression en y. Donc vraiement rien de bien sorcier. J'ai récupéré l'exemple suivant :

Code :

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

1
2
3
4
5
6
7
8
9
 
from numpy import *
import Gnuplot
x=arange(0,10)
y=arange(0,10)
z=random.standard_normal((10,10))
g = Gnuplot.Gnuplot(debug=1)
g('set data style linespoints')
g.splot(Gnuplot.GridData(z,x,y, binary=0))

Mais l'explication sur à quoi sert chaque ligne n'était pas très clair. J'ai du mal à trouver un tutoriel à la fois simple et qui fonctionne bien (souvent ils donnent des exemples avec des formules mathématiques complexes). Le graphique obtenu suivant est un exemple 2D, moi ce que je veux est un exemple de graphique 2D tout simple.
Quelqu'un aurait il un tuto simple fournissant le plus basic des exemples pour un débutant à qui faut presque tout expliquer?

Merci pour votre aide

[nyko77]

Bonjour,
Je serais toi, j'utiliserais plutôt matplotlib, c'est mieux documenté.

Code :

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

1
2
3
4
5
6
7
8
9
 
import matplotlib.pyplot as plt
from numpy import *
plt.xlabel('Temps')
plt.ylabel('Pression')
x=arange(0,10)
y=arange(0,10)
plt.plot(x, y)
plt.show()

[nicogigo]

Merci, c'est effectivement très simple d'utilisation et ça marche bien.

[nicogigo]

Si quelqu'un sait, mon problème devient plus compliqué.

Je fais tourner mon programme qui calcul une vitesse et une pression qui évolue dans le temps, dans les variables "pression" et "mach". Je souhaiterais que au fur et à mesure que ce que le programme tourne pour faire son calcul qui simule par exemple 10 secondes, mon graphique (temps en x et les 2 autres variables en y) s'actualise au fur et à mesure de la simulation.

Quelqu'un aurait il une idée sur comment faire?

[nyko77]

Il y a pas mal d'exemple sur le site de matplotlib: http://matplotlib.sourceforge.net/examples/index.html

Regarde notamment le animation example code: animation_blit_tk.py.

[nicogigo]

Salut,

Je me penche à nouveau sur la question des graphiques dynamiques. J'ai regardé les exemples de mathplotlib. Leurs exemples fonctionnent bien, le problème est qu'il n'y a aucune explication sur comment fonctionne le code, à quoi sert chacune des lignes. Quelqu'un connaitrait il un bon tuto?
Je veux juste faire tourner un programme qui effectue des calculs et afficher un graphique dynamique qui s'actualise à chaque fois qu'une ligne de calcul se termine.

Merci de votre aide

[ju_bicycle]

Hello,
Pour avoir un graphique dynamique avec matplotlib, j'utilise cette méthode qui est trés simple. P'tet pas la plus efficace d'ailleurs, mais elle a le mérite de marcher!

Code :

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

1
2
3
4
5
6
 
def DrawGraph(liste_x,liste_y):
    plt.interactive(True) #Permet d'être en mode dynamique
    plt.figure(x) #tu met ici un numéro de figure, ca permet de gérer plusieur graphique
    plt.clf() #clear figure
    et la tu met tes lignes qui dessinent ton graph et qui utilisent liste_x et liste_y

et tu appelle ta fonction a chaque fois que tu a calculé des nouvelles valeurs...Le tour est joué

[nicogigo]

Merci, je vais tester ça, je pense que ça fonctionnera bien. J'avais un autre exemple que je commençais à comprendre mais horriblement compliqué. Celui là est simple.

[nicogigo]

J'ai dû zapper un truc. J'ai fais un simple programme de test. Il affiche une seule fenêtre, ensuite il en ouvre une nouvelle au fur et à mesure que je ferme l'ancienne. Si quelqu'un pouvait avoir une idée pour débugger 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
import matplotlib.pyplot as plt
import time
 
def DrawGraph(liste_x,liste_y):
    plt.interactive(True) 
    plt.figure(1)
    plt.clf()
    plt.plot(liste_x,liste_y)
    plt.show()
 
liste_x=[]
liste_y=[]
 
x=1
y=1
step=0
 
while (step<100):
    x=x+3
    y=y+2
    liste_x.append(str(x))
    liste_y.append(str(y))
    time.sleep(.1)
    step=step+1
    command=DrawGraph(liste_x,liste_y)

[ju_bicycle]

il ne faut plus mettre le plt.show()

[nicogigo]

Dommage, quelqu'un d'autre alors aurait une idée? Je me penche sur cet exemple : http://matplotlib.sourceforge.net/ex...n_blit_tk.html

Bon il fonctionne, mais il y a plus de 10 lignes de codage sans compter la partie calcul juste pour afficher ce graphique. Et aucune explication dessus, juste quelques commentaires. N'existe il vraiment pas une solution plus simple sous python?

[nicogigo]

J'ai essayé de faire un test tout simple de graphique. Je ne fais que incrémenter x et y de 1 à chaque passage dans une boucle. Il n'affiche hélas rien. Je vous communique mon code, merci de me dire si vous savez pourquoi mon graphique ne veut pas s'afficher :

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
# -*- coding: cp1252 -*-
 
import matplotlib
matplotlib.use('TkAgg')
 
import sys
import pylab as p
import numpy as npy
import time
 
def run():
    step=0
    x=0
    y=0
    background=canvas.copy_from_bbox(ax.bbox)
    while (step<100):
        x=x+1
        y=y+1
        canvas.restore_region(background)
        line.set_xdata(x)
        line.set_ydata(y)
        ax.draw_artist(line)
        canvas.blit(ax.bbox)
        step=step+1
 
#Définition du graphique et placement dans une fenêtre
 
ax = p.subplot(111)
canvas = ax.figure.canvas
 
#Définition des variables du graphique
 
x=0
y=0
 
#Définition du tracé initial
 
line,=p.plot(x,y,animated=True,lw=2)
 
#
 
p.grid()
manager = p.get_current_fig_manager()
manager.window.after(100, run)
 
#Pour afficher le graphique
 
p.show()

N'existe il pas d'outil plus simple pour faire des graphs dynamiques? Pour l'instant, je trouve celà extrêmement complexe.

[ju_bicycle]

Salut
Bon il se trouve que je vais devoir me pencher sur le probleme, p'tet qu'a deux on y arrivera!
A premiere vu ce qui rend les choses complexe c'est que les exemples qu'ils donnent integrent les fenetre matplot lib a des ensembles plus larges de bibliotheque graphique (TK, Wx, GTK etc...).
Est-on obliger de faire ca? Aucune idée je vais regarder ca cette aprem.
Si je trouve des truc je te fais signe. Hésite pas toi aussi

Y'a aussi un second probleme, c'est que clairement sous Windows ca ne marche pas tout a fait pareil. bon c'est peut être du a mon install (un peu à l'arrache), mais même les exemples du sites me donnent des erreurs(je vois bien la courbe évolué, mais plante au moment de finir le programme)
++
Julien

[nyko77]

C'est normale que ça n'affiche rien tu assignes un points (x,y). Il faut mettre une liste si tu veux afficher une courbe.
Voici un exemple, j'ai juste utilisé random.shuffle pour modifier l'axe y à chaque itération:

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
 
# -*- coding: cp1252 -*-
 
import matplotlib
matplotlib.use('TkAgg')
from random import shuffle
import sys
import pylab as p
import numpy as npy
import time
 
#Définition du graphique et placement dans une fenêtre
 
ax = p.subplot(111)
canvas = ax.figure.canvas
 
x=range(10)
y=range(10)
 
line,=p.plot(x,y,animated=True,lw=2)
 
def run():
    step = 1
    background=canvas.copy_from_bbox(ax.bbox)
    y=range(10)
    while (step<100):
        canvas.restore_region(background)
        shuffle(y)
        line.set_ydata(y)
 
        ax.draw_artist(line)
        canvas.blit(ax.bbox)
        step=step+1
 
#Définition des variables du graphique
 
p.grid()
manager = p.get_current_fig_manager()
manager.window.after(100, run)
 
#Pour afficher le graphique
 
p.show()

[ju_bicycle]

Salut a tous
Alors voila, j'ai un peu planché la dessus et je propose une solution qui a le mérite d'être simple. Certes j'ai un peu plus de ligne que celle de Nyko77, mais au moins je les comprends toutes. Pas de galere avec les Tkinter et autres...
En fait la ligne "Magique" c'est plt.draw()

voila l'esprit du truc:
on créer un objet (DrawGraph) avec une méthode (Add_point) qui permet d'ajouter un nouveau point au graphique. Evidemment j'ai rien inventé ca utilise du MatPlotLib.

C'est un espece de "Scrolling", c'est a dire que la fenetre fais une certaine taille (choisi par l'utilisateur), et donc la courbe se 'décale' dans le temps

Fonctionnement de "Add_point"

DrawGraph.add_point(titre,valeur,taille de la fenetre,numéro de la figure)

titre: Nom qui apparait sur la courbe
valeur: le 'y' du point a tracer
taille de la fenetre: Le nombre de point que tu peux visualiser (quand tu dépasse ce nombre de point max, la courbe se décale)
numéro de la figure: tu peux afficher plusieurs figures (cf l'exemple)

ATTENTION:
Ca fonctionne trés bien sous Linux, un peu moins bien sur mon Windows.
Enfin ca fonctionne, mais tu ne peux pas 'déplacer' la figure pendant l'execution. Mais ca me fait le meme probleme avec les exemples du sites, c'est p'tet du a ma bécane

Voila essaye et dit moi si t'as un probleme

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
 
import matplotlib.pyplot as plt
 
#--------------------------------------------------------------------------------------------------------
#                              Classe de construction de graphique
#--------------------------------------------------------------------------------------------------------
class DrawGraph():
 
    def __init__(self):
        self.values=[0]
 
    def add_point(self,title,new_value,histo_len=5,fig_num=1):
 
        #On regarde si pour la figure demander, le vecteur de point exisite déja
        #Si ce n'est pas le cas, on le créer. Le '+1' est du a la numerotation des listes qui commencent a '0'
        #et a '1' pour les figures de Matplotlib. La case self.values[0] n'est donc jamais utilisée
        if len(self.values)<fig_num+1:
            self.values.append([])
 
        #Si le vecteur de point est plus petit que la taille max du scrolle, on ajoute le point 
        if len(self.values[fig_num])<histo_len:
            self.values[fig_num].append(new_value)
        #sinon, on efface le premier point et on ajoute le suivant
        else:
            del self.values[fig_num][0]
            self.values[fig_num].append(new_value)
 
        #Construction du graphique avec matplotlib
        plt.figure(fig_num)
        plt.interactive(True)
        plt.clf()
        x=range(len(self.values[fig_num]))
        y=self.values[fig_num]
        plt.plot(x,y)
        plt.title(title.upper()+' vs time')
        plt.xlabel('time')
        plt.ylabel(title.upper())
        plt.draw()
 
 
#--------------------------------------------------------------------------------------------------------
#                              Fonction qui construit le graphique
#--------------------------------------------------------------------------------------------------------
def totorun(x):
    y=x**2+2*x+3
    y2=x**2-2*x+3
    graph_ber.add_point('toto',y,100,1)
    graph_ber.add_point('toto_2',y2,100,2)
 
 
#--------------------------------------------------------------------------------------------------------
#                              Main
#--------------------------------------------------------------------------------------------------------
graph_ber=DrawGraph()   #Instanciation de l'objet
x=0
while x<100:
    totorun(x)          #On construit les deux courbes
    x=x+1