j'ai un probleme pour lire les bmp sous visual C++

j'ai un probleme pour lire les bmp sous visual C++ - Programmation

Marsh Posté le 23-03-2001 à 19:45:12    

J'ai fais une fonction pour copier des bmp de 320*240*24 bpp NON COMPRESSES
dans cette fonction, je copie les deux entetes, puis je fais une boucle pour recupérer dans un tableau chaque pixel :
palette tab[320][240]; // structure de 3 unsigned char
for(int j = 0;j < 240; j++)
{
  for(int i = 0; i < 320; i++)
  {
     fread(&tab[i][j],sizeof(tab[i][j]),1,F); // F = fichier
                                              //     source
     fwrite(&tab[i][j],sizeof(tab[i][j],1,P); // destination
  }
}
ca parait bete, mais ca marche pour les bmp créés sous paint, mais pas sous photoshop ou les autres logiciel,(il n'y a aucune compression qui n'intervient) la copie obtenue n'est pas complete, je n'obtient que les 1/4 du bas de l'image
Je comprend pas peut on m'aidr ?

Reply

Marsh Posté le 23-03-2001 à 19:45:12   

Reply

Marsh Posté le 23-03-2001 à 20:03:05    

tu démarré le chargement à un offset fixe, ou par rapport aux infos du header ????? (y a ptet une palette optionnelle ???, t'as zieuté le MSDN pour voir tous les cas de figure)

Reply

Marsh Posté le 23-03-2001 à 20:48:00    

attention, il y a une magouille. En fait chaque ligne d'une fichier bmp a une longueur qui doit etre un multiple de 4. si la ligne : "BVRBVRBVRBVRBVR" fait 15 octets donc il y a un octet qui sera ajouté à la fin.
 
mais bon normalement c'est bon puisque 320*3/4=240 donc y'a rien a ajouter.
 
c'est louche ton histoire

Reply

Marsh Posté le 24-03-2001 à 00:17:26    

ce qui est plus louche c'est que le fichier crée avec paint et l'autre avec photoshop ont la meme taille à 2 octets près, je comprend pas...

Reply

Marsh Posté le 24-03-2001 à 11:28:07    

Et alors, qu'est-ce que tu as contre paint, c'est bien et ca permet de faire de belle image paint
(beeuuuuuuaaaaaaaarrrrrrrrrrrrrrrrrrrrrkkkkkk)

Reply

Marsh Posté le 24-03-2001 à 12:01:50    

c'est bizarre ton histoire, je te file les fonctions que j'utilise et qui marche. L'image chargé zst enregistré dans un tampon au format OpenGL RGBA.
 
chargement :
 
// -----------------------------------------------------------------------------
// charge les textures en mémoire à partir de fichiers bmp 24bits non compressés dans Texture_TMP qui est une variable globale
// retourne 1 ou 0
int Load_BMP_Ex(char* nom_fichier) {
 // Fichier bmp non compressé 24bits
  FILE*         fichier;
  unsigned char entete[54];
  int         position_donnees=0;
  int           nb_pixels=0;
  int           taille_donnees_24=0;
  int           taille_donnees_32=0;
  int           taille_donnees_fichier=0;
  int           complement=0;
  GLubyte*      Image_TMP=(GLubyte*)NULL; // image de la texture en chargement
 
 // Ouverture du fichier
  fichier = fopen(nom_fichier,"rb" );
  if (fichier==(FILE*)NULL) {
    return(0);
    }
 
 // Lit l'entete du fichier
  fseek(fichier,0,0);
  if (fread(entete,1,54,fichier)!=54) {
    return(0);
    }
  if (entete[0]!='B' || entete[1]!='M') {
    return(0);
    }
 
 // Récupère les infos de l'image
  largeur_texture = entete[21]<<24 | entete[20]<<16 | entete[19]<<8 | entete[18];
  hauteur_texture = entete[25]<<24 | entete[24]<<16 | entete[23]<<8 | entete[22];
 
  nb_pixels=largeur_texture*hauteur_texture;
  taille_donnees_24=nb_pixels*3;
  taille_donnees_32=nb_pixels*4;
  taille_donnees_fichier=largeur_texture*3;
  complement=taille_donnees_fichier & 3;
  if (complement>0) {
    complement=4-complement;
    taille_donnees_fichier=taille_donnees_fichier + complement; // pour une ligne
    }
  taille_donnees_fichier=taille_donnees_fichier * hauteur_texture; // pour toutes les lignes
 
  position_donnees=54;
 
 // Charge l'image
  if (Image_TMP!=(GLubyte*)NULL) {
    free(Image_TMP);
    }
  if (Image_TMP!=(GLubyte*)NULL) {
    return(0);
    }
  Image_TMP=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_24);
  if (Image_TMP==(GLubyte*)NULL) {
    return(0);
    }
 
  fseek(fichier,position_donnees,0);
  if (fread(Image_TMP,1,taille_donnees_24,fichier)!=taille_donnees_24) {
    free(Image_TMP);
    fclose(fichier);
    return(0);
    }
 
  fclose(fichier);
 
 // prépare la texture [tampon]
  if (Texture_TMP!=(GLubyte*)NULL) {
    free(Texture_TMP);
 Texture_TMP=(GLubyte*)NULL;
    }
 // free ne fonctionne pas !!!
  if (Texture_TMP!=(GLubyte*)NULL) {
    return(0);
    }
  Texture_TMP=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_32);
  if (Texture_TMP==(GLubyte*)NULL) {
    return(0);
    }
 
 // transfert du format bmp au rgba : BGR -> RGBA
 // attention chaque ligne du fichier bmp a une longueur multiple de 4
 // si ce n'est pas le cas de l'image des octets sont ajoutés en fin
  int taille_ligne=(largeur_texture*3)+complement;
  int position_TMP=taille_ligne*(hauteur_texture-1); // dernière ligne
  int position=0;
  int position_pixels=0;
  int nb_ligne=2;
 
  for (int i=0;i<nb_pixels;i++) {
    Texture_TMP[position  ]=Image_TMP[position_TMP+2];
    Texture_TMP[position+1]=Image_TMP[position_TMP+1];
    Texture_TMP[position+2]=Image_TMP[position_TMP  ];
    Texture_TMP[position+3]=255;
    position=position+4;
    position_TMP=position_TMP+3;
    position_pixels++;
    if (position_pixels>=largeur_texture) {
      position_TMP=taille_ligne*(hauteur_texture-nb_ligne);
      nb_ligne++;
      position_pixels=0;
      }
    }
 
 // fin
  free(Image_TMP);
  return(1);
}
// -----------------------------------------------------------------------------
 
sauvegarde :
 
// -----------------------------------------------------------------------------
// Enregistre une image dans un fichier : format bmp
int Save_BMP_Ex(char* nom_fichier,int largeur,int hauteur,GLubyte* mem) {
 // Fichier bmp non compressé 24bits
  FILE*         fichier;
  int           position_tampon=54;
  int           position_image=0;
  int           taille_donnees_fichier=0;
  int           complement=0;
  GLubyte*      tampon=(GLubyte*)NULL;
 
 // initialisation des données
  complement=(largeur*3)%4;
  if (complement>0) {
    complement=4-complement;
    }
  taille_donnees_fichier=54+((largeur*3)+complement)*hauteur;
 
 // création du tampon
  tampon=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_fichier);
  if (tampon==(GLubyte*)NULL) {
    return(0);
    }
 
 // remlissage du tampon
 // entete
  tampon[ 0]='B';
  tampon[ 1]='M';
 // taille du fichier
  tampon[ 2]=taille_donnees_fichier & 255;
  tampon[ 3]=(taille_donnees_fichier >> 8) & 255;
  tampon[ 4]=(taille_donnees_fichier >> 16) & 255;
  tampon[ 5]=(taille_donnees_fichier >> 24) & 255;
 // inutilisé
  tampon[ 6]=0;
  tampon[ 7]=0;
  tampon[ 8]=0;
  tampon[ 9]=0;
 // adresse des données
  tampon[10]=54;
  tampon[11]=0;
  tampon[12]=0;
  tampon[13]=0;
 // taille de l'entete
  tampon[14]=40;
  tampon[15]=0;
  tampon[16]=0;
  tampon[17]=0;
 // taille image : largeur et hauteur
  tampon[18]=largeur & 255;
  tampon[19]=(largeur >> 8) & 255;
  tampon[20]=(largeur >> 16) & 255;
  tampon[21]=(largeur >> 24) & 255;
  tampon[22]=hauteur & 255;
  tampon[23]=(hauteur >> 8) & 255;
  tampon[24]=(hauteur >> 16) & 255;
  tampon[25]=(hauteur >> 24) & 255;
 // nombre de plan
  tampon[26]=1;
  tampon[27]=0;
 // nombre de couleur
  tampon[28]=24; // 24 bits
  tampon[29]=0;
 // format de compression (aucune=0)
  tampon[30]=0;
  tampon[31]=0;
  tampon[32]=0;
  tampon[33]=0;
 // taille de l'image : ta mère
  tampon[34]=0;
  tampon[35]=0;
  tampon[36]=0;
  tampon[37]=0;
 // resolution horizontale : 2834ppm
  tampon[38]=18;
  tampon[39]=11;
  tampon[40]=0;
  tampon[41]=0;
 // resolution verticale : 2834ppm
  tampon[42]=18;
  tampon[43]=11;
  tampon[44]=0;
  tampon[45]=0;
 // nombre de couleurs utilisées : ?
  tampon[46]=0;
  tampon[47]=0;
  tampon[48]=0;
  tampon[49]=0;
 // nombre de couleurs importantes : ?
  tampon[50]=0;
  tampon[51]=0;
  tampon[52]=0;
  tampon[53]=0;
 // image
  for (int i=0;i<hauteur;i++) {
    for (int j=0;j<largeur;j++) {
      tampon[position_tampon  ]=mem[position_image+2];
      tampon[position_tampon+1]=mem[position_image+1];
      tampon[position_tampon+2]=mem[position_image  ];
      position_tampon=position_tampon+3;
      position_image=position_image+3;
      }
    position_tampon=position_tampon+complement;
    }
 
 // Ouverture du fichier
  fichier = fopen(nom_fichier,"wb" );
  if (fichier==(FILE*)NULL) {
    free(tampon);
    return(0);
    }
 
 // Ecriture du fichier
  fseek(fichier,0,0);
  if (fwrite(tampon,1,taille_donnees_fichier,fichier)!=taille_donnees_fichier) {
    free(tampon);
    return(0);
    }
 
 // fin
  free(tampon);
  fclose(fichier);
  return(1);
}
//------------------------------------------------------------------------------
 
voila ca ca marche j'ai testé

Reply

Marsh Posté le 24-03-2001 à 21:21:19    

http://philgauthier.free.fr/filtre.zip
J'ai fais une fonction qui lit les bmp 24bits noncompressé.
Attention suivant les dimentions de l'image, il y a un nombre variable d'octets qui délimitent les lignes varie, ce qui produit un décalage à chaque ligne si on en tient pas compte.
T'as qu'a tester mon prog sur les 2 images voir s'il y a le même bug. Si mon prog marche correct tu regardes les sources.


---------------
http://www.cheata.net le site qui vous donne la banane!
Reply

Sujets relatifs:

Leave a Replay

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