| | auteur : gulish |
Qwt (Qt Widgets for Technical applications) est une librairie annexe à Qt,
qui utilise cette dernière, et qui simplifie la création de widgets de mesure
(Courbes, Graphiques, Jauges, Cadrans, ...).
Cette librairie, ainsi que toutes les informations la concernant,
sont disponibles sur la page web du projet : La librairie Qwt.
|
lien :  Qwt
|
| | auteur : gulish |
Quelques images des exemples Qwt sont disponibles dans le chapitre "Screenshots"
de la page web de la librairie. Elles sont assez représentatives du type de
composants pouvant être crées, même si une personnalisation est toujours possible.
|
lien : Qwt
|
| | auteur : gulish |
Les classes Qwt sont basées sur celles de Qt, et leur utilisation est relativement
simple. De plus, les classes disponibles sont assez complètes,
et permettent facilement de créer l'objet que l'on désire. Cependant,
cette librairie est moins intuitive que Qt, et la documentation la concernant est plutôt succincte.
Il est nécessaire de connaître les bases de l'utilisation de Qt pour utiliser Qwt.
|
| | auteur : gulish |
Qwt est basé sur Qt, et il faut donc préalablement avoir installé la librairie Qt.
Il suffit ensuite de décompresser l'archive Qwt,
modifier le fichier .pri (similaire au fichier .pro) selon vos besoins,
puis d'exécuter qmake, puis make ou équivalents (nmake, cmake ...).
|
| | auteur : gulish |
Les repères des courbes (QwtPlot) et les éléments de type "jauges" (QwtCompass,
QwtDial, QwtKnob, ...) héritent tous de la classe QWidget.
Il est donc facile de les ajouter, comme tout autre widget, dans le layout de votre
application.
|
| | auteur : gulish |
La classe principale pour la gestion des repères est QwtPlot.
Son utilisation est très simple.
Par défaut, seule la partie positive des axes x et y apparaît, mais cela est modifiable.
#include <QApplication>
#include <qwt_plot.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
myPlot.show();
return app.exec();
}
|
|
| | auteur : gulish |
On utilise la méthode setCanvasBackground(const QColor &c) :
#include <QApplication>
#include <qwt_plot.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
myPlot.setCanvasBackground(Qt::white);
myPlot.show();
return app.exec();
}
|
|
| | auteur : gulish |
Les courbes se créent grâce à la classe QwtPlotCurve.
Cette classe permet une grande personnalisation de l'affichage
(symboles des points, couleur, traçage ou non de ligne, etc.). Une courbe étant
une suite de points, il faut renseigner une suite de points à QwtPlotCurve. Pour cela,
on utilise la méthode setData(...) qui peut accepter différents arguments. La plus triviale est
setData (const double *xData, const double *yData, int size), ou xData représente un tableau de double,
contenant toutes les abscisses des points de notre courbe, yData contient lui les ordonnées.
Ainsi, notre premier point aura comme coordonnées [ xData[0],yData[0] ]. Le troisième paramètre,
size, renseigne sur le nombre de points à afficher, en partant de zéro. Bien sûr, xData et yData
doivent au moins contenir "size" éléments.
#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
QwtPlotCurve myCurve;
myCurve.attach(&myPlot);
QVector<double> x(5);
QVector<double> y(5);
for(int i=0;i<5;i++)
{
x.append((double)i);
y.append((double)(5-i));
}
myCurve.setData(x.data(),y.data(),x.size());
myPlot.replot();
myPlot.show();
return app.exec();
}
|
Vous remarquerez que les axes se sont automatiquement ajustés aux données.
|
| | auteur : gulish |
Il faut utiliser la méthode QwtPlotCurve::setPen().
#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
QwtPlotCurve myCurve;
myCurve.attach(&myPlot);
QVector<double> x(5);
QVector<double> y(5);
for(int i=0;i<5;i++)
{
x.append((double)i);
y.append((double)(5-i));
}
myCurve.setData(x.data(),y.data(),x.size());
myCurve.setPen(QPen(Qt::red));
myPlot.replot();
myPlot.show();
return app.exec();
}
|
|
| | auteur : gulish |
Il est inutile d'ajouter une multitude de courbes pour faire apparaître une grille sur notre repère.
QwtPlotGrid permet d'ajouter facilement une grille à notre repère. De plus,
cette grille s'adapte automatiquement aux nouvelles échelles, et peut être personnalisée.
#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
QwtPlotCurve myCurve;
QwtPlotGrid myGrid;
myCurve.attach(&myPlot);
QVector<double> x(5);
QVector<double> y(5);
for(int i=0;i<5;i++)
{
x.append((double)i);
y.append((double)(5-i));
}
myCurve.setData(x.data(),y.data(),x.size());
myGrid.attach(&myPlot);
myPlot.replot();
myPlot.show();
return app.exec();
}
|
|
| | auteur : gulish |
On peut facilement réaliser ce type de grille grâce aux méthodes QwtPlotGrid::enableX()
et QwtPlotGrid::enableY().
#include <QApplication>
#include <QHBoxLayout>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QWidget myWidget;
QwtPlot myLeftPlot;
QwtPlotGrid myLeftGrid;
myLeftGrid.enableX(false);
myLeftGrid.attach(&myLeftPlot);
QwtPlot myRightPlot;
QwtPlotGrid myRightGrid;
myRightGrid.enableY(false);
myRightGrid.attach(&myRightPlot);
QHBoxLayout myLayout(&myWidget);
myWidget.setLayout(&myLayout);
myLayout.addWidget(&myLeftPlot);
myLayout.addWidget(&myRightPlot);
myLeftPlot.replot();
myRightPlot.replot();
myWidget.show();
return app.exec();
}
|
|
| | auteur : gulish |
Les axes peuvent simplement se personnaliser grâce aux fonctions
setAxisScale(axe,min,max,step) et setAxisTitle(axe,titre). Dans la majorité
des cas, la grille s'ajuste automatique sur l'échelle du repère.
#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
QwtPlotGrid myGrid;
myGrid.attach(&myPlot);
myPlot.setAxisScale(QwtPlot::xBottom,-15.0,35.0,5.0);
myPlot.setAxisScale(QwtPlot::yLeft,-70.0,-35.0,5.0);
myPlot.setAxisTitle(QwtPlot::xBottom,QString("My x values"));
myPlot.setAxisTitle(QwtPlot::yLeft,QString("<u>My y values</u>"));
myPlot.replot();
myPlot.show();
return app.exec();
}
|
|
| | auteur : gulish |
Il existe une classe dédiée au zoom nommée QwtPlotZoomer.
Elle permet de créer très simplement un outil de zoom, et d'autres fonctionnalités.
On peut zoomer successivement sur une zone.
Le zoom s'effectue en faisant un cliquer-glisser sur une zone du repère,
le clic sur la molette permet de revenir au zoom précédent, et le clic droit permet de
revenir au repère initial. La grille et les axes s'ajustent avec le zoom.
#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_zoomer.h>
int main(int argc, char** argv)
{
QApplication app(argc,argv);
QwtPlot myPlot;
QwtPlotGrid myGrid;
myGrid.attach(&myPlot);
QwtPlotZoomer myZoomer(myPlot.canvas());
myPlot.replot();
myPlot.show();
return app.exec();
}
|
|
Consultez les autres F.A.Q's
Les sources présentés sur cette page sont libres de droits,
et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs.
Copyright ©2006
Developpez LLC. Tous droits réservés Developpez LLC.
Aucune reproduction, même partielle, ne peut être faite de ce site et de
l'ensemble de son contenu : textes, documents et images sans l'autorisation
expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à 3 ans
de prison et jusqu'à 300 000 E de dommages et intérêts.
Cette page est déposée à la SACD.
|
