Compression avec zlib

Compression avec zlib - C - Programmation

Marsh Posté le 02-06-2006 à 11:18:50    

Bonjour,
 
je suis sur un projet qui demande d'enregistrer / charger des images cérébrales 3D au format NIfTI. Ce format est constitué d'un fichier contenant un header puis, toujours à partir de l'offset 352 (taille du header), les niveaux de gris de l'image.
 
 L'enregistrement et le chargement fonctionnent parfaitement sous ce format et j'ai donc décidé de pouvoir utiliser la compression / décompression de fichiers avec zlib. Et c'est là que rien ne va plus.
 
En effet, après sauvegarde et compression, lorsque l'on recharge le fichier, l'image se trouve légèrement décalée. Cela n'est pas du au chargement puisque les fichiers externes dont je me sers pour tester le programme s'ouvrent correctement.
 
Les informations du header me semblent bien enregistrées étant donné qu'elles sont toutes récupérées au chargement. Il s'agit très certainement d'un problème à l'enregistrement des niveaux de gris de l'image.
 
Voici comment je les enregistre (après avoir enregistré le header) :
 

Code :
  1. if(!write_raw(fich, image, 352)){
  2.   remove(fich);
  3.   PUT_ERROR("Erreur lors de la sauvegarde des donnees MRI de l'image" );
  4.   return 0;
  5.  }


 
Ceci est l'appel de la fonction d'enregistrement des données avec comme argument le nom du fichier, la structure contenant les données à enregistrer ("image" ) et la position d'enregistrement (l'offset).
 
 
Voilà le code de cette fonction, d'où vient certainement le bug :
 

Code :
  1. int write_raw(const char *file_img, grphic3d *graphic, int offset)
  2. {
  3. gzFile f_img;
  4. int i=0,j=0,k=0;
  5.     char *buffchar;
  6.     short *buffshort;
  7.     long *bufflong;
  8.     void *buffer;
  9. int data_size,num_items;
  11. f_img=gzopen(file_img, "a+" );
  13. if(f_img==NULL || (long)gzseek(f_img, offset, SEEK_SET)==-1)
  14.     {
  15.    char tmp[256];
  16.    sprintf(tmp,"pas possible ecrire fichier %s\n",file_img);
  17.        PUT_ERROR(tmp);
  18.        return 0;
  19.     } 
  21. //---------------------IMG Section
  23. data_size = graphic->bitppixel/8;
  24. num_items = graphic->width*graphic->depth;
  25.     switch(data_size)
  26.     {
  27.     case sizeof(char):
  28. buffchar = CALLOC(num_items,char);
  29. if(buffchar == NULL) {
  30.     PUT_ERROR(
  31.          "[save_mri_ipb_3d] memory allocation error (2)!\n" );
  32.     gzclose(f_img);
  33.  FREE(buffchar);
  34.     return 0;
  35. }
  36. buffer = buffchar;
  38. for(j=0; j<graphic->height; j++)
  39. {
  40.     buffchar = buffer;
  42.  for(k=0; k<graphic->depth; k++)
  43.  for(i=0; i<graphic->width; i++)
  44.      *buffchar ++ = graphic->mri[i][graphic->height-j-1][graphic->depth-k-1];
  46.     if(gzwrite(f_img,(void *)buffer, data_size * num_items) / data_size != num_items) {
  47.  PUT_ERROR(
  48.             "[save_mri_ipb_3d] error writing data (2)!\n" );
  49.  gzclose(f_img);
  50.  FREE(buffchar);
  51.  return 0;
  52.     }
  53. }
  54. gzflush(f_img, Z_SYNC_FLUSH);
  56. break;
  58.     case sizeof(short):
  59. buffshort = CALLOC(num_items,short);
  60. if(buffshort == NULL) {
  61.     PUT_ERROR(
  62.             "[save_mri_ipb_3d] memory allocation error (4)!\n" );
  63.     gzclose(f_img);
  64.  FREE(buffshort);
  65.     return 0;
  66. }
  67. buffer = buffshort;
  69. for(j=0; j<graphic->height; j++)
  70. {
  71.     buffshort = buffer;
  73.  for(k=0; k<graphic->depth; k++)
  74.  for(i=0; i<graphic->width; i++)
  75.      if (!_is_bigEndian) *buffshort ++ = graphic->mri[i][graphic->height-j-1][graphic->depth-k-1];
  76.   else *buffshort ++ = shEndianConversion(graphic->mri[i][graphic->height-j-1][graphic->depth-k-1]);
  78.     if(gzwrite(f_img, (void *)buffer, data_size * num_items) / data_size != num_items) {
  79.  PUT_ERROR(
  80.             "[save_mri_ipb_3d] error writing data (4)!\n" );
  81.  gzclose(f_img);
  82.  FREE(buffshort);
  83.  return 0;
  84.     }
  85. }
  86. gzflush(f_img, Z_SYNC_FLUSH);
  88. break;
  90.     case sizeof(long):
  91. bufflong = CALLOC(num_items*2,long);
  92. if(bufflong == NULL) {
  93.     PUT_ERROR(
  94.         "[save_mri_ipb_3d] memory allocation error (6)!\n" );
  95.     gzclose(f_img);
  96.  FREE(bufflong);
  97.     return 0;
  98. }
  100. buffer = bufflong;
  102. for(j=0; j<graphic->height; j++)
  103. {
  104.     bufflong = buffer;
  106.  for(k=0; k<graphic->depth; k++)
  107.  for(i=0; i<graphic->width; i++)
  108.      if (!_is_bigEndian) *bufflong ++ = graphic->mri[i][graphic->height-j-1][graphic->depth-k-1];
  109.   else *bufflong ++ = longEndianConversion(graphic->mri[i][graphic->height-j-1][graphic->depth-k-1]);
  111.     if(gzwrite(f_img, (void *)buffer, data_size * num_items) / data_size != num_items) {
  112.  PUT_ERROR(
  113.            "[save_mri_ipb_3d] error writing data (6)!\n" );
  114.  gzclose(f_img);
  115.  FREE(bufflong);
  116.  return 0;
  117.     }
  118. }
  119. gzflush(f_img, Z_SYNC_FLUSH);
  121. break;
  123.     default:
  124. PUT_ERROR(
  125.          "[save_mri_ipb_3d] invalid data size\n" );
  127. return 0;
  128.     }
  129.     FREE(buffer);
  131.     return 1;
  132. }


 
Le paramètre graphic est la structure contenant les données importantes sur l'image comme les dimensions (width, height, depth) ainsi que le nombre de bits par pixel (bitppixel) que l'on divise par 8 pour connaître le type de données et enregistrer les niveaux de gris (champ mri) en conséquence.
 
Ce même code enregistre sans aucun problème les données en utilisant les primitives fopen, fwrite, etc...
 
Merci à qui me répondra  :)


Message édité par atharendil le 06-06-2006 à 10:29:32
Reply

Marsh Posté le 02-06-2006 à 11:18:50   

Reply

Marsh Posté le 06-06-2006 à 10:29:50    

up !

Reply

Marsh Posté le 08-06-2006 à 16:45:40    

kk c'est bien compliqué tout ça...
 
En gros, tu ne devrai pas avoir de problème à passer d'un fread/fwrite à un fichier compressé avec zLib.
 
Vérifie d'abord que tu utilise les bonnes fonctions de la librarie, car il y a tout un tas de trucs pas forcément necessaire dans zLib, comme le flush à mon avis.
 
Ensuite, à vue de nez, il est certainement possible que ce décalage soit dû au header de ton image. Vérifie que les fonctions load() et write() lisent et écrivent exactement le même header, avec les mêmes champs, le même nombre d'octets, etc... et que tes appels de fonctions zLib n'interfèrent pas (vire les trucs inutiles).

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed