Discussion :

[ody31gr]

Bonjour,

Mon application doit lire un fichier de type TIFF et afficher son contenu dans un QLabel.

Facile vous allez me dire, mais Qt ne supporte pas (encore) les fichiers TIFF a multi-page.

Donc, je fais appel a libTIFF pour la lecture du TIFF. L'idee est donc de lire le fhcier TIFF, separer les pages en les stoquant dans un conteneur, et iterer dessus pour afficher image par image.

Voici la partie du code utilisant libTIFF, qui lit le fichier TIFF.

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
49
50
51
52
53
54
55
56
 
#include "tiffio.h"
 
 
TIFF* f_tiff;
unsigned int width;
unsigned int height;
unsigned short depth;
unsigned short samples_per_pixel;
unsigned short photo_metric;
int total_pages;
 
//ici on stoque les differentes pages
std::vector< unsigned char* > _pages;
 
f_tiff = TIFFOpen( input_file.c_str(), "r" );
//on suppose que le fichier est bien ouvert
 
TIFFGetField( f_tiff, TIFFTAG_IMAGEWIDTH, &width );
TIFFGetField( f_tiff, TIFFTAG_IMAGELENGTH, &height );
TIFFGetField( f_tiff, TIFFTAG_BITSPERSAMPLE, &depth );
TIFFGetField( f_tiff, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel );
TIFFGetField( f_tiff, TIFFTAG_PHOTOMETRIC, &photo_metric );
 
total_pages = 0;
 
//Pour chaque page
do{
     total_pages++;
 
     //tampon pour stoquer la page actuelle
     unsigned char* in_image = (unsigned char*) _TIFFmalloc( width * height );
 
     if( in_image == NULL )
         log( "Could not allocate memory!" );
     else
     {
         int check_io;
         unsigned int row;
 
         //lire ligne par ligne de la page actuelle
         for( row = 0; row < height; row++ )
         {
              check_io = TIFFReadScanline( f_tiff, &in_image[ row * width ], row, 1 );
              if( check_io != 1 )
                  log( "ERROR IO" );
         }
 
         //la lecture de la page est terminee, on la stoque dans le conteneur
         _pages.push_back( in_image );
     }
 
}
while( TIFFReadDirectory( f_tiff ) ); //Pour chaque paqe
 
TIFFClose( f_tiff );

Maintenant pour simplifier, nous allons afficher la toute premiere page sur un QLabel, nomme label_fax.

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
 
//Pointeur sur la premiere page
unsigned char* raw = _pages[ 0 ];
 
//On sait d'avance que le fichier TIFF qu'on veut afficher est code sur 1bit (noir ou blan) donc on cree la QImage avec un format Mono (voir doc Qt)
QImage image( width, height, QImage::Format_Mono );
 
for( unsigned int y(0); y < height; ++y )
{
    for( unsigned int x(0); x < width; ++x )
    {
        int index( y * width + x );
        unsigned char pix = raw[ index ];
        image.setPixel( x, y, pix );
     }
}
label_fax.setPixmap( QPixmap::fromImage( image ) ); 
label_fax.show();

Jusqu'ici tout va bien, la compilation fonctionne parfaitement.

Le systeme de gestion des pages fonctionne egalement.

Le probleme, dont je cherche a resoudre, est l'affichage de l'image.

Voici l'image originale:



Et voici l'image affichee sur mon interface Qt avec le code ci-dessus:


On dirait que la largeur est deformee...

Je n'arrive pas a trouver ce qui peut causer ceci ( j'y travaille depuis mardi ! ).

P.S. Les tags width, height etc sont corrects.

Avez vous une idee ? Une piste ?

[Bousk]

Salut,

à vue de nez, je dirais que tu ne lis pas bien tous les pixels. Du style tu ne prends que 1/4 ou 1/3 (1 composante de (A)RGB) de ton image.
Mais je n'ai jamais joué avec le format TIFF pour pouvoir en savoir plus.

[ody31gr]

Mais mon image est caracterisee par:

Code :

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

1
2
3
 
TIFFGetField( f_tiff, TIFFTAG_BITSPERSAMPLE, &depth );
TIFFGetField( f_tiff, TIFFTAG_SAMPLESPERPIXEL, &samples_per_pixel );

depth et samples_per_pixels valent 1. Donc un composant par pixel, un bit ?

Tu as surement raison, je ne lis pas tous les pixels.

Peut etre quand je lis 1 octet, en realite j'en lis 8 ? ( 1 bit par composante et 1 composante par pixel )

[_zzyx_]

C'est quoi le type de donnée dans ton images, là tu la lis comme un tableau d'octet (que se passe-t-il si l'image source est 16 bits ? ) je pense pas que ce soit ton problème mais juste une observation.

Seconde question (peut être ton problème) comment est geré la couleur dans le tif et dans Qt ?
Si tu lis une image noir et blanc (Un pixel = 1 valeur) et que tu remplis une image couleur (Un pixel = 3 valeurs RGB) ca peut tout à fait te faire sauter un pixel sur trois. (Sous réserve que dans Qt les images soit des tableaux de pixels RGB et pas 3 tableaux de pixels).

J'ai galéré il y a peu avec libtiff donc ce sont les pistes que je vois mais je te garantis rien.

[ody31gr]

Je dois mettre de cote cette fonctionalite pour le moment.

Mais j'y reviendrai des que je peux.

Ta piste me semble tres interessante en tout cas.

Merci beaucoup !

[ody31gr]

Ton idée est intéressante en effet.

Je décris la problématique.

Je travaille dans le domaine de la téléphonie numérique, et plus particulièrement, sur le Fax over IP.

Pour l'instant je sais que les TIFF générés avec nos modules, sont codés sur 1 bit.


Vu que je crée la QImage en utilisant le format QImage::Format_Mono (voir http://qt-project.org/doc/qt-4.8/qim...ml#Format-enum ) pourquoi tu penses que malgré tout Qt place 3 composantes pour l'image ?