Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
4882 connectés 

  FORUM HardWare.fr
  Programmation

  recherche un fonction pour enregistrer les bitmap

 
 


Dernière réponse
Sujet : recherche un fonction pour enregistrer les bitmap
juldjin je vais essayer,
mais & je sais po a quoi ça sert, je maitrise pas l'hexa, mais un jour je m'y mettrais

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse
[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 
Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
juldjin je vais essayer,
mais & je sais po a quoi ça sert, je maitrise pas l'hexa, mais un jour je m'y mettrais
gnoof Ton decalage ne me semble pas bon puisque lorsque la largeur est un multiple de 4 il doit valoir 0 et non pas 4.
tu peux ecrire par exemple:
decalage=(4-(largeur_image&3))&3;
juldjin je me suis encore gouré, decidément :
 
decalage = 4 - (largeur_image % 4);
darkoli y'a quoi dans la variable decalage au debut ?
 
voila ce que j'utilise pour enregistrer :
 

Code :
  1. // -----------------------------------------------------------------------------
  2. // Enregistre une image dans un fichier : format bmp
  3. int Save_BMP_Ex(char* nom_fichier,int largeur,int hauteur,GLubyte* mem) {
  4. // Fichier bmp non compressé 24bits
  5.   FILE*         fichier;
  6.   int           position_tampon=54;
  7.   int           position_image=0;
  8.   int           taille_donnees_fichier=0;
  9.   int           complement=0;
  10.   GLubyte*      tampon=(GLubyte*)NULL;
  12. // initialisation des données
  13.   complement=(largeur*3)%4;
  14.   if (complement>0) {
  15.     complement=4-complement;
  16.     }
  17.   taille_donnees_fichier=54+((largeur*3)+complement)*hauteur;
  19. // création du tampon
  20.   tampon=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_fichier);
  21.   if (tampon==(GLubyte*)NULL) {
  22.     return(0);
  23.     }
  25. // remlissage du tampon
  26. // entete
  27.   tampon[ 0]='B';
  28.   tampon[ 1]='M';
  29. // taille du fichier
  30.   tampon[ 2]=taille_donnees_fichier & 255;
  31.   tampon[ 3]=(taille_donnees_fichier >> 8) & 255;
  32.   tampon[ 4]=(taille_donnees_fichier >> 16) & 255;
  33.   tampon[ 5]=(taille_donnees_fichier >> 24) & 255;
  34. // inutilisé
  35.   tampon[ 6]=0;
  36.   tampon[ 7]=0;
  37.   tampon[ 8]=0;
  38.   tampon[ 9]=0;
  39. // adresse des données
  40.   tampon[10]=54;
  41.   tampon[11]=0;
  42.   tampon[12]=0;
  43.   tampon[13]=0;
  44. // taille de l'entete
  45.   tampon[14]=40;
  46.   tampon[15]=0;
  47.   tampon[16]=0;
  48.   tampon[17]=0;
  49. // taille image : largeur et hauteur
  50.   tampon[18]=largeur & 255;
  51.   tampon[19]=(largeur >> 8) & 255;
  52.   tampon[20]=(largeur >> 16) & 255;
  53.   tampon[21]=(largeur >> 24) & 255;
  54.   tampon[22]=hauteur & 255;
  55.   tampon[23]=(hauteur >> 8) & 255;
  56.   tampon[24]=(hauteur >> 16) & 255;
  57.   tampon[25]=(hauteur >> 24) & 255;
  58. // nombre de plan
  59.   tampon[26]=1;
  60.   tampon[27]=0;
  61. // nombre de couleur
  62.   tampon[28]=24; // 24 bits
  63.   tampon[29]=0;
  64. // format de compression (aucune=0)
  65.   tampon[30]=0;
  66.   tampon[31]=0;
  67.   tampon[32]=0;
  68.   tampon[33]=0;
  69. // taille de l'image : ta mère
  70.   tampon[34]=0;
  71.   tampon[35]=0;
  72.   tampon[36]=0;
  73.   tampon[37]=0;
  74. // resolution horizontale : 2834ppm
  75.   tampon[38]=18;
  76.   tampon[39]=11;
  77.   tampon[40]=0;
  78.   tampon[41]=0;
  79. // resolution verticale : 2834ppm
  80.   tampon[42]=18;
  81.   tampon[43]=11;
  82.   tampon[44]=0;
  83.   tampon[45]=0;
  84. // nombre de couleurs utilisées : ?
  85.   tampon[46]=0;
  86.   tampon[47]=0;
  87.   tampon[48]=0;
  88.   tampon[49]=0;
  89. // nombre de couleurs importantes : ?
  90.   tampon[50]=0;
  91.   tampon[51]=0;
  92.   tampon[52]=0;
  93.   tampon[53]=0;
  94. // image
  95.   for (int i=0;i<hauteur;i++) {
  96.     for (int j=0;j<largeur;j++) {
  97.       tampon[position_tampon  ]=mem[position_image+2];
  98.       tampon[position_tampon+1]=mem[position_image+1];
  99.       tampon[position_tampon+2]=mem[position_image  ];
  100.       position_tampon=position_tampon+3;
  101.       position_image=position_image+3;
  102.       }
  103.     position_tampon=position_tampon+complement;
  104.     }
  106. // Ouverture du fichier
  107.   fichier = fopen(nom_fichier,"wb" );
  108.   if (fichier==(FILE*)NULL) {
  109.     free(tampon);
  110.     return(0);
  111.     }
  113. // Ecriture du fichier
  114.   fseek(fichier,0,0);
  115.   if (fwrite(tampon,1,taille_donnees_fichier,fichier)!=taille_donnees_fichier) {
  116.     free(tampon);
  117.     return(0);
  118.     }
  120. // fin
  121.   free(tampon);
  122.   fclose(fichier);
  123.   return(1);
  124. }
  125. //------------------------------------------------------------------------------
juldjin je me suis trompé, c'est :
 
if(decalage < 4) lire...
juldjin ouais mais ca y est j'ai réussi, c'est pas facile mais bon :sarcastic:  
 
au faite, j'ai encore un soucis,  
j'arrive a lire tous les fichiers bmp non compressés et en 24 bits/pixels, mais certaines images me resistent, j'ai l'impression qu'il y a un decalage, et pourtant je tiens compte de l'arrondissement a chaque lignes en 4 octets (bon c'est du charabia,mais je pense qu'on s'est compris).
 
voila mon algorithme pour calculer le decalage :
 
decalage = 4 - (decalage % 4);
if(decalage > 0) lire....
 
ayudan me, por favor   :cry:
darkoli ben j'en ai fait une mais je ne l'ai pas ici.
 
Elle enregistre des fichier bmp au format 24bits non compressé uniquement.
juldjin j'arrive a lire sans pb les bmps,mais j'ai du mal a les enregistrer (sous VC++), si quelqu'un avait une fonction ou un site pour m'aider...

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)