PyQt Lab est un outil puissant qui permet aux utilisateurs de créer des graphiques mathématiques complexes et interactifs. Pyqtgraph est un module qui fait partie de PyQt Lab et qui permet aux utilisateurs de créer des graphiques à l’aide de données mathématiques. Dans cet article, nous allons voir comment afficher progressivement une courbe dans un graphique Pyqtgraph à l’aide d’un Timer. Nous verrons comment configurer le Timer et comment l’utiliser pour afficher la courbe de manière progressive.
PyQt Lab’ : Graphiques Math : Pyqtgraph : Affichage progressif d’une courbe dans un graphique Pyqtgraph à l’aide d’un Timer.
Par X. HINAULT – Juin 2013


Ce que l’on va faire ici
- Afficher progressivement une courbe dans un graphique Pyqtgraph à l’aide d’un Timer. On réalisera également un « glissement » de la courbe vers la gauche une fois un premier passage de l’axe des abscisses effectué.
- Ce code pourra servir de base pour des applications « d’oscilloscope » et monitoring.
Pré-requis
- python 2.7
- pyqt4.x
- pyqtgraph
Le fichier d’interface *.ui
<ui version=« 4.0 »>
<class>Form</class>
<widget class=« QWidget » name=« Form »>
<property name=« geometry »>
<rect>
<x>0</x>
<y>0</y>
<width>525</width>
<height>413</height>
</rect>
</property>
<property name=« windowTitle »>
<string>PyQt + pyqtgraph : Affichage courbe progressive</string>
</property>
<widget class=« PlotWidget » name=« graph »>
<property name=« geometry »>
<rect>
<x>5</x>
<y>10</y>
<width>480</width>
<height>360</height>
</rect>
</property>
</widget>
</widget>
<customwidgets>
<customwidget>
<class>PlotWidget</class>
<extends>QGraphicsView</extends>
<header>pyqtgraph</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
Le fichier d’interface *.py
- Fichier obtenu automatiquement avec l’utilitaire pyuic4 à partir du fichier *.ui créé avec QtDesigner :
# Form implementation generated from reading ui file
#
# Created: Sat Aug 17 15:01:45 2013
# by: PyQt4 UI code generator 4.9.1
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_Form(object):
def setupUi(self, Form):
Form.setObjectName(_fromUtf8(« Form »))
Form.resize(525, 413)
self.graph = PlotWidget(Form)
self.graph.setGeometry(QtCore.QRect(5, 10, 480, 360))
self.graph.setObjectName(_fromUtf8(« graph »))
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def retranslateUi(self, Form):
Form.setWindowTitle(QtGui.QApplication.translate(« Form », « PyQt + pyqtgraph : Affichage courbe progressive », None, QtGui.QApplication.UnicodeUTF8))
from pyqtgraph import PlotWidget
if __name__ == « __main__ »:
import sys
app = QtGui.QApplication(sys.argv)
Form = QtGui.QWidget()
ui = Ui_Form()
ui.setupUi(Form)
Form.show()
sys.exit(app.exec_())
Le fichier d’application *Main.py
# -*- coding: utf-8 -*-
# par X. HINAULT – Mai 2013 – Tous droits réservés
# GPLv3 – www.mon-club-elec.fr
# modules a importer
from PyQt4.QtGui import *
from PyQt4.QtCore import * # inclut QTimer..
import os,sys
import pyqtgraph as pg # pour accès à certaines constantes pyqtgraph, widget, etc…
import numpy as np # math et tableaux
from tuto_pyqt_pyqtgraph_timer_courbe_simple import * # fichier obtenu à partir QtDesigner et pyuic4
# +/- variables et objets globaux
class myApp(QWidget, Ui_Form): # la classe reçoit le Qwidget principal ET la classe définie dans test.py obtenu avec pyuic4
def __init__(self, parent=None):
QWidget.__init__(self) # initialise le Qwidget principal
self.setupUi(parent) # Obligatoire
# — Variables de classe
# — Paramétrage des widgets de l’interface GUI si nécessaire —
# — Connexions entre signaux des widgets et fonctions
# connecte chaque signal utilisé des objets à l’appel de la fonction voulue
# — Code actif initial —
#– initialise le graphique pyqtgraph —
# l’objet self.graph correspond au plotWidget créé dans QtDesigner
# aspect fond /axes
#self.graph.hideAxis(‘left’) # masque axes – left, bottom, right, or top
self.graph.setBackgroundBrush(QBrush(QColor(Qt.white))) # la classe PlotWidget est un GraphicsWidget qui est un QGraphics View
self.graph.showGrid(x=True, y=True) # affiche la grille
self.graph.getAxis(‘bottom’).setPen(pg.mkPen(0,0,255)) # couleur de l’axe + grille
self.graph.getAxis(‘left’).setPen(pg.mkPen(255,0,0)) # couleur de l’axe + grille
# légende des axes
labelStyle = {‘color’: ‘#00F’, ‘font-size’: ’10pt’} # propriétés CSS à utiliser pour le label
self.graph.getAxis(‘bottom’).setLabel(‘X’, units=‘unit’, **labelStyle) # label de l’axe
self.graph.getAxis(‘left’).setLabel(‘Y’, units=‘unit’, **labelStyle) # label de l’axe
# adaptation échelle axes
# axe X et Y sont autoscale par défaut
self.graph.enableAutoRange(axis=pg.ViewBox.YAxis, enable=False) # fonction plotItem : désactive autoscale Y
self.Ymin=-1
self.Ymax=1
self.graph.setYRange(self.Ymin,self.Ymax) # fonction plotItem : fixe échelle des Y
self.Xmin=0
self.Xmax=360
self.graph.setXRange(self.Xmin,self.Xmax) # fonction plotItem : fixe échelle des X
# interactivité
#self.graph.setInteractive(False) # fonction QGraphics View : pour inactiver interaction souris
self.graph.getViewBox().setMouseMode(pg.ViewBox.RectMode) # fonction ViewBox pas accessible depuis PlotWidget : fixe selection par zone
self.graph.setMouseEnabled(x=False, y=True) # désactive interactivité axe X
#– initialise données —
#– définition des x
#self.nombreValeurs=360
#self.x = np.arange(0.0, self.nombreValeurs+1, 1.0) # crée un vecteur de n valeurs à intervalle régulier pour les x
#print(self.x) # debug – affiche les valeurs x
#– calcul des y : courbe y=f(x)
#self.y=np.sin(np.radians(self.x))# crée un tableau de valeur y basé sur x – courbe y=sin(x)
#self.y= np.random.normal(0,1,size=self.nombreValeurs) # génére une série de 1000 valeurs aléatoires
#print(self.y) # debug – affiche les valeurs y
#– affichage de la courbe —
self.courbe=self.graph.plot(pen=(0,0,255)) # avec couleur
self.compt=0 # variable comptage
#– initialisation du Timer
self.timer=QTimer() # déclare un timer Qt
self.timer.start(10) # lance le timer – durée en ms
self.connect(self.timer, SIGNAL(« timeout() »), self.timerEvent) # connecte le signal timeOut de l’objet timer à l’appel de la fonction voulue
# NB : le nom de la fonction appelée est ici timerEvent : ce nom est arbitraire et peut être ce que l’on veut…
# — les fonctions appelées, utilisées par les signaux des widgets —
# — les fonctions appelées, utilisées par les signaux hors widgets —
#– fonction gestion survenue évènement Timer
def timerEvent(self): # fonction appelée lors de la survenue d’un évènement Timer – nom de la fonction indiférrent
#print(« Timer »)
if self.compt==0: # premier passage
self.points= np.array([[self.compt,self.compt]]) # tableau à 2 dimensions – ici 1er points
self.x=self.points[:,0] # la première colonne = les x
self.y=self.points[:,1] # la deuxième colonne = les y
self.compt=self.compt+1 # incrémente compt
elif self.compt<=self.Xmax: # on remplit le tableau de point une première fois
newY=np.sin(np.radians(self.compt)) * np.cos(np.radians(3*self.compt))
#newY=self.compt # x=y – debug
self.points=np.append(self.points,[[self.compt,newY]],axis=0)# ajouter un point au tableau
self.x=self.points[:,0] # la première colonne = les x
self.y=self.points[:,1] # la deuxième colonne = les y
self.compt=self.compt+1 # incrémente compt
else:
#self.points=roll(self.points,1, axis=1) # décale les éléments y de 1 – fonctin numpy
#self.x=self.points[:,0] # la première colonne = les x – existe déjà
#self.y=self.points[:,1] # la deuxième colonne = les y – existe déjà
#self.y=roll(self.y,1) # décale les éléments y de 1 – fonctin numpy – les x ne bougent pas..
self.y=np.roll(self.y,-1) # décale les éléments y de 1 – fonction numpy – les x ne bougent pas.. et remet y[0] en y[max].. évite recalcul…
#self.y[self.Xmax-1]=self.y[self.Xmax-1]/2 # nouvelle valeur en dernière position
#self.y[self.Xmax]=0 # nouvelle valeur en dernière position
#self.y[self.Xmax]=np.sin(np.radians(self.compt)) * np.cos(np.radians(3*self.compt)) # avec recalcul
#self.compt=self.compt+1 # incrémente compt
# important : pour le tracé, ce n’est pas l’ordre qui est important, mais la coordonnée x,y dans notre cas…
# remarquer la simplicité avec laquelle il es possible d’extraire le tableau des x ou des y à partir du tableau de points
#if self.compt==self.Xmax : self.compt=0 # RAZ compt
# debug
#print self.points
#print self.x
#print self.y
« » »
#– initialise données —
self.x = arange(0.0, 361.0, 1.0) # crée un vecteur de n valeurs à intervalle régulier pour les x
print(self.x) # debug – affiche les valeurs x
#self.y = zeros(len(self.x), Float) # debug – crée un tableau rempli de 0 de la taille voulue pour les y
#– calcul des y : courbe y=sin(x).cos(3x)
self.y=sin(radians(self.x)) * cos(radians(3*self.x))# crée un tableau de valeur y basé sur x
print(self.y) # debug – affiche les valeurs y
« » »
#– initialise la courbe —
self.courbe.setData(self.x,self.y) # initialisation valeurs courbe
# — fonctions de classes autres—
# — Autres Classes utiles —
# — Classe principale (lancement) —
def main(args):
a=QApplication(args) # crée l’objet application
f=QWidget() # crée le QWidget racine
c=myApp(f) # appelle la classe contenant le code de l’application
f.show() # affiche la fenêtre QWidget
r=a.exec_() # lance l’exécution de l’application
return r
if __name__==« __main__ »: # pour rendre le code exécutable
main(sys.argv) # appelle la fonction main
Utilisation
- Les 2 fichiers suivants sont à enregistrer dans un même répertoire, l’un en nom.py et l’autre en nomMain.py.
- Puis lancer l’application depuis Geany ou équivalent, en exécutant le fichier nomMain.py
- La courbe s’affiche progressivement.
- La molette de souris assure le zoom
Articles similaires:
- PyQt Lab’ : Graphiques Math : Pyqtgraph : Courbe paramétrique de la forme x=f(t) et y=f(t) dans un graphique Pyqtgraph.
- PyQt Lab’ : Graphiques Math : Pyqtgraph : Paramétrer les points d’une courbe simple dans un graphique Pyqtgraph.
- PyQt Lab’ : Graphiques Math : Pyqtgraph : Afficher une courbe simple dans un graphique Pyqtgraph.
- PyQt Lab’ : Graphiques Math : Pyqtgraph : Afficher 1000 valeurs aléatoires dans un graphique Pyqtgraph afin de simuler une série de données.
- PyQt Lab’ : Graphiques Math : Pyqtgraph : Afficher/masquer des courbes dans un graphique Pyqtgraph à l’aide widgets checkbox.
Articles Liés
- Javascript : Canva : Tracé progressif d'une courbe mathématique
Le tracé progressif d'une courbe mathématique est une tâche complexe qui peut être simplifiée grâce…
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…