Salut a tous;

J'ai posté un message hier ici. Résultat après plusieurs tentative ce matin je ne parvient toujours pas a mes fins.

A savoir, je cherche après avoir sélectionné une image, l'afficher dans dans une partie de ma fenêtre.
Je poste mon code pour ce mettre d'accord sur une base de travail:

Le main.cpp

#include <QApplication>
#include <QtGui>
#include "FenPrincipale.h"

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    FenPrincipale fenetre;
    fenetre.show();

    return app.exec();
}

FenetrePrincipale.cpp

#include "FenPrincipale.h"


FenPrincipale::FenPrincipale()
{
    QWidget *zoneCentrale = new QWidget;
    setCentralWidget(zoneCentrale);

//============================================================================//
//                      Création du menu Fichier                              //
//============================================================================//
    QMenu *menuFichier = menuBar()->addMenu("&Fichier");

//============================================================================//
//                           Fichier -> Ouvrir                                //
//============================================================================//
    QAction *actionOuvrir = new QAction("Ouvrir une nouvelle image", this);
    menuFichier->addAction(actionOuvrir);
    connect(actionOuvrir, SIGNAL(triggered()), this, SLOT(OuvrirImage()));

//============================================================================//
//                           Fichier -> quitter                               //
//============================================================================//
    QAction *actionQuitter = new QAction("&Quitter", this);
    menuFichier->addAction(actionQuitter);
    connect(actionQuitter, SIGNAL(triggered()), qApp, SLOT(quit()));
    actionQuitter->setIcon(QIcon("quitter.png"));

//============================================================================//
//               Création et positionnement des Bouttons                      //
//============================================================================//
    m_BoutonQuitter = new QPushButton ("Quitter");
    m_BoutonOuvrir = new QPushButton ("Ouvrir une image");

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(m_BoutonQuitter, 1,1);
    layout->addWidget(m_BoutonOuvrir, 0,0);
    zoneCentrale->setLayout(layout);

    connect(m_BoutonOuvrir, SIGNAL(clicked()), this, SLOT(OuvrirImage()));
    connect(m_BoutonQuitter, SIGNAL(clicked()), qApp, SLOT(quit()));

//============================================================================//
//                             Afficher une image                             //
//============================================================================//



}

void FenPrincipale::getFichierImage(QString FichierImage){

    FichierImage = *m_FichierImage;
}


//============================================================================//
//                                    Slots                                   //
//============================================================================//
void FenPrincipale::OuvrirImage(){

    m_FichierImage = new QString();
    *m_FichierImage = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg *.bmp)");
    QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + *m_FichierImage);

}

Et enfin FenPrincipale.h

#ifndef FENPRINCIPALE_H_INCLUDED
#define FENPRINCIPALE_H_INCLUDED

#include <QtGui>

class FenPrincipale : public QMainWindow
{

    Q_OBJECT
	public:
    FenPrincipale();
    void getFichierImage(QString FichierImage);

    public slots :
    void OuvrirImage();

	private:
	QPushButton *m_BoutonQuitter;
	QPushButton *m_BoutonOuvrir;
	QString *m_FichierImage;


};

#endif // FENPRINCIPALE_H_INCLUDED

Donc j'ai besoin d'indication plus précise que celle fournit par freecircus qui m'ont permis de faire des recherches dans la doc mais j'ai du me perdre dedans .Sachant qu'une fois l'image chargée j'aurai encore besoin d'accéder à celle-ci pour y effectuer des traitements. Je pense a créer une classe qui se charge d'afficher l'image et les traitement que je souhaite y faire. Es-ce une bonne solution?

Je ne sait pas si ce que je donne est suffisamment complet. Donc ne pas hésiter à me demander de plus amples information.

#include "FenPrincipale.h"


FenPrincipale::FenPrincipale()
{
    QWidget *zoneCentrale = new QWidget;
    setCentralWidget(zoneCentrale);

//============================================================================//
//                      Création du menu Fichier                              //
//============================================================================//
    QMenu *menuFichier = menuBar()->addMenu("&Fichier");

//============================================================================//
//                           Fichier -> Ouvrir                                //
//============================================================================//
    QAction *actionOuvrir = new QAction("Ouvrir une nouvelle image", this);
    menuFichier->addAction(actionOuvrir);
    connect(actionOuvrir, SIGNAL(triggered()), this, SLOT(OuvrirImage()));

//============================================================================//
//                           Fichier -> quitter                               //
//============================================================================//
    QAction *actionQuitter = new QAction("&Quitter", this);
    menuFichier->addAction(actionQuitter);
    connect(actionQuitter, SIGNAL(triggered()), qApp, SLOT(quit()));
    actionQuitter->setIcon(QIcon("quitter.png"));

//============================================================================//
//               Création et positionnement des Bouttons                      //
//============================================================================//
    m_BoutonQuitter = new QPushButton ("Quitter");
    m_BoutonOuvrir = new QPushButton ("Ouvrir une image");

    QLabel *m_labelImage = new QLabel;

    QGridLayout *layout = new QGridLayout;
    layout->addWidget(m_BoutonQuitter, 1,1);
    layout->addWidget(m_BoutonOuvrir, 0,0);
    zoneCentrale->setLayout(layout);

    connect(m_BoutonOuvrir, SIGNAL(clicked()), this, SLOT(OuvrirImage()));
    connect(m_BoutonQuitter, SIGNAL(clicked()), qApp, SLOT(quit()));

//============================================================================//
//                             Afficher une image                             //
//============================================================================//



}

void FenPrincipale::getFichierImage(QString FichierImage){

    FichierImage = *m_FichierImage;
}


//============================================================================//
//                                    Slots                                   //
//============================================================================//
void FenPrincipale::OuvrirImage(){

    m_FichierImage = new QString();
    *m_FichierImage = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg *.bmp)");
    QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + *m_FichierImage);
    
    m_labelImage->setPixmap(QPixmap(m_FichierImage));

}

moii >
Penses-tu que QPixmap soit le plus adapté pour le traitement des images ?
Penses-tu que c'est la meilleur conception vu qu'il va sans doute devoir creer des méthodes pour manipuler son image ?

Citation : PO

Sachant qu'une fois l'image chargée j'aurai encore besoin d'accéder à celle-ci pour y effectuer des traitements.

ooops pardon j'ai du zaper cette ligne.
Il faut qu'il utilise alors la classe QPainter.
Je ne vois que cette solution. non?

moii > Oui c'est ce que je lui proposais dans l'autre topic

---

Citation : natrio

Je pense a créer une classe qui se charge d'afficher l'image et les traitement que je souhaite y faire. Es-ce une bonne solution?

Ca me semble une bonne solution, ça va dans le sens de ce que je t'avais proposé :

Citation :

Au final, tu devras créer une classe qui hérite de QWidget (ce sera le support de l'image à l'écran). Cette classe devra avoir un attribut QImage dans lequelle l'image sera chargée. Ensuite, il reste à réimplémenter QWIdget::paintEvent() pour dessiner ton image dedans avec QPainter.

Pour être plus concret voici un patron :

class WidgetImage : public QWidget
{
    public:
        WidgetImage(QWidget *parent=0);
        void loadImage(const QString& path); // edit : correction
        //.. + toutes les fonctions de traitement
    protected:
        void paintEvent(QPaintEvent*);
	
    private:
        QImage img;
}

Et dans ta classe FenPrincipale tu auras donc un attribut WidgetImage

Et il me suffit "d'afficher" ce WidgetImage dans FenPrincipale ? Si j'ai recherché certains élément et j'ai cru comprendre qu'il faudrai l'afficher dans un QLabel?

En tout cas merci pour le "patron", j'ai une bonne base de travail maintenant.

Citation :

Et il me suffit "d'afficher" ce WidgetImage dans FenPrincipale ?

Oui, comme n'importe quel widget, puisque c'est un widget (par héritage)
C'est l'intérêt de cette approche.
Par exemple si je veux juste avoir un "WidgetImage" à l'écran :

int main(int argc, char *argv[])
{
   QApplication app(argc, argv);

   WidgetImage w;
   w.loadImage("img.jpg");
   w.show();
	
   return app.exec();
}

Bien vue c'est exactement un truc comme ça qu'il me faut. j'entrevoyais l'idée mais impossible de la concrétiser. Je te remercie vivement, je m'en vais coder!!

S'il y a d'autre personne qui aurait des suggestions je suis preneur!

EDIT: Je suis en train de penser, actuellement, je récupère l'adresse d'une image via:

connect(m_BoutonOuvrir, SIGNAL(clicked()), this, SLOT(OuvrirImage()));

et

void FenPrincipale::OuvrirImage(){

    m_FichierImage = new QString();
    *m_FichierImage = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg *.bmp)");
    QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + *m_FichierImage);

}

Donc ma boite de dialogue qui me demande de choisir un fichier, s'ouvre grâce à un slot, suite a l'appelle c'est m_FichierImage, un objet de type QString qui contient cette adresse.

Comment récupérer cette adresse et l'exploiter dans le constructeur de FenPrincipale? Si c'est bien dans le constructeur qu'il faut l'exploiter.

Avant tout, ça:

m_FichierImage = new QString();

ça doit être dans le constructeur et non ici
Donc on part avec :

void FenPrincipale::OuvrirImage(){

    *m_FichierImage = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg *.bmp)");
    QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + *m_FichierImage);
}

---

Citation :

Comment récupérer cette adresse et l'exploiter dans le constructeur de FenPrincipale? Si c'est bien dans le constructeur qu'il faut l'exploiter.

Non, ce n'est effectivement pas dans le constructeur, car lui n'est appelé que lors de la création de la fenêtre.

En reprenant le patron que j'ai posté plus haut, dans le constructeur de FenPrincipale tu as du faire quelque chose du type :

m_widgetImage = new WidgetImage;

non ?
Pour mettre à jour l'image il faut se servir de la méthode

void WidgetImage::loadImage(const QString& path);

Ca doit donner quelque chose comme :

void FenPrincipale::OuvrirImage(){

    *m_FichierImage = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg *.bmp)");
    QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + *m_FichierImage);

    m_widgetImage->loadImage(m_FichierImage);
}

Le tout est d'avoir bien implémenté la classe "WidgetImage", y es-tu arrivé ?

ça m'énerve!! Je pensai avoir compris mais en fait je m'aperçois que ce n'est pas trop le cas...
Concretement:

WidgetImage(QWidget *parent=0);

Ceci est donc le constructeur de la class WidgetImage. Que doit-il créer en définitive? Un espace mémoire pour l'image que j'aurai choisie? Si c'est le cas je pense utiliser la classe QImage et la méthode load ( const QString & fileName, const char * format = 0 ).

Mais si je regarde bien le prototype, (QWidget *parent=0) m'indique qu'il souhait en paramètre un Widget. Si j'ai bien compris tes explications ce Widget sera ma fenêtre principale. Ou plutôt l'emplacement d'un objet de type WidgetImage dans ma fenêtre. Dans se ca là quelles sont les instructions a mettre dans le constructeur? Parce que là je ne vois pas!

Et une dernière question, (et oui j'en ai jamais assez!! )

loadImage(const QString& path);

Ce n'est pas un constructeur. C'est peut-être une méthode mais il n'y a pas de type... JE ne vois pas ce que c'est ... heuuueuuu (à la François Hollande)

Donc on est toujours avec cette classe :

class WidgetImage : public QWidget
{
    public:
        WidgetImage(QWidget *parent=0);
        void loadImage(const QString& path);
        //.. + toutes les fonctions de traitement
    protected:
        void paintEvent(QPaintEvent*);
	
    private:
        QImage img;
}

Citation :

Ceci est donc le constructeur de la class WidgetImage. Que doit-il créer en définitive? Un espace mémoire pour l'image que j'aurai choisie? Si c'est le cas je pense utiliser la classe QImage et la méthode load ( const QString & fileName, const char * format = 0 ).

Ici "on" n'a pas utilisé de pointeur pour QImage, donc le contructeur n'a pas grand chose à faire.
La méthode QImage::load(..) sera utile dans WidgetImage::loadImage(..)

Citation :

Mais si je regarde bien le prototype, (QWidget *parent=0) m'indique qu'il souhait en paramètre un Widget. Si j'ai bien compris tes explications ce Widget sera ma fenêtre principale. [..] Dans se ca là quelles sont les instructions a mettre dans le constructeur? Parce que là je ne vois pas!

Aucune
On se contente juste de passer le parent au constructeur de QWidget car c'est lui que ça intéresse :

WidgetImage::WidgetImage(QWidget *parent) : QWidget(parent)
{ }

C'est tout

Citation :

loadImage(const QString& path);

Ce n'est pas un constructeur. C'est peut-être une méthode mais il n'y a pas de type... JE ne vois pas ce que c'est ...

Arf désolé, si je t'embrouille en plus !
C'est une erreur j'ai oublié le void, je corrige ça.

Bon courage

Citation : freecircus

Arf désolé, si je t'embrouille en plus !

ttt ça va pas le faire ça, je croi qu'on ne vas pas s'entendre!!!

bref je récapitule ou j'en suis (car j'ai des problème de compilation!!! )

- la class WidgetImage n'a pas changé. Elle est comme tu me l'a suggéré. Le constructeur également.

- C'est pour

void loadImage(const QString& path);

qu'il y a quelque soucie, voila la méthode que j'ai écrite:

void WidgetImage::loadImage(const QString& path){

    //img.load (path);
    if(img.load (path))
        QMessageBox::information(this, "Image Chargé?", "l'Image ets chargé quelque par dans la mémoire!!");
    else
        QMessageBox::critical(this, "Image Chargé?", "Image est perdu!!!");

}

Comme il s'agit de charger l'image en mémoire j'ai choisi la méthode load ( const QString & fileName, const char * format = 0 ) issu de la class QImage.
J'ai provoqué l'affichage de boite de dialogue pour vérifier que le chargement avait eu lieu.

Mon compilateur dans tout ça bonté d'âme m'aide beaucoup pour identifier le problème:

release/TraitementImage.o(.text+0x6c):TraitementImage.cpp: undefined reference t
o `vtable for WidgetImage'
release/TraitementImage.o(.text+0x73):TraitementImage.cpp: undefined reference t
o `vtable for WidgetImage'
release/TraitementImage.o(.text+0x14c):TraitementImage.cpp: undefined reference
to `vtable for WidgetImage'
release/TraitementImage.o(.text+0x153):TraitementImage.cpp: undefined reference
to `vtable for WidgetImage'
collect2: ld returned 1 exit status
mingw32-make[1]: *** ["release\Interface] Error 1
mingw32-make[1]: Leaving directory `D:/Documents and Settings/Marc/Mes documents
/Programation/SICFO/Interface 0.1'
mingw32-make: *** [release] Error 2

Donc suite a se genre d'erreur j'ai refait un

qmake -project
qmake
make

Aucun changement... Es-ce que pour charger une image en mémoire la méthode load est bien indiqué?

Et pour continuer il me reste a implémenter la méthode void paintEvent(QPaintEvent*).

Citation :

Est-ce que pour charger une image en mémoire la méthode load est bien indiqué?

hm oui, en tout cas je ne vois pas de contre-indication dans la doc'

Citation :

Et pour continuer il me reste a implémenter la méthode void paintEvent(QPaintEvent*).

Bon courage, il y a des exemples, toujours dans la doc'

Excuse moi de ne pas avoir répandu plus tôt j'étais for occupé ces deniers jours...

void paintEvent(QPaintEvent*)

Cette méthode me donne du fil à retordre. On est daccord, elle attend en paramètre un objet de type QPaintEvent. Go to the doc!!!
http://doc.trolltech.com/4.4/qpaintevent.html. Et quand je regarde ce morceau de doc je comprends plus rien . Et je décroche complètement je suis incapable
de poursuivre une réflexion rationnelle...

http://doc.trolltech.com/4.4/qpainter.html#drawing Si je regarde le morceau de doc que tu m'a suggéré, je croie comprendre que mon code devra démarré comme ça:

void paintEvent(QPaintEvent*){

    QPainter painter(this);
    


}

Donc on se prépare à dessiner dans un Qpainter dans le WidgetImage. Et alors là je ne trouve plus de classe qui me permettrai de charger l'image que j'ai en mémoire. Es-ce que je suis bien partie? Comment continuer?

-> Pour paintEvent :

Le truc à savoir c'est qu'on n'appelle pas cette fonction directement (tu l'as peut être déjà compris, mais ça fait pas de mal de le rappeler au cas ou).
Elle est appelé par Qt quand le widget à besoin d'être redessiné. Deux cas se présentent :

• Automatiquement, quand le widget réapparait après avoir été masqué (par une boite de dialogue...).
• Quand le programmeur le décide, en appelant la méthode QWidget::update().

Pour l'instant tu n'as pas besoin de t'occuper du paramètre.
A propos de QWIdget::update() j'y pense, tu auras besoin de l'appeler dans WidgetImage::loadImage(), car Qt ne verra pas tout seul qu'il faut redessiner le widget.

----------

Citation :

je croie comprendre que mon code devra démarré comme ça:
[...]
Donc on se prépare à dessiner dans un Qpainter dans le WidgetImage. Et alors là je ne trouve plus de classe qui me permettrai de charger l'image que j'ai en mémoire. Es-ce que je suis bien partie? Comment continuer?

Tu es bien partis
Par contre, tu ne te prépares pas à dessiner dans un QPainter, mais à l'aide de.
Il faut voir QPainter comme un peintre : tu lui donnes une toile (le this), et il exécute tes ordres.
Exemple : QPainter::drawMeASheep()

hmhm.. pardon.
Pour dessiner la QImage, c'est tout simplement QPainter::drawImage() qui t'intéresse
----

Citation :

Excuse moi de ne pas avoir répandu plus tôt j'étais for occupé ces deniers jours...

Pas de problème, il est préférable que tu répondes quand tu as de nouveau un problème ou quand tout est réglé.
Situ réponds quelque chose comme "ok je vais tester!" et que plus tard tu édites pour dire que "ça ne marche pas", le topic ne sera pas remonté ou quoi que ce soit.. pas pratique

J'ai encore une question :

1° je ne comprends ce que "void paintEvent(QPaintEvent*)" attend comme paramètre:
un objet de type QPaintEvent? ou QPaintEvent* ? Ou est le nom de l'objet qu'on a choisie?

Citation : freecircus

Citation :

Citation : Moi

Excuse moi de ne pas avoir répandu plus tôt j'étais for occupé ces deniers jours...

Pas de problème, il est préférable que tu répondes quand tu as de nouveau un problème ou quand tout est réglé.
Situ réponds quelque chose comme "ok je vais tester!" et que plus tard tu édites pour dire que "ça ne marche pas", le topic ne sera pas remonté ou quoi que ce soit.. pas pratique

En effet je m'en était aperçu Entout cas je te remercie pour ta patience!!

Citation :

1° je ne comprends ce que "void paintEvent(QPaintEvent*)" attend comme paramètre:
un objet de type QPaintEvent? ou QPaintEvent* ?

Un QPaintEvent*, d'où le prototype.

Citation :

Ou est le nom de l'objet qu'on a choisie?

Ici, comme on s'en n'occupe pas, il n'y a tout simplement pas besoin de le mettre.
Si plus tard tu veux utiliser le paramètre il suffit de lui donner un nom:
void paintEvent(QPaintEvent* event)

Dans un premier temps, je te conseil vraiment de ne pas te soucier de ce paramètre, tu n'en as pas besoin pour dessiner ton image, c'est de la pure optimisation qui n'a pas toujours lieu d'être

bon alors je ne me soucie pas du QPaintEvent*.
voila le code que j'ai pour le moment:

void paintEvent(QPaintEvent*){

     QPainter painter(this);
     painter.drawImage(QPoint::Qpoint(), img);

}

Comment j'appelle cette fonction du coup? Comme cela?

m_WidgetImage->paintEvent();

A oui encore une chose: pour mes traitements d'image j'ai vu que la bibliothèque OpenCV pourrait être très utile, cf : tuto de NoHaR. Es-ce qu'il est facile de l'utiliser en plus de Qt?

Citation : natrio

Comment j'appelle cette fonction du coup? Comme cela?

m_WidgetImage->paintEvent();

surtout pas (en plus elle est protected).
elle est appelée automatiquement par Qt quand il faut "repeindre" le widget. Pour demander le repeignage, il faut appeler update()

Citation :

painter.drawImage(QPoint::Qpoint(), img);

hm.. vaut mieux que tu passes par :

painter.drawImage(0,0, img);

Ca fait toujours un objet en moins.

Citation :

Comment j'appelle cette fonction du coup? Comme cela? [...]

déjà dit, faut écouter

Citation : plus haut

-> Pour paintEvent :

Le truc à savoir c'est qu'on n'appelle pas cette fonction directement.
Elle est appelé par Qt quand le widget à besoin d'être redessiné. Deux cas se présentent :

* Automatiquement, quand le widget réapparait après avoir été masqué (par une boite de dialogue...).
* Quand le programmeur le décide, en appelant la méthode QWidget::update().
A propos de QWIdget::update() j'y pense, tu auras besoin de l'appeler dans WidgetImage::loadImage(), car Qt ne verra pas tout seul qu'il faut redessiner le widget.

Merci à tous les deux pour votre aide j'avance a grand pas! En tout cas je pense que j'ai enfin compris pourquoi void paintEvent(QPaintEvent*) était protected. Et je pense que je cerne mieux la QPaintEvent. Enfin je pense

bref j'ai donc apporté les améliorations suggérées. Et corrigé plusieurs erreur du compilateur. Mais il en a entre-autre deux qui me nargue :

TraitementImage.cpp:26: error: invalid use of `this' in non-member function
TraitementImage.cpp:27: error: `img' undeclared (first use this function)

les lignes 26 et 27 indiqué par la compilateur sont respectivement les lignes 3 et 4.

void paintEvent(QPaintEvent*){

     QPainter painter(this);
     painter.drawImage(0,0, img);
     QWidget::update(img);

}

Il se peu qu'il manque du code n'hésitez pas à me le demander.

void WidgetImage::paintEvent(QPaintEvent*){ // c'est une méthode de la classe !

     QPainter painter(this);
     painter.drawImage(0,0, img);
}

Citation : Plus haut

A propos de QWIdget::update() j'y pense, tu auras besoin de l'appeler dans WidgetImage::loadImage()

Edit : corrigé
| tss erreur bête désolé !
v

surtout pas, il ne faut pas appeler "update()" dans "paintEvent()" car ça va probablement créer une boucle infinie.

J'ai honte... Une erreur pareille je ne devrai plus la faire... j'ai honte... j'en tire les conclusions en me retirent définitivement de la vie d programmeur... .

Mais non je plaisante j'adore la jubilation que l'on peut avoir quand enfin ça marche!!! Et d'ailleurs il est 16h43 et mon programme compile et court!!!

L'objectif était de charger une image dans ma fenêtre et de pouvoir y effectuer des traitements. Mission accompli!!

Encore merci a vous deux et je met le sujet résolut!

Citation :

j'adore la jubilation que l'on peut avoir quand enfin ça marche!!!

ha ça

Bon courage pour la suite

Salut a tous, je reviens pour de nouvelles aventures!!!!

Mon programme a évolué depuis ces péripétie. Dans les épisode précédent j'avais besoin que d'un seul QImage, celui qui devait être affiché. J'ai rajouté non sans difficulté d'autres méthode de traitement qui agisse sur se QImage. Aujourd'hui je souhaite créer une méthode qui donne des indications sur l'histogramme. Concrètement qui le calcule et l'affiche.

je retrouve donc avec se WidgetImage qui possède deux attributs QImage. Comment puis-je afficher distinctement a des endroit différent ses deux QImage.
Doit-je passé par une classe dérivé? Affiner la/les méthode(s) d'affichage? Autre structure possible? Ou tout autre que sait-je?

Merci pour tout aide future!