Discussion :

[eagl1]

Bonjour a tous,
apres une petite recherche, je ne trouve toujours pas ce que je recherche exactement, pourtant il doit y avoir pas mal de discussion la dessus.

J'ai une liste de donnees (que je peux tres bien convertir en tableau ou en matrice, pour ca pas de probleme), et je voudrai creer une image BMP en 256 couleurs a partir de ces donnees.

Connaissez vous un endroit ou je pourrai trouver des renseignements sur ce sujet (creation de BMP en C++)?
Je ne recherche ni a l'afficher ni travailler dessus. Donc en fait je voudrai eviter d'utiliser des grosses librairies avec what mille classes, je voudrais juste trouver une simple classe qui cree un BMP si cela est possible.

Merci de votre temps,
Bien cordialement
Eagl.

[loufoque]

Un BMP c'est trivial comme format.
Tu as une entête tout bête qui indique la palette utilisée etc., la taille de l'image, puis ensuite les données.

[eagl1]

Bonsoir loufoque,
Et serais tu ou je peux trouver des infos sur ce sujet?
comme des Explications du format BMP et/ou trouver des methodes d'ecriture pour le creer (a partir d'une liste/tableau de byte/entier par exemple).
car partout ou je cherche, je trouve les explications vraiment pas clair.

Eagl

[LittleWhite]

Ce qu'il te faut pour le BMP , c'est juste connaitre le format, et après tu fait ta fonction pour réecrire un fichier correct , qui sera donc un BMP.

Tu as un peu de chance , mais j'ai un prof qui m'a passé aujourd'hui la description du format ( simple , mais en anlglais )...
http://www.gamedev.net/reference/art...rticle1966.asp

Certes il explique l'ouverture , mais la sauvegarde est très similaire ( juste que c'est que les opération dans l'autre sens , au lieu de lire , tu ecrit )

Au sinon une recherche sur google , pour avoir un truc comme ça en français

[3DArchi]

Par exemple, ici ou là.

[Médinoc]

Et aussi ici, en complément de l'autre page de MSDN.

[eagl1]

Merci beaucoup a vous tous,
Les deux premiers liens ont l'air interessants.
Apres, pour la MSDN, C'est le premier lieu ou je regarde tout le temps, mais j'y comprends que tres rarement, c'est un peu brut comme donnees et pas tres pedagogue je trouve.
Je vais donc etudier tout ca,
merci encore pour les reponses,
A la votre ^^

[eagl1]

Re everyone, ^^
apres de petites recherches, je vais mettre une solution qui marche ci dessous (pour ceux a qui ca interessent). Cependant j'aurais une remarque et une question a faire apres l'affichage du code.

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
 
void MaClass::Create_Save_BMP()  {
    int x=0;
    int iWidth = 256;
    int iHeight = 256;
    HANDLE file;
    BITMAPFILEHEADER fileHeader;
    BITMAPINFOHEADER fileInfo;
    RGBTRIPLE image;
    DWORD write = 0;
 
    file = CreateFile("examplea.bmp",GENERIC_WRITE,0,NULL,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
    fileHeader.bfType = 19778;
    fileHeader.bfSize = sizeof(fileHeader.bfOffBits) + sizeof(RGBTRIPLE);
    fileHeader.bfReserved1 = 0;
    fileHeader.bfReserved2 = 0;
    fileHeader.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
 
    fileInfo.biSize = sizeof(BITMAPINFOHEADER);
    fileInfo.biWidth = iWidth;
    fileInfo.biHeight = iHeight;
    fileInfo.biPlanes = 1;
    fileInfo.biBitCount = 24;
    fileInfo.biCompression = BI_RGB;
    fileInfo.biSizeImage = 0;
    fileInfo.biXPelsPerMeter = 0;
    fileInfo.biYPelsPerMeter = 0;
    fileInfo.biClrImportant = 0;
    fileInfo.biClrUsed = 0;
 
    WriteFile(file,&fileHeader,sizeof(fileHeader),&write,NULL);
    WriteFile(file,&fileInfo,sizeof(fileInfo),&write,NULL);
 
    for (int i = 0; i < (iWidth*iHeight); i++)
    {
        if (i <= iWidth*iHeight/2-1)
           { x=254;}
        else {x=5;}
        image.rgbtBlue = x-1;
        image.rgbtGreen = x-1;
        image.rgbtRed = x-1;
        WriteFile(file, &image, sizeof(RGBTRIPLE), &write, NULL);
    }
    CloseHandle(file);
}

Resultat : image de 256*256px moitie noire (en haut) moitie blanche (en bas)

Remarque : Ce code fonctionne pour creer des images BMP avec des pixels codes sur 24 bits

Ma question est la suivante: quelqu'un saurait il comment modifier ce code pour creer des images ou les pixels sont codes sur 8 bits (soit 256 niveaux de gris).
J'ai beau ecrire des choses tel que

Code :

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

fileInfo.biBitCount = 8;

et/ou

Code :

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

fileInfo.biClrUsed = 256;

et/ou

Code :

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

fileInfo.biClrImportant = 256;

et/ou remplacer la structure RGBTRIPLE par RGBQUAD (avec les bons parametres)

Rien ne fonctionne,
J'ai meme essayer de remplacer la structure RGBTRIPLE par une que je cree avec un seul parametre pour avoir une structure de 8bits au lieu de 24bit pour RGBTRIPLE, cela ne marche pas non plus.

J'avoue avoir utilise toutes mes resources, donc si quelqu'un peu m'aider, cela serait vraiment cool.

PS1: dsl pour les accents, en qwerty je suis, ^^
PS2: la solution de mettre la meme valeure au roug au vert et au bleu ne me convient pas, il me faut vraiment en 256 niveau de gris.

Pour les courageux qui ont tout lu, merci bcp de votre temps.

[Twindruff]

En 256 couleurs le format bmp utilise une palette.
Faut que tu regardes les specifications du format dans ce cas précis.

Sinon tu pourrais aussi utiliser GDI+ qui est bien pratique. En GDI+ tu peux utiliser la classe Bitmap et utiliser le format de pixel PixelFormat8bppIndexed ensuite tu utilises la méthode Save avec l'encodeur de bmp.

Par contre GDI+ existe que sur Windows XP ou supérieur.

[loufoque]

Le plus simple c'est le RGB, trois octets par pixel, un par couleur.

[Twindruff]

Le plus simple c'est le RGB, trois octets par pixel, un par couleur.

oui mais

PS2: la solution de mettre la meme valeure au roug au vert et au bleu ne me convient pas, il me faut vraiment en 256 niveau de gris.

[eagl1]

Merci Twindruff,
Petit 1 pour ta derniere remarque, cela m'evite de la faire, ^^.
(no offense loufoque, mais tes reponses ne sont pas d'une grande aide)
Petit 2 pour ton indication sur la palette.
Effectivement, je ne l'avais pas encore poste, mais en creant des images avec notre cher vieux paint, je me suis appercu qu'il y a des informations entre l'entete et les donnes des pixels (pour des BMP sauvegarde en 256 couleurs), Je me suis donc demande si c'etait la palette de couleurs: donc merci de confirmer.
Donc par la suite j'ai un peu etudie cela et effectivement, on a 256 couleurs, 3 octets de codage par couleur + 1 octet de separaption a chaque fois (Je parle pour la palette hein), ce qui nous fais 1024 octets (ou bytes si vous preferez, c'est du meme au meme). Ce qui correspond exactement a la longueur de cette palette entre l'entete et les pixels (J'ai compte 1024 mots hexadecimaux genre "3f").

Pour ceux a qui cela interessent, je suis en train de faire un ti truc un peu bourin, mais je pense que cela marchera. Si ca marche je posterai le code et qlq explications sur cette palette que je viens de comprendre (du moins je pense ^^).

ciao et ++

[Médinoc]

Fichier .bmp : 2 en-têtes (BITMAPFILEHEADER et BITMAPINFOHEADER), une palette (tableau de RGBQUAD), puis les données.
Attention aussi à l'offset dans la structure BITMAPFILEHEADER : Il m'est arrivé de voir un programme qui le réglait mal.

À ma connaissance, il n'existe pas de pur format "niveaux de gris 8 bits" en .bmp : Il s'agit bêtement d'une image 256 couleurs avec une palette "grise" (couleurs #000000, #010101, #020202, ..., #FEFEFE, #FFFFFF).

[eagl1]

Salut tout le monde,
Bon je vais mettre le fruit de mes recherches a contribution pour expliquer les choses que je n’avais pas compris au debut pour les novices comme moi qui pourraient avoir besoin de ca par la suite.
Tout d’abord, merci Medinoc, tu m’aurais dit ca il y a 3 jours, j’avoue que je n’aurais pas forcement compris, mais puisque depuis je me suis mis un peu dans le sujet, ben je confirme tout ce que tu as dit.

Donc effectivement, dans un BMP on a :

2 en-têtes (BITMAPFILEHEADER et BITMAPINFOHEADER), une palette (tableau de RGBQUAD), puis les données.

Au debut j’ai eu du mal sur les tailles que l’on trouve dans les entetes et sur l’offset, donc petite explication:
Dans BITMAPFILEHEADER on trouve
- bfSize qui est la taille globale de TOUT le fichier (taille de l’offset (bfOffBits) + taille des donnees des pixels (hauteur * largeur (* 3 si les pixels sont code en RGB donc sur 3 bytes)))
- bfOffBits qui est la taille des 2 entetes + la taille de la palette des couleurs utilisees SI elle existe.
Exemple : Pour une BMP sans palette, la taille de l’offset sera de 54 bytes (14+40) , pour une BMP avec une palette de 256 couleurs, la taille sera de 1078 bytes (14+40+1024).

Dans BITMAPINFOHEADER on trouve
- biSize qui est la taille de cette deuxieme entete (cela devrait etre 40 tout le temps si je ne m’abuse)
- biSizeImage qui est la taille des donnees representant les pixels (hauteur * largeur (* 3 si les pixels sont code en RGB donc sur 3 bytes)).
Dans le cas ou nous sommes en 8 bits, Les pixels ne seront code que sur 1 byte, donc la multiplication par 3 n’existera pas (dans le code vous verrez un 1 pour le mettre en valeur)

Parlons maintenant de la palette de couleurs.
Lorsque nous n’avons pas de palette, le codage des pixels commence directement au premier byte derriere les entetes (sur 3 bytes a chaque fois : R, G et B). Lorsque la palette existe, elle s’incruste entre la 2iem entete et les donnees des pixels de la facon qui suit.
Le premier byte derriere les entete correspond a la composante rouge de la premier couleur utilisee, Le deuxieme byte correspond a la composante verte et le troisieme a la composante bleu. Le quatrieme byte (generalement egal a 0, doit certainement etre le parametre rgbreserved de la structure RGBQUAD, mais je ne suis pas sure).
(dans un cas d’une palette de 256 couleurs, cette premiere couleur definie, quel qu’elle soit, sera code par le chiffre 0, sur une echelle de 0 a 255, (soit 00 en hexa, pour le byte representant le pixel qui est code sur un seul byte))
On continu …, le cinquieme byte correspond a la composante rouge de la deuxieme couleurs utilisee. Etc etc etc … cette deuxieme couleur, quel qu’elle soit, sera code par 1 (soit 01 en hexa).


Je vous place mon code qui fonctionne pour les interesses. Je precise que je n’ai pas utilise les structures BITMAPFILEHEADER, BITMAPINFOHEADER pour les entetes et RGBQUAD pour les pixels, mais les variables ecrites representent exactement la meme chose. Pourquoi ? car je ne savais pas comment utiliser RGBQUAD pour créer ma palette et par la suite utiliser seulement un byte pour le codage d’un pixel. J’ai donc tout fait un peu brutalement.
Je precise aussi que ce code est pour une image BMP, 8bits (en 256 couleurs), avec une une taille de 256*256px. La palette de couleurs creee represente les niveau de gris (soit 256 niveaux de gris).
Ce code est un peu bourrin mais il marche :

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
void MaClasse::CreateAndSaveBMP()
{
    ofstream bmpfile;
    bmpfile.open("example.bmp", ios::out | ios::binary | ios::trunc);
    if(!bmpfile.is_open())
    {
        cout << "ERROR: FILE COULD NOT BE OPENED" << endl;
        return ;
    }
    CreateHeader(bmpfile);
    CreatePalette(bmpfile);
    CreatePixel(bmpfile);
    bmpfile.close();
}
 
void MaClasse::CreateHeader(ofstream &bfile)
{
    int width = 256;                        //will be coded with 4 bytes
    int height = 256;                       //... 4 bytes
 
    int Type = 19778;                       //... 2 bytes
    int fSize = (width*height*1)+40+14+1024;  //... 4 bytes
    int Reserved1 = 0;                      //... 2 bytes
    int Reserved2 = 0;                      //... 2 bytes
    int Offset = 40+14+1024;                //... 4 bytes
 
    int hSize = 40;                         //... 4 bytes
    int nbPlane = 1;                        //... 2 bytes
    int nBPP = 8;                           //... 2 bytes
    int Compression = 0;                    //... 4 bytes
    int iSize = width*height*1;             //... 4 bytes
    int ResoX = 0;                          //... 4 bytes
    int ResoY = 0;                          //... 4 bytes
    int clrUsd = 256;                       //... 4 bytes
    int clrImp = 0;                         //... 4 bytes
 
    bfile.write((char*)&Type, 2);
    bfile.write((char*)&fSize, 4);
    bfile.write((char*)&Reserved1, 2);
    bfile.write((char*)&Reserved2, 2);
    bfile.write((char*)&Offset, 4);
    bfile.write((char*)&hSize, 4);
    bfile.write((char*)&width, 4);
    bfile.write((char*)&height, 4);
    bfile.write((char*)&nbPlane, 2);
    bfile.write((char*)&nBPP, 2);
    bfile.write((char*)&Compression, 4);
    bfile.write((char*)&iSize, 4);
    bfile.write((char*)&ResoX, 4);
    bfile.write((char*)&ResoY, 4);
    bfile.write((char*)&clrUsd, 4);
    bfile.write((char*)&clrImp, 4);
}
 
void MaClasse::CreatePalette(ofstream &bfile)
{
    int TabPalette[1024];
    int i=0;
    for (int x=0;x<256;x++)
    {
        TabPalette[i]=x;
        i++;
        TabPalette[i]=x;
        i++;
        TabPalette[i]=x;
        i++;
        TabPalette[i]=0;
        i++;
    }
    for (int x=0;x<1024;x++)
    {
        bfile.write((char*)&TabPalette[x], 1);
    }
}
 
void MaClasse::CreatePixel(ofstream &bfile)
{
    int white = 255;
    int black = 0;
    for (int i=0;i<256*256;i++)
    {
        if ((i % 2) == 0)
            bfile.write((char*)&white, 1);
        else
            bfile.write((char*)&black, 1);
    }
}

Resultat : Image BMP 256*256 en 8 bits et en 256 niveaux de gris, colonnes de pixels paires blanches, colonnes de pixels impaires noires.

PS : Si vous trouvez des trucs faux, n'hesitez pas a me le faire remarquer
PS2 : Merci a tous pour vos interventions.

Eagl

[loufoque]

Toutes ces informations ne sont pas clairement définies dans la spécification, qu'on t'a dite de lire dès le début ?

[eagl1]

Et bien pour les differentes tailles, si, sur ce lien, c'est bien dit
http://www.gamedev.net/reference/art...rticle1966.asp
Mais j'ai prefere le repreciser pour les gens qui ne parlent pas trop anglais.

En ce qui concernait la creation de la palette, pas trop, je trouve que c'etait un peu flou.
Enfin bref, maintenant c'est tout bon. ^^