Discussion :

[tamar_a_roulettes]

bonjour,

je sèche depuis un bon bout de temps:
j'ai une application qui fait du tracé vectoriel en utilisant moins de 256 couleurs.
Je désire faire une bitmap 8 bits correspondant à ce tracé avec GDI.
Quand je crée un DC et une bitmap compatible , j'obtiens bien une bitmap correspondant à la zone écran que je veut capturer, mais de base en 32 bit ! ...
Comment puis-je faire (sans changer les caractéristiques de mon écran) pour faire une "capture" 8 bits de mon tracé dans une bitmap ?

Merci.

[Mat.M]

bonjour,
Je désire faire une bitmap 8 bits correspondant à ce tracé avec GDI.
Quand je crée un DC et une bitmap compatible , j'obtiens bien une bitmap correspondant à la zone écran que je veut capturer, mais de base en 32 bit ! ...
Merci.

La Bitmap a l'écran sera toujours de 32bits ( ou bien la résolution du panneau de config ).
Même si la bitmap est formattée à 8bits le GDI la cuisine pour l'afficher en 16 ou 32 bits
On ne peut la porter à 8bits qu'une fois enregistrée sur disque.
Il faut jouer avec les BITMAPINFOHEADER et créer une LOGPALETTE associée.
Voir le MSDN
Pour la enieme fois je mets le lien
http://msdn.microsoft.com/library/de...tmaps_7zfp.asp

[Médinoc]

Je n'ai rien sous la main pour un bitmap 8 bits, mais j'avais une fonction qui crée un bitmap 4 bits en forçant sa palette (ça, tu n'en as pas besoin, tu peux piquer la palette 8bits d'un autre DC, généralement). Pour la création de ton bitmap 8bits, tu peux t'en inspirer...

Le code était dans un .cpp, mais cela pourrait bien être du C, en fait, honte sur moi

Code C :

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
/* Function to create a 16-Color DIB with standard VGA colors
   ---------------------------------------------------------- */
HBITMAP CreateStandard16ColorDIB(
 int const xSize,	//[in] width
 int const ySize,	//[in] height
 LPVOID * const pt_pt_bits	//[out] receives a pointer to the bitmap binary data
 )
{
HBITMAP hBmpReturn = NULL;	//[out] handle to the newly created bitmap
 
//Bitmap info for creation
char bufBmpInfo[sizeof(BITMAPINFOHEADER)+16*sizeof(RGBQUAD)];
PBITMAPINFO const pbmi = (PBITMAPINFO)bufBmpInfo;
RGBQUAD * const pClr = pbmi->bmiColors;
 
//Initialize the BITMAPINFO struct
ZeroMemory(pbmi, sizeof(BITMAPINFOHEADER)+16*sizeof(RGBQUAD));
 
pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
pbmi->bmiHeader.biBitCount = 4;	//4 bit/pixel (16 colors)
pbmi->bmiHeader.biClrImportant = 0;	//use all colors
pbmi->bmiHeader.biClrUsed = 0;	//use all colors
pbmi->bmiHeader.biCompression = BI_RGB;	//No compression
pbmi->bmiHeader.biHeight = ySize;	//bitmap height
pbmi->bmiHeader.biPlanes = 1;	//Aways 1 plane for DIBs
pbmi->bmiHeader.biSizeImage = 0;
pbmi->bmiHeader.biWidth = xSize;	//bitmap width
pbmi->bmiHeader.biXPelsPerMeter = 0;
pbmi->bmiHeader.biYPelsPerMeter = 0;
 
//Fill the DIB color palette with the 16 standard VGA colors
pClr[ 0].rgbRed=  0 ; pClr[ 0].rgbGreen=  0 ; pClr[ 0].rgbBlue=  0;	//Black       #000000
pClr[ 1].rgbRed=  0 ; pClr[ 1].rgbGreen=  0 ; pClr[ 1].rgbBlue=128;	//Blue        #000080
pClr[ 2].rgbRed=  0 ; pClr[ 2].rgbGreen=128 ; pClr[ 2].rgbBlue=  0;	//Green       #008000
pClr[ 3].rgbRed=  0 ; pClr[ 3].rgbGreen=128 ; pClr[ 3].rgbBlue=128;	//Cyan        #008080
pClr[ 4].rgbRed=128 ; pClr[ 4].rgbGreen=  0 ; pClr[ 4].rgbBlue=  0;	//Red         #800000
pClr[ 5].rgbRed=128 ; pClr[ 5].rgbGreen=  0 ; pClr[ 5].rgbBlue=128;	//Magenta     #800080
pClr[ 6].rgbRed=128 ; pClr[ 6].rgbGreen=128 ; pClr[ 6].rgbBlue=  0;	//Yellow/Brown#808000
pClr[ 7].rgbRed=192 ; pClr[ 7].rgbGreen=192 ; pClr[ 7].rgbBlue=192;	//Light Grey  #C0C0C0
pClr[ 8].rgbRed=128 ; pClr[ 8].rgbGreen=128 ; pClr[ 8].rgbBlue=128;	//Dark Grey     #808080
pClr[ 9].rgbRed=  0 ; pClr[ 9].rgbGreen=  0 ; pClr[ 9].rgbBlue=255;	//Bright Blue   #0000FF
pClr[10].rgbRed=  0 ; pClr[10].rgbGreen=255 ; pClr[10].rgbBlue=  0;	//Bright Green  #00FF00
pClr[11].rgbRed=  0 ; pClr[11].rgbGreen=255 ; pClr[11].rgbBlue=255;	//Bright Cyan   #00FFFF
pClr[12].rgbRed=255 ; pClr[12].rgbGreen=  0 ; pClr[12].rgbBlue=  0;	//Bright Red    #FF0000
pClr[13].rgbRed=255 ; pClr[13].rgbGreen=  0 ; pClr[13].rgbBlue=255;	//Bright Magenta#FF00FF
pClr[14].rgbRed=255 ; pClr[14].rgbGreen=255 ; pClr[14].rgbBlue=  0;	//Bright Yellow #FFFF00
pClr[15].rgbRed=255 ; pClr[15].rgbGreen=255 ; pClr[15].rgbBlue=255;	//Bright White  #FFFFFF
 
//Create the DIB
hBmpReturn = CreateDIBSection(NULL, pbmi, DIB_RGB_COLORS, pt_pt_bits, NULL, 0);
return hBmpReturn;
}

Le bitmap créé n'est pas un "bitmap compatible" (alias "Device-Dependent Bitmap" ou DDB), mais un "Device-Independent Bitmap" (DIB) qui peut rentrer dans tout "DC Compatible"...

[tamar_a_roulettes]

bon, j'en retiens qu'il n'existe rien de simple.
par contre pour la palette de couleurs, comme je veux récupérer les couleurs exactes utilisées pour le tracé, je ne peux pas récupérer une palette d'unh DC standard, sinon, je pense que les couleurs déclarées pourront être différentes des couleurs réelles que mon appli utilise (il y en a une 50aine).
donc, si j'ai bien compris, je crée ma bitmap en 32 bits que j'enregistre sur le disque (ce que j'avais déjà !), puis je parcours l'ensemble des pixels: je crée un nouvel indice dans la palette à chaque nouvelle couleur trouvée... ça risque de prendre du temps pour la conversion, c'est pour ça que je ne l'avais pas fait de base, pensant que GDI offrait des services plus souples, mais bon, si 'faut le faire je le ferai.
Merci tout de même.

[Mat.M]

comme je veux récupérer les couleurs exactes utilisées pour le tracé, je ne peux pas récupérer une palette d'unh DC standard, sinon, je pense que les couleurs déclarées pourront être différentes des couleurs réelles que mon appli utilise (il y en a une 50aine).

Si cela doit être faisable en utilisant une LOGPALETTE et des API comme CreatePalette RealizePalette....
Regarder sur codeguru.com ou codeproject.com à tout hasard sinon le MSDN