Création de graphiques

Version imprimable

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

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:

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:lol:

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

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()

23/03/2010, 05h08
nicogigo

Merci

Merci, c'est effectivement très simple d'utilisation et ça marche bien.:P
24/03/2010, 05h14
nicogigo

Evolution du graphique dans le temps

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?:zoubi:
24/03/2010, 10h42
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.
06/04/2010, 04h47
nicogigo

Graphiques dynamiques

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:D

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:

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é

07/04/2010, 04h58
nicogigo

Merci

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.:D

Mon code

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:

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)

07/04/2010, 11h54
ju_bicycle

il ne faut plus mettre le plt.show()

Ca ne marche pas encore

Ok, j'ai retiré le plt.show(). Il ouvre bien la fenêtre, mais là il y a le sablier puis plus rien. Un peu comme si il cherchait des trucs super longtemps sans tracer. Si vous avez une idée. Mon nouveau code :
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 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) 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)

08/04/2010, 10h03
ju_bicycle

Salut
Alors effectivement, ton code ne fonctionne pas sous windows...
Mais fonctionne trés bien sous linux

Attention tout de même. Cette méthode avec "interactive" fait que matplotlib redessine entierement sa fenetre a chaque fois. Si tu doit donc avoir un pas de 0.1 seconde, le résultat est assez pénible a regarder...

Je ne sais pas pourquoi ca marche pas sur windows, et je n'ai pas le temps de creuser. Désolé. Enfin tu as une piste maintenant.
08/04/2010, 10h56
nicogigo

Solution?

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?

Mon code

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:

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.

12/04/2010, 14h51
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

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:

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()

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:

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

16/04/2010, 16h32
jlg_47

Bonjour à tous,

Ju bicycle, je n'arrive pas à faire marcher ton code.

Il ouvre une fenêtre qui reste blanche et puis plus rien ...

J'ai remplacé plt.draw par plt.show ; il met trace alors un point puis quand je ferme la fenêtre, il l'ouvre à nouveau en traçant le second point, de même en fermant la seconde fenêtre, il en ouvre une nouvelle avec le 3 ième point .... et ainsi de suite ...

Ce qui m'intéresse dans mon cas est simplement de retracer la courbe après l'avoir recalculée ...
Je suis surpris qu'on ne puisse pas simplement l'effacer et la retracer ..

Apparemment ça bloque le programme.

Bonne journée

J'ai essayé
16/04/2010, 17h13
ju_bicycle

Salut,
Bon bah je me répete...j'suis désolé j'peux pas trop t'aider vu que chez moi sa fonctionne:
*Sous linux (ubuntu) c'est vraiment nickel: Tu peux déplacer les fenetres pendants que ca tourne sans probleme

*sous windows, ca tourne aussi mais moins bien (aucune idée d'ou peut venir le probleme d'ailleurs). en gros mes fenetres s'ouvrent et je vois la courbe évoluer.
Par contre je ne peux pas déplacer la fenetre (ni même passer une autre fenetre par dessus puis revenir dessus). La ca devient tout blanc...

J'suis en python 2.5 sous linux et 2.6 sous windows(xP pro). Pour le matplotlib j'ai la 0.99 dans les deux cas...Franchement je comprend pas pourquoi ca tourne chez moi et pas chez vous...
17/04/2010, 12h03
jlg_47

Bonjour,

De toute façon, même de nombreux exemples marchent mal :aie:

Il me semble qu'il devrait pourtant être assez facile de tracer une courbe, puis de l'effacer pour en tracer une autre ...

Et même cela je n'y arrive pas ...
J'ai vu qu'il ne faut pas utiliser show() plus d'une fois .. Mais chez moi draw() ne fait rien et bloque le programme :mrgreen:

Bonne journée

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