Lire et afficher une image en Qt

Version imprimable

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

02/04/2009, 13h33
superjaja
Citation:

Envoyé par lisco

oui mais j'ai une image en niveau de gris c'est à dire sans couleur , est ce toujours possible avec setpixel?
et est ce que je peux utiliser file.read(monfichier.seek(i)) pour lire les pixels de l'image dans le fichier en faisant une boucle

Si tu a une image en niveau de gris tu mets la valeur des 3 composant RGB à la meme valeur representant le niveau de gris.
Code:

1 2 3 QRgb value; value = qRgb(255, 255, 255); uneImage.setPixel(x,y,value);//Pixel tout blanc
Regarde bien la doc Qt tu auras plein d'information sur les question que tu te pose au niveau de l'utilisation de certaine fonction. ;)
02/04/2009, 13h34
yan

Citation:

Envoyé par lisco

oui mais j'ai une image en niveau de gris c'est à dire sans couleur , est ce toujours possible avec setpixel?
et est ce que je peux utiliser file.read(monfichier.seek(i)) pour lire les pixels de l'image dans le fichier en faisant une boucle

:koi:
la je ne comprend plus rien... Qu'es ce que tu as compris et pas compris??

Bonjour ,
Alors Yan, ce que j'ai compris c'est puisque j'ai une image en niveau de gris les composantes rgb sont toutes égales mais j'ai les valeurs de mes pixels différentes de 255, à mon avis je dois avoir ceci:

Code:

value = qrgba(255,255,255,valeur du pixel à lire dans mon fichier) ;

si c'est pas le cas je pense alors que la valeur du pixel contenu dans mon fichier doit etre :

Code:

value = qrgba(0,0,0,valeur du pixel à lire dans mon fichier) ;

Alors je reexplique, j'ai mon fichier image comme je l'ai presenté des le debut :là j'ai lus l'en-tete de mon fichier et j'ai recupéré le nombre de lignes et de colonnes ensuite la taille des commentaires, ce qui me montre par où commence les pixels de l'image et je dois lire les pixels à partir de :

Code:

file.seek(Taille des commentaires) ce qui équivaut à file.seek(437) ;

ensuite je mets les pixels dans le QImage en utilisant la méthode setpixel;
cela fait aujourd'hui 4jours je suis dessus, mais je vais pas baisser les bras avec votre aide et je vais bien comprendre si vous m'aidez, alors voici mon bout de 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 QImage uneImage(rows, columns, QImage::Format_ARGB32) ; uint valeur_pixel ; for (int k = 0; k < (rows * columns * 4) ; k = k + 6000) { file.seek((128 + CommentLength) + k) ;// Je lis le fichier à cette position que je vais incrementer de la taille des donnes lues //cad de la valeur de rows*taille d'un pixel:4*1500 = 6000 for (int n = 0; n < rows; n++) { QDataStream in(&file) ;// Je lis le fichier for (int m = 0; m < columns; m++) { in >> valeur_pixel ;// j'ecrase les valeurs lues apres avoir remplit mon QImage a chaque tour de boucle. uneImage.setPixel(n,m,valeur_pixel) ;//je remplis QImage avec la valeur_pixel ui->ZoneImage->setPixmap(QPixmap::fromImage(uneImage));
Le grand probleme c'est de reussir a lire mon fichier qui fait 1200 * 1300 et de recuperer les pixels ??

Moi perso j'ai du mal a suivre. Si tu as un image en niveau de gris et que chaque niveau de gris est codé sur 8 bits cela veut dire que tu dois lire 1200*1300 octets. Donc tu peux utiliser une buffer comme ca:
Code:

1 2 char* buff = new char[1200*1300];//Buffer ou vont etre les pixels file.read ( buff,1200*1300);//là tu lis tout les pixels de ton image a condition de t'etre positionné au bonne endoit dans ton fichier
Normalement une fois que tu as fait ca, tu dois afficher ton image. Je ne suis pas sur que Qt gère les images 8 bits niveau de gris ou alors voir ce format peut etre je comprend pas bien ce qu'il fait (QImage::Format_Indexed8). Si ce format de correspond pas tu crée une image RGB et avec set pixel tu fais.
Code:

1 2 3 QRgb value; value = qRgb(Buff[i], buff[i], buff[i]);//La variable i est l'index correspondant a ton pixel uneImage.setPixel(x,y,value);//Tu renseigne la valeur du pixel dans l'image
Sinon il faudrait que tu te mettes d'accord dans le format de ton image. C'est a dire comment elle se trouve dans ton fichier. Au debut tu parlais d'une image 8 bits puis RGB puis avec des valeurs composées de float. Tout cela est possible mais ça on peut pas le savoir seul toi peux nous renseigner. Et en fonction de comment sont codés les pixels les methodes pour arriver à l'affichage d'une image peuvent changer.

02/04/2009, 19h49
lisco

Merci Superjaja, alors je vais apporter des precisions :
J'ai une image float en niveau de gris codé sur 32 bits dans un fichier que je dois lire pour afficher l'image.
02/04/2009, 20h04
yan

Bon on va faire plus rapide.
Tes pixels sont codés en quoi dans ton fichier???
ce sont des octets? des entier? des float?

La j'y comprend plus rien. Tu as toute les indications qu'il faut. Si tu ne comprend pas des explications, demande des précisions. La on tourne en rond... Vue ce que tu explique, y as vraiment rien de compliquer:
1- tu sait lire l'entête :king:
2- ne tien pas compte de ma remarque sur seek. j'ai dit une connerie apparemment.
3- Si tes pixels sont des octets, pourquoi tu lit des uint?
4- Pourquoi tu met dans la couche alpha la valeur de ton pixel?
02/04/2009, 20h16
lisco

là je pense que c'est moi qui comprends pas trop ;je résume encore:

J'ai une image float en niveau de gris et chaque pixel est codé sur 32 bits.
Donc je pense que chaque pixel occupe 4 octets en mémoire.Mais la valeur des pixels c'est des float.
dans mon fichier l'en-téte occupe 437 octets et le reste ce sont les pixels de l'image sur 1200 lignes et 1300 colonnes.
J'ai utilisé la couche alpha car je sé pas trop ce que cela represente si les rgb sont les composantes couleurs, dsl.
02/04/2009, 20h22
IrmatDen

L'alpha, c'est l'opacité, la transparence. Pour un niveau de gris, il faut affecter la même valeur à R, G et B.

La valeur des float se trouve dans quel espace ? C'est encore LE détail qui manque pour que tu puisses créer un QImage ou QPixmap.
02/04/2009, 20h52
lisco

dans quel espace ?? j'ai pas bien compris ta question,si tu peux eclaircir stp??

j'ai ces valeurs dans un fichier, et c'est une image en niveau de gris , je sais pas si ça repond a ta question?
02/04/2009, 21h32
superjaja

Citation:

Envoyé par lisco

dans quel espace ?? j'ai pas bien compris ta question,si tu peux eclaircir stp??

j'ai ces valeurs dans un fichier, et c'est une image en niveau de gris , je sais pas si ça repond a ta question?

En general les images sont pas en float sauf si elles ont subit une transformation ou si elles sont codée de maniere particulire. Ce que te demande IrmatDen c'est en fait dans quel espace ce trouve tes float pour pouvoir faire la transformation inverse et passer de float en octet et ainsi pouvoir afficher ton image (enfin si je me trompe pas sur ce que dit IrmatDen). :D
02/04/2009, 21h51
lisco

Superjaja tu m'avais donné ceci:

Code:

QImage((uchar*)image , rows, columns, QImage::Format_RGB32)??

Ne gére que les images en uchar??est ce je me trompe ??
02/04/2009, 21h57
lisco

l'espace dans lequel se trouve mes floats, je sais pas trop désolé IrmatDen .
Je savais pas que les images en float on subit une transformation ou ont été codées d'une maniere particuliere merci a Superjaja pour ces precisions. Mais je suis preneur si vous pouvez me dire les methodes de transformations qui existe pour passer de float en octet!!
02/04/2009, 22h13
superjaja

Citation:

Envoyé par lisco

Superjaja tu m'avais donné ceci:

Code:

QImage((uchar*)image , rows, columns, QImage::Format_RGB32)??

Ne gére que les images en uchar??est ce je me trompe ??

C'est a dire qu'elle ne gere que les images ou les pixels sont représentés par des octets. Donc directement si tu as des float c'est pas possible d'utiliser ça.

Sinon vu ou on en est dans un premier temps je pense que tu devrais utiliser setPixel() et pas crée une image directement a partir du buffer pour les raison qu'a precisé yan.
03/04/2009, 02h48
IrmatDen

Citation:

Envoyé par superjaja

En general les images sont pas en float sauf si elles ont subit une transformation ou si elles sont codée de maniere particulire. Ce que te demande IrmatDen c'est en fait dans quel espace ce trouve tes float pour pouvoir faire la transformation inverse et passer de float en octet et ainsi pouvoir afficher ton image (enfin si je me trompe pas sur ce que dit IrmatDen). :D

C'était presque ça :)
Il n'y a pas nécessairement de notion d'inversion ; si tu prends une image HDR, elles sont codées en float, et certains appareils photos les enregistrent directement dans ce format (cf wiki). Par contre, tu peux assurément parler de conversion ;)

@ lisco
Dit autrement, je demandais si tes valeurs:
a. sont comprises entre 0-1 (auquel cas, tu multiplies par 255 dans un premier temps) ?
b. sont dans un autre espace que 0-1, auquel cas il faut que tu saches lequel pour pouvoir les ramener entre 0 et 255.

Bonjour, d'aprés vos conseils voici la voie que j'ai opté pour voir le resultat:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 char* buff = (char*) malloc(isize); file.read ( buff,rows*columns * 4); QImage uneImage((uchar*)buff , rows, columns, QImage::Format_RGB32) ; QRgb value; QImage uneImage ; // int qGray ( int r, int g, int b ) ; for (int x = 0; x < rows; x = x + 1) { for (int y = 0; y < columns; y = y + 1) { value = qRgb(*(buff+(x*columns+y)), *(buff+(x*columns+y)), *(buff+(x*columns+y))); uneImage.setPixel(x,y,value); } } ui->ZoneImage->setPixmap(QPixmap::fromImage(uneImage));
Cela m'affiche une image en niveau de gris ,mais une image vraiment tres bizarre et tres foncé et aussi qui depasse les dimansions de l'image originale en fait l'image depasse meme l'ecran de mon ordinateur !!!tres bizarre pour moi alors que j'ai alloue la bonne taille???
Si vous pouvez encore m'aider svp et merci d'avance a vous tous .

03/04/2009, 07h37
yan
Pourquoi est tu revenu en arrière ?? :cry:
l'autre code était bien mieux.

Comme te la demandé irmatden, connaît tu la dynamique de tes valeur? (0-1, min et max, positif, négatif,...)
C'est ce dernier point qui va changer la façon de traiter la lecture.

Dans la plupart des cas, il te faudra sûrement retrouver quelques valeurs dans ton image. Comme le min et le max par exemple.
Vue la taille de ton images, tu peut utiliser un buffer de float (et non de char) qui contiendra les valeur de ton mage.
Code:

1 2 3 4 5 std::vector<float> buffer(rows*columns); for (int id = 0 ; i < rows*columns ; ++i) { in >> buffer[id]; }
Ensuite avec ta méthode de convention float -> pixel tu rempli les pixel de ton image
03/04/2009, 09h14
superjaja

Citation:

Envoyé par Lisco

Code:

QImage uneImage((uchar*)buff , rows, columns, QImage::Format_RGB32) ;

A moins que je ne me trompe cette ligne ne sert a rien si tu remplis avec setPixel() et il vaut mieux que tu utilises ça je pense :

Code:

QImage uneImage(rows, columns, QImage::Format_RGB32);

Citation:
Envoyé par yan
Pourquoi est tu revenu en arrière ?? :cry:
l'autre code était bien mieux.

Comme te la demandé irmatden, connaît tu la dynamique de tes valeur? (0-1, min et max, positif, négatif,...)
C'est ce dernier point qui va changer la façon de traiter la lecture.

Dans la plupart des cas, il te faudra sûrement retrouver quelques valeurs dans ton image. Comme le min et le max par exemple.
Vue la taille de ton images, tu peut utiliser un buffer de float (et non de char) qui contiendra les valeur de ton mage.
Code:

1 2 3 4 5 std::vector<float> buffer(rows*columns); for (int id = 0 ; i < rows*columns ; ++i) { in >> buffer[id]; }
Ensuite avec ta méthode de convention float -> pixel tu rempli les pixel de ton image
Bonjour ,

Yan là je vois pas trop comment remplir les pixels dans l'image , je dois utiliser setpixel?? voila ce que j'ai essayé:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 std::vector<float> buffer(rows*columns); for (int i = 0 ; i < rows*columns ; i++) { in >> buffer[i]; for (int x = 0; x < rows; x = x + 1) { for (int y = 0; y < columns; y = y + 1) { value = qRgb(buffer[x][y], buffer[x][y] , buffer[x][y]); uneImage.setPixel(x,y,buffer); //Reconstruction de l'image pixel par pixel, x et y étant l'index de l'image } } ui->ZoneImage->setPixmap(QPixmap::fromImage(uneImage));*/
Mais ça marche pas et ça plante.
Sinon le niveau de gris max de mon image est 1 et le niveau min est 0.

J'ai pas tres bien compris cette methode yan si tu peux donner plus d'explication stp sur la maniere de remplir les pixels dans l'image.
Merci d'avance

Sinon ce sur quoi j'ai travaillé aujourd'hui est :

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
  char* image = (char*) malloc(isize);
 
   file.read ( image,rows*columns * 4);//Chaque pixel est codé sur 32 bits donc je multiplie par 4.
 
    for (int i = 0; i < rows; i++)
   {
       for (int j = 0; j < columns; j++)
       {
           *(image + (i*columns + j)) = ((MaxSignalLevel - MinSignalLevel) * *(image +(i*columns + j)))/(QuantLevels) ;
            // w = *(image + (i*columns + j)) ;
       }
   }
 
   QImage uneImage((uchar*)image , rows, columns, QImage::Format_ARGB32) ;
 
   //Jusqu'ici je peux afficher l'image mais en RGB, et ensuite j'essaie de transformer l'image en niveaux de gris.
 
  // std::vector<float> buffer(rows*columns);
 
  QVector<QRgb> table(256) ;
   uneImage.setColorTable(table) ;
 
   for (int l = 0; l < 256 ; l++)
   {
       table[l] = qRgb(l, l, l) ;
 
       uneImage.setColorTable(table) ;
   }
 
 
   ui->ZoneImage->setPixmap(QPixmap::fromImage(uneImage));

Ceci ça marche , j'arrive à afficher l'image mais elle est en RGB et j'ai des problémes au niveau de la convertion en niveau de gris (cf voir code).
merci

Le code de yan sert a lire dans ton fichier binaire et remplace le file.read().
Il a repris ton code de depart avec le QDataStream et il utilise à la place de
char* buff=malloc(rows*columns); ça std::vector<float> buffer(rows*columns);
En gros je répete les etapes:

1 - tu lis les pixel de ton fichier comme ça
Code:

1 2 3 4 5 std::vector<float> buffer(rows*columns); for (int id = 0 ; i < rows*columns ; ++i) { in >> buffer[id]; }
2- Ici tu as donc tous tes pixels dans la varaible buffer et tu dois remplir ton image maintenant avec setPixel()
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 QImage uneImage(rows, columns, QImage::Format_RGB32); for (int x = 0; x < rows; x = x + 1) { for (int y = 0; y < columns; y = y + 1) { value = qRgb( buff[x*columns+y] * 255, buff[x*columns+y] * 255, buff[x*columns+y] * 255); uneImage.setPixel(x,y,value); } } ui->ZoneImage->setPixmap(QPixmap::fromImage(uneImage));
Je suis partie du principe que tu as des pixel entre 0 et 1 et que tu as juste a faire une multiplication par 255 comme on ne sait pas exactement ce quie représentent tes float...

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