Creation d'images TIFF

Version imprimable

Bonjour,

J'ai une nouvelle fois besoin de vos lumières avisées...

J'ai un tableau 2D (600*600) contenant des températures en centièmes de Kelvin (donc des nombres à 5 chiffres) que je récupère castées en unsigned short int. Je souhaite enregistrer ce tableau sous forme d'une image tiff en niveau de gris, pour cela j'essaye de convertir mes données codées sur 16 bits en données codées sur 8 bits, puis j'utilise les fonctions TIFFOpen, TIFFWriteScanline et TIFFClose de la librairie tifflib.

Le problème c'est que l'image que j'obtiens est toute noire... Il semblerait donc que je me sois trompé quand je veux passer des données codées sur 16 bits aux données codées sur 8 bits... Ou alors lors de l'utilisation de TIFFWriteScanline...

et voici un bout de mon 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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/*NBLIG et NBCOL sont des constantes valant 600 et temperature est un tableau 2D casté en unsigned short int contenant mes températures*/
      unsigned char ** temp8bit = malloc (NBLIG *sizeof(unsigned char *));
      if (temp8bit == NULL)
         {
         free(temp8bit);
         printf("erreur lors de l'allocation memoire 4");
         }
      else
         {
         for (i=0;i<NBLIG;i++)
            {
            temp8bit[i]= malloc(NBCOL * sizeof(unsigned char));
            if (temp8bit[i] == NULL)
               {
               free(temp8bit[i]);
               printf("erreur lors de l'allocation memoire 5");
               }
            for (j=0; j<NBCOL; j++)
               {
               temp8bit[i][j]=temperature[i][j]*(255/65535);
               }
            }
         TIFF* imgTIFF = TIFFOpen("toto.tif","w");
         if (imgTIFF == NULL)
            {
            printf("erreur à la creation du tiff");
            }
         else
            { 
            TIFFSetField(imgTIFF,TIFFTAG_IMAGEWIDTH,NBLIG);
            for (i=0; i<NBLIG; i++)
               {
               TIFFWriteScanline(imgTIFF,temp8bit[i],i,0);
               }            
            TIFFClose(imgTIFF);  
            }
         free(temp8bit);   
         }

20/11/2009, 19h43
Mac LAK

A mon avis, mets directement ceci comme conversion :

Code:

temp8bit[i][j]=(unsigned char)((temperature[i][j]>>8) & 0xFF) ;

Le résultat de ta division, dont j'avoue ne pas comprendre réellement le but, est évalué à zéro => pixel à zéro => image noire.
21/11/2009, 15h28
SofEvans
Pour completer la reponse de MacLak :
Code:

1 2 temp8bit[i][j]=temperature[i][j]*(255/65535);
Ceci est une division d'entier (egalement connu sous le nom de "division euclidienne"). Cela signifie "combien de fois on peut mettre 65535 dans 255 ?".

Pour palier a ce probleme (car tu veux faire une division de reel et non d'entier), il faut faire en sorte qu'au moins une des deux valeurs mise en jeu ne soit pas de type "entier" (donc pas long, int short ...), mais de type "réel" (double, float ...).
La mauvaise solution serait d'appliquer un cast. La bonne solution serait :
Code:

1 2 temp8bit[i][j]=temperature[i][j]*(255/65535.0);

Arf désolé je me suis trompé de bout de code à vous montrer :/
Ca c'est quand j'ai essayé de faire un réetalement de la dynamique, car vu que mes températures ne varient pas entre 0 et 65535, c'est le meilleur moyen pour avoir du contraste sur l'image (réaffecter 0 à la plus basse température et 256 à la plus élevée). Mais j'ai préféré laisser ça de côté tant que je n'arrive pas à créer mon image tiff.

Donc j'ai essayé la solution de Mac LAK, mais malheureusement ça ne fonctionne pas. L'image obtenue n'est pas bonne (cf miniature on devrait avoir une sorte de photos avec des nuages...). C'est donc que j'ai du me tromper dans la création de l'image avec tifflib, y'a t'il une horreur/erreur qui vous saute aux yeux quand vous voyez cela ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 TIFF* imgTIFF = TIFFOpen("toto.tif","w"); if (imgTIFF == NULL) { printf("erreur à la creation du tiff"); } else { TIFFSetField(imgTIFF,TIFFTAG_IMAGEWIDTH,NBLIG); for (i=0; i<NBLIG; i++) { TIFFWriteScanline(imgTIFF,temp8bit[i],i,0); } TIFFClose(imgTIFF); }
Merci de votre aide !

23/11/2009, 10h32
Mac LAK

Citation:

Envoyé par Flaherty Mc Coillean

(réaffecter 0 à la plus basse température et 256 à la plus élevée)

Attention : 256 n'est PAS une valeur autorisée dans une image 8 bits, c'est 255 le maximum !!!
La solution que je te donne (via un décalage binaire) est la meilleure approximation possible de ce que tu cherches, considérant bien sûr que la dynamique de base est bien sur l'échelle 0..65535. Si elle est plus courte que ça, un changement d'échelle sera nécessaire avant d'appliquer la moindre formule si tu désires obtenir systématiquement une image avec une dynamique 8 bits maximale.

Citation:

Envoyé par Flaherty Mc Coillean

y'a t'il une horreur/erreur qui vous saute aux yeux quand vous voyez cela ?

Je ne connais hélas pas cette librairie, donc difficile de t'aider à ce sujet.
Par contre, tu peux éventuellement sauvegarder ton image dans un format plus simple afin de mieux voir ce qu'il se passe : je ne saurais trop te conseiller soit un format RAW, soit un format TGA pour les tests (afin de vérifier si l'image est correcte).
Si tu utilises TGA, il te suffit de sauver les valeurs R, G et B comme étant égales entre elles, et valant ta couleur 8 bits calculée.

Si ton image RAW/TGA est bonne, c'est que ton utilisation de la librairie TIFF est foireuse. Si l'image RAW/TGA est foireuse, c'est ton algo qui est en cause. Au pire, ça t'aidera à trouver plus rapidement la localisation de l'erreur.

Salut,

J'ai retravaillé dessus, et j'ai progressé, en fait je n'avais pas suffisamment paramétré mon tiff. J'arrive désormais a créer une image tiff qui est presque bonne. Je dis presque parce qu'il y'a un sérieux problème de déformation...

En fait ce qui devrait être des colonnes, forme des diagonales (cf les miniatures). Le premier pixel qui devrait se trouver en haut à gauche de l'image se retrouve en haut à droite... Pourtant théoriquement TIFFTAG_ORIENTATION précise bien qu'il faut qu'il soit en haut à gauche :/

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
         TIFF* imgTIFF = TIFFOpen("toto.tif","w");
         if (imgTIFF == NULL)
            {
            printf("erreur à la creation du tiff");
            }
         else
            {
            int SamplesPerPixel = 1, BitsPerSample = 8;
 
            TIFFSetField(imgTIFF, TIFFTAG_BITSPERSAMPLE, BitsPerSample);
            TIFFSetField(imgTIFF, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
            TIFFSetField(imgTIFF, TIFFTAG_IMAGELENGTH, NBLIG); 
            TIFFSetField(imgTIFF, TIFFTAG_IMAGEWIDTH, NBCOL);
            TIFFSetField(imgTIFF, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
            TIFFSetField(imgTIFF, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
            TIFFSetField(imgTIFF, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT); 
            TIFFSetField(imgTIFF, TIFFTAG_SAMPLESPERPIXEL, SamplesPerPixel);
 
            for (i=0; i<NBLIG; i++)
               {
               TIFFWriteScanline(imgTIFF,temp8bit[i],i,0);
               }            
            TIFFClose(imgTIFF);
            }

Voilà des idées pour corriger ce petit problème ?

23/11/2009, 14h26
Jerome Briot

J'ai l'impression que ça correspond plus à un décalage de pixel, non ?

La diagonale (bas-gauche => haut-droit) de la seconde image correspond au bord gauche de la première image

La première ligne du bas serait bien remplie mais avec au moins 1 pixel en trop ou en moins => les lignes suivantes reporteraient ce décalage...

Les dimensions de l'image finale (NBLIG et NBCOL) sont-elles bonnes ?
23/11/2009, 15h10
Flaherty Mc Coillean

Arf merci Dut ! C'était effectivement un problème de décalage plus en amont dans mon code...

Le problème est réglé, merci beaucoup à tous !

J'espère ne pas trop dire de bêtises mais je pense qu'il y a un problème avec ton allocation de mémoire en cas d'échec :
Code:

1 2 3 4 5 6 7 8 9 10 11 for (i=0;i<NBLIG;i++) { temp8bit[i]= malloc(NBCOL * sizeof(unsigned char)); if (temp8bit[i] == NULL) { free(temp8bit[i]); printf("erreur lors de l'allocation memoire 5"); } for (j=0; j<NBCOL; j++) temp8bit[i][j]=temperature[i][j]*(255/65535); }
Si temp8bit[i] ne peut pas être alloué, tu continues quand même ton code... :?

Dans un premier temps sépare l'allocation de mémoire du calcul proprement dit .
Ensuite, il faut désallouer la mémoire de tous les éléments précédemment alloués et pas seulement du dernier.
Enfin, il faut sortir du programme si l'allocation échoue
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 for (i=0;i<NBLIG;i++) { temp8bit[i] = malloc(NBCOL * sizeof(unsigned char)); if (temp8bit[i] == NULL) { for(j=0;j<i;j++) { free(temp8bit[j]); temp8bit[j] = NULL; } printf("erreur lors de l'allocation memoire 5"); return; /* A modifier suivant le type de retour de ton code */ } } for (i=0;i<NBLIG;i++) for (j=0; j<NBCOL; j++) temp8bit[i][j]=temperature[i][j]*(255/65535);

ah merci je n'avais pas vu...

En fait pour toutes les autres allocations mémoire j'ai fait ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
   unsigned short int ** temperature = malloc (NBLIG * sizeof(unsigned short int*));
   if (temperature == NULL)
      {
      free(temperature);
      printf("erreur lors de l'allocation memoire 2");
      }
   else
      {
      for(i=0;i<NBLIG;i++)
         {
         temperature[i]=malloc(NBCOL * sizeof(unsigned short int));
         if(temperature[i] == NULL)
            {
            free(temperature[i]);
            printf("erreur lors de l'allocation memoire 3");
            }
         else
            {
            /*bout de code*/
            }
         }
      }
   free(temperature)

Ce qui fait qu'en cas d'échec d'allocation on quitte le code et on arrive sur free(temperature). Est ce que free(temperature) suffit pour désallouer entièrement la mémoire où il faut absolument désallouer temperature[i] pour tous les i ?

24/11/2009, 11h46
Mac LAK

Citation:

Envoyé par Flaherty Mc Coillean

Est ce que free(temperature) suffit pour désallouer entièrement la mémoire où il faut absolument désallouer temperature[i] pour tous les i ?

En C, tu dois avoir une égalité stricte entre le nombre de malloc et le nombre de free, il n'y a pas de concept de destructeur comme en C++ qui se charge de détruire les entités possédées.

Donc, si tu as fait une boucle de NBLIG itérations pour allouer, il te faut une boucle de NBLIG itérations pour libérer.

EDIT : Inutile de faire un free sur un malloc qui a échoué, par contre. Si malloc échoue, il n'y a rien à libérer car rien n'a été alloué.
24/11/2009, 11h48
Jerome Briot

Citation:

Envoyé par Flaherty Mc Coillean

Ce qui fait qu'en cas d'échec d'allocation on quitte le code et on arrive sur free(temperature). Est ce que free(temperature) suffit pour désallouer entièrement la mémoire où il faut absolument désallouer temperature[i] pour tous les i ?

=> http://rperrot.developpez.com/articl...llocationC/#L3
24/11/2009, 11h53
Flaherty Mc Coillean

Merci pour vous réponses, je vais régler tout ça de suite!