Discussion :

[alexmam15]

Salut tout le monde,
je suis entrain de réaliser une appliction qui permette d'afficher une image en utilisant Qt. L'affichage est fait après la lecture du fichier octet par octet et ensuite la construction de l'image pixel par pixel, càd en utilisant deux boucles imbriquées(une pour la longueur et une pour le largueur de l'image) mais je trouve que mon appliction est lente en terme de temps d'exécution.
Est ce que quelqu'un peut m'aider à améliorer mon algorithme.
Merci d'avance

[gbdivers]

Bonjour

Si tu utilises setPixel pour chaque pixel, ça peut diminuer fortement les performances. Utilises plutôt les fonctions bas niveau (bits ou scanLine). Evite aussi d'utiliser QColor (ou autre) pour faire des conversions de couleur. Cf un exemple d'optimisation : http://www.developpez.net/forums/d96...e/#post5469399

Bonne continuation

[yan]

salut.
Si tu peux détailler. On devrais pourvoir te donner plus détaille.

[alexmam15]

@Yan: voici mon code, mon problème c'est que la lecture de l'image puis l'affichage prend quelques secondes à cause des 2 boucles(c'est plus pire si la résolution de l'image est grande), je veux savoir comment réduire ce temps et le rendre comme les algorithmes d'affichage des images jpg ou autres dans Windows.

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
 
/////////////////////////Format ARGB8888/////////////////////
#include <QApplication>
#include <QFile>
#include <QString>
#include <QByteArray>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QPixmap>
 
int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    QImage image(720, 576, QImage::Format_ARGB32);
    QRgb value;
    bool ok;
    QByteArray A,R,G,B;
 
    QFile fichier("monfichier.xxx");
    if(fichier.open(QIODevice::ReadOnly))
    {
           for(int j=0;j<=575;++j)
           {
                for(int i=0;i<=719;++i)
                {
                    A = fichier.read(1).toHex();
                    R = fichier.read(1).toHex();
                    G = fichier.read(1).toHex();
                    B = fichier.read(1).toHex();                  
 
                    value = qRgba(R.toInt(&ok, 16), G.toInt(&ok, 16), B.toInt(&ok, 16), A.toInt(&ok, 16));
                    image.setPixel(i, j, value);
                }
            }
 
         fichier.close();
 
    }
 
 
    QGraphicsScene scene;
    QPixmap pixmap = QPixmap::fromImage(image);
    scene.addPixmap(pixmap);
    QGraphicsView vue(&scene);
    vue.show();
 
    return app.exec();
}

[yan]

Sait tu comment est agencé la mémoire dans une QImage?
Pourquoi passer de Hex pour revenir à du int 8 bits ?

[alexmam15]

J'ai pas compris votre question:"Sait tu comment est agencé la mémoire dans une QImage?".
Pour la 2ème question: les données dans le fichier sonten Hexa et les paramètres de la construction du pixel sont en décimal

[yan]

J'ai pas compris votre question:"Sait tu comment est agencé la mémoire dans une QImage?".

^^ donc non.
QImage interface un tableau 2D mise à plat. C'est à dire qu'il utilise un tableau 1D et accède au pixel par

Code :

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

int id(int x, int y) { return y*Width+x;}

ou width est la largeur de l'image.

Comme tu utilise de l'ARGB c'est exactement ton cas.

Mais peux y avoir une particularité avec d'autre type de pixel comme le indexed 8 bits. QImage considère que taille en octet d'une ligne en mémoire est un multiple de 4. Si ce n'est pas le cas il y as du padding ajouté. Et la formule deviens :

Code :

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

int id(int x, int y) { return y*(Width+padding)+x;}

Ce qu'il faut savoir :
- getPixel n'est pas coûteux.
- setPixel est trés couteux car QImage utilse le COW et il y as des testes.
- bits : permet d’accéder au buffer interne au début
- scanline : permet d’accéder au début d'une ligne.
Pour bits et scanLine :
* si l'instance est const cela ne coûte rien.
* si l'instance est non const il y as des testse dû au COW et faut eviter
- Si les pixel sont du type ARGB32* ou RGB32, tu peux considérer que le buffer internet est un tableau de QRgb et donc caster ce qui est retourné par bits ou scanline.

voici ce que cela donne quand tu veux remplir les pixels d'une QImage avec des pixels de type ARGB32* ou RGB32

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
const unsigned int H = img.height();
const unsigned int W = img.width();
for(int y = 0; y < H; ++y)
{
     QRgb * line = (QRgb*) img.scanLine(y);
     for(int x = 0 ; x < W; ++x)
     {
         line[x] = ....
     }
}

Comme il n'y as pas de padding avec les formats ARGB32* ou RGB32, tu peux aussi le faire en une boucle

Code :

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

1
2
3
4
5
6
7
8
 
const unsigned int idMax = img.height()*img.width();
QRgb * imgBuffer= (QRgb*) img.bits();
for(int id = 0; id < idMax ; ++id)
{
         imgBuffer[id] = ....
 }
}

Pour la 2ème question: les données dans le fichier sonten Hexa et les paramètres de la construction du pixel sont en décimal

Dans ton code, tu lie un char, tu le convertie en hexa et tu le retransforme en char. Cela ne sert à rien. Tu lie un char et tu l'utilise directement.
De plus il faut mieux lire un fichier d'un coup que pas à pas comme tu le fait.
Regarde la fonction readAll de QFile.

[alexmam15]

Dans ton code, tu lie un char, tu le convertie en hexa et tu le retransforme en char. Cela ne sert à rien. Tu lie un char et tu l'utilise directement.

c'est pas ça, je lis un char, je le converte en Hexa puis en entier pour la construction du pixel. c'est ça,non?

[yan]

c'est pas ça, je lis un char, je le converte en Hexa puis en entier pour la construction du pixel. c'est ça,non?

La valeur du char lu et la valeur du int est la même

[alexmam15]

Comment je transforme mon code alors au niveau de

Code :

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

value=qRgb(int,int,int,int);

merci

[yan]

Qu'es ce que tu n'as pas compris?

[alexmam15]

j'ai oublie de vous dire que les fichiers ne sont pas en Hexa, c'est déja pourquoi lorsque on l'ouvre avec un éditeur de teste on trouve queque chose incompréhensible, pour les rendre en hexa il faut lire chaque caractère et trouve son code ASCII en Hexa (c'est pour celà que j'utilise la fonction .Hex()).
Donc je peux pas lire le fichier en entier, il faut avoir une autre méthode.

Est ce que je peux importer le fichier en mémoire au lieu de faire la lecture directe à partir de fichier pour réduire le temps?

[yan]

j'ai oublie de vous dire que les fichiers ne sont pas en Hexa, c'est déja pourquoi lorsque on l'ouvre avec un éditeur de teste on trouve queque chose incompréhensible, pour les rendre en hexa il faut lire chaque caractère et trouve son code ASCII en Hexa (c'est pour celà que j'utilise la fonction .Hex()).
Donc je peux pas lire le fichier en entier, il faut avoir une autre méthode.

De ce que je comprend ton fichier est en binaire. Et c'est pour cela que tu n'arrive pas à le lire avec un fichier text.
fichier.read(1) te lis un octect (char). Ce qu'il représente est la valeur int que tu veux utiliser. Tu n'as donc aucun besoin de passer pas une représentation hexa et revenir à un int.
char et int sont tous les deux des entiers. La différence est le nombre de valeur possible.
Pour accéder aux valeurs lue dans le byteArray, tu peux utiliser QByteArray::constData.

[alexmam15]

merci pour vos réponse et désolé si je vous dérange car c'est la première fois que je traite des fichiers images en Qt, bon voilà ce que je veux faire:

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
 
#include <QApplication>
#include <QFile>       
#include <QString>     
#include <QByteArray>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QPixmap>
 
int main(int argc, char **argv)
{
    QApplication app(argc, argv);
uchar buffer[width * height * 4];
QImage image(buffer, width, height, QImage::Format_ARGB32);
uchar* pbuffer = &buffer[0];
QFile fichier("monimage.xxx");
 if(fichier.open(QIODevice::ReadOnly))
QByteArray text=readAll();
 
while( i<text.size())
{
 
*pbuffer = (uchar) text[i]; // blue
++pbuffer;
*pbuffer = (uchar) text[i+1]; // green
++pbuffer;
*pbuffer = (uchar) text[i+2]; // red
++pbuffer;
*pbuffer = (uchar) text[i+3]; // alpha
++pbuffer;
i+=4;
}
 
QGraphicsScene scene;
QPixmap pixmap = QPixmap::fromImage(image);
scene.addPixmap(pixmap);
QGraphicsView vue(&scene);
vue.show();
return app.exec();
}

Le problème c'est est ce que text[i] est un char et il doit être enregister sous forme de Int;

le code marche bien, et le temps d'exécution et beaucoup plus mieu.
Merci pour votre aide, c'est gentil

[yan]

désolé si je vous dérange car c'est la première fois que je traite des fichiers images en Qt, bon voilà ce que je veux faire:

Non non t'inquiète pas. Au contraire le forum est là pour cela.

Le problème c'est est ce que text[i] est un char et il doit être enregister sous forme de Int;

dans ton cas char et int c'est la même chose. C'est vrai que leurs méthode peux porter à confusion.

ton code est tout même un peu compliqué. Avec mes explication, tu peux faire un truc comme :

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
QImage image(buffer, width, height, QImage::Format_ARGB32);
 
QByteArray fileMemory;
 
QFile fichier("monimage.xxx");
if(fichier.open(QIODevice::ReadOnly))
    fileMemory=readAll();
 
QRgb * imgBuffer = (QRgb *) image.bits();
for (int id =0 , idMemory = 0;id < width* height;++id ,idMemory +=4)
{
     imgBuffer[id] = qRgba(
                              fileMemory[idMemory +2],
                              fileMemory[idMemory  +1],
                              fileMemory[idMemory ],
                              fileMemory[idMemory +3])
);
 
}