Discussion :

[chronos]

D'abord je mexcuse au pret des admins je suis pas du tout sur d'etre au bon endroit, mais comme les gens d'ici font de l'image...

Alors voilà mon probleme, j'aimerai faire une copie de bitmap en memoie pour afficher :
Un qui n'est pas touché
Un qui est simplement tourné d'un angle X

Une copie simple peut ce faire comme ça (elle 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
HBITMAP CopyBitmap( HBITMAP hbm) {
    HDC hdcSrc = CreateCompatibleDC(NULL);
    HDC hdcDst = CreateCompatibleDC(NULL);
    HBITMAP hbmOld, hbmOld2, hbmNew;
    BITMAP bm;
    GetObject(hbm, sizeof(bm), &bm);
    hbmOld = SelectObject(hdcSrc, hbm);
    hbmNew = CreateBitmap( bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel,
            NULL);
    hbmOld2 = SelectObject(hdcDst, hbmNew);
    BitBlt(hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, SRCCOPY);
    SelectObject(hdcSrc, hbmOld);
    DeleteDC(hdcSrc);
    DeleteDC(hdcDst);
    return hbmNew;
}

le truc c'est que ce code me donne pas un acces "correcte" aux valeurs de pixels de l'image, alors pour avoir le controle total des pixels je fais une copie plus compliquée avec CreateDIBSection

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
88
89
90
91
92
HBITMAP CRotate::SimpleCopie(HDC hDC, HBITMAP hSourceBitmap)
{
	/*
	HDC hdcSrc = CreateCompatibleDC(NULL);
    HDC hdcDst = CreateCompatibleDC(NULL);
    HBITMAP hbmOld, hbmOld2, hbmNew;
    BITMAP bm;
    GetObject(hSourceBitmap, sizeof(bm), &bm);
    hbmOld = (HBITMAP) SelectObject(hdcSrc, hSourceBitmap);

    hbmNew = CreateBitmap( bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel,NULL);

    hbmOld2 = (HBITMAP) SelectObject(hdcDst, hbmNew);
    BitBlt(hdcDst, 0, 0, bm.bmWidth, bm.bmHeight, hdcSrc, 0, 0, SRCCOPY);
    SelectObject(hdcSrc, hbmOld);
    DeleteDC(hdcSrc);
    DeleteDC(hdcDst);
    return hbmNew;
	*/
	//2. Getting bimap size.
	BITMAP bm;
	GetObject(hSourceBitmap, sizeof(BITMAP), &bm);


	//3. Creating new bitmap and receive pointer to it's bits.
	HBITMAP hTargetBitmap;
	void *pBuffer;

	//3.1 Initilize DIBINFO structure
	BITMAPINFO bi = {0};
	bi.bmiHeader.biBitCount = 32;
	bi.bmiHeader.biClrImportant = 0;
	bi.bmiHeader.biClrUsed = 0;
	bi.bmiHeader.biCompression = 0;
	bi.bmiHeader.biHeight = bm.bmHeight;
	bi.bmiHeader.biPlanes = 1;
	bi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);;
	bi.bmiHeader.biSizeImage = bm.bmWidth*bm.bmHeight*3;
	bi.bmiHeader.biWidth = bm.bmWidth;
	bi.bmiHeader.biXPelsPerMeter = 3780;
	bi.bmiHeader.biYPelsPerMeter = 3780;
	bi.bmiColors[0].rgbBlue = 0;
	bi.bmiColors[0].rgbGreen = 0;
	bi.bmiColors[0].rgbRed = 0;
	bi.bmiColors[0].rgbReserved = 0;


	//3.2 Create bitmap and receive pointer to points into pBuffer
	hTargetBitmap = CreateDIBSection(
		hDC,
		&bi,
		DIB_RGB_COLORS,
		(void**)&pBuffer,
		NULL,
		0);


	//4. Copy source bitmap into the target bitmap.

	//4.1 Create 2 device contexts 
	HDC memDc = CreateCompatibleDC(NULL);
	HDC targetDc = CreateCompatibleDC(NULL);

	//4.2 Select source bitmap into one DC, target into another
	HBITMAP hOldBitmap1 = (HBITMAP)::SelectObject(memDc, hSourceBitmap);
	HBITMAP hOldBitmap2 = (HBITMAP)::SelectObject(targetDc, hTargetBitmap);

	//4.3 Copy source bitmap into the target one
	BitBlt(memDc,0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY);

	//4.4 Restore device contexts
	::SelectObject(memDc, hOldBitmap1);
	::SelectObject(targetDc, hOldBitmap2);
	DeleteDC(memDc);
	DeleteDC(targetDc);

	//Here we can bitmap bits: pBuffer. Note:
	// 1. pBuffer contains 3 bytes per point
	// 2. Lines ane from the bottom to the top!
	// 3. Points in the line are from the left to the right
	// 4. Bytes in one point are BGR (blue, green, red) not RGB
	// 5. Don't delete pBuffer, it will be automatically deleted 
	//    when delete hTargetBitmap

	//DeleteObject(hSourceBitmap);
	//DeleteObject(hTargetBitmap);
	return hTargetBitmap;



}

Mais voilà si le bitmap retourné à bien la bonne taille, il est tout noir !! (pixels = 0 je suppose) donc ma question est la suivante,
Ba pourquoi ???

Alors je sais que l'on est directx ici mais mois je suis avec des API windows de base pas de MFC, c'est une simple copie que je cherche a faire (pas de truc complexes non plus je develloppe sur un telephone portable !) et non il ne connait pas GetDIBits

[Laurent Gomila]

Loupé, il existe un forum "Développement Windows" tout à fait approprié pour ça.

Sujet déplacé.

[matazz]

j'ai pas tout lu ton post mais déjà regarde ce lien, ça peut peut-être t'aider :

http://www.codeguru.com/Cpp/G-M/bitm...cle.php/c1747/
et celui la:
http://www.codeguru.com/Cpp/G-M/bitm...cle.php/c1743/

[chronos]

Humm a vu de nez ça devrai coller je ragrde ça merci

[chronos]

Et bien en fait les liens sont tres bien mais pas du tout adaptés pour mon telephoen portable !! il manque les les fonctions de recup des pixels

Alors pour faire un essai je copie un bitmap avec la fonction createBitmap :

Code :

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

1
2
3
4
5
6
7
8
9
HBITMAP CRotate::CopyBitmap( HBITMAP hbm) {
    BITMAP bm = {0};
    GetObject(hbm, sizeof(bm), &bm);
    hbmOld = (HBITMAP)  SelectObject(hdcSrc, hbm);

    hbmNew = (HBITMAP)  CreateBitmap( bm.bmWidth, bm.bmHeight, bm.bmPlanes, bm.bmBitsPixel,bm.bmBits);
    return hbmNew;
}

Et j'obtien un truc tres bizard...
Mon image resultat ressemble à une fractale alors que au depart c'est un chat avec une mouche sur le nez
Ce qui me parait pas top c'est que MSDN dit :

typedef struct tagBITMAP {
LONG bmType;
LONG bmWidth;
LONG bmHeight;
LONG bmWidthBytes;
WORD bmPlanes;
WORD bmBitsPixel;
LPVOID bmBits;
} BITMAP;

bmBits
Pointer to the location of the bit values for the bitmap. The bmBits member must be a long pointer to an array of character (1-byte) values.

ALors avec GetObject on devrait pouvoir chopper ces %µ£¨¤+@ de pixels non pour moi il semble que non...

Quelqu'un a t'il une idée ???

[matazz]

moi j'utiliserai plutot GetBitmapBits ou GetDIBBits

[chronos]

Et bien moi aussi j'utiliserias ces fonctions, mais ya un hic...
Le hic c'et Windows Mobile 2003, il ne connasi pas ces functions, alors d'apres tes liens j'ai adapté le creatDIB ça donnne ça :

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
HBITMAP CRotate::CopieSimple(HDC hDC, HBITMAP hSourceBitmap)
{
	//2. Getting bimap size.
	BITMAP bm;
	GetObject(hSourceBitmap, sizeof(BITMAP), &bm);


	//3. Creating new bitmap and receive pointer to it's bits.
	HBITMAP hTargetBitmap;
	void *pBuffer;

	//3.1 Initilize BITMAPINFO structure
	BITMAPINFO bi = {0};

	bi.bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
	bi.bmiHeader.biPlanes		= 1;
	bi.bmiHeader.biBitCount		= 32;
	bi.bmiHeader.biWidth		= bm.bmWidth;
	bi.bmiHeader.biHeight		= bm.bmHeight;
	bi.bmiHeader.biCompression	= BI_RGB;



	//3.2 Create bitmap and receive pointer to points into pBuffer
	hTargetBitmap = CreateDIBSection(
		hDC,
		&bi,
		DIB_RGB_COLORS,
		(void**)&pBuffer,
		NULL,
		0);



	//4. Copy source bitmap into the target bitmap.

	//4.1 Create 2 device contexts 
	HDC memDc    = CreateCompatibleDC(NULL);
	HDC targetDc = CreateCompatibleDC(NULL);

	//4.2 Select source bitmap into one DC, target into another
	HBITMAP hOldBitmap1 = (HBITMAP)::SelectObject(memDc, hSourceBitmap);
	HBITMAP hOldBitmap2 = (HBITMAP)::SelectObject(targetDc, hTargetBitmap);

	//4.3 Copy source bitmap into the target one
	BitBlt(targetDc,0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY);

	//4.4 Restore device contexts
	::SelectObject(memDc, hOldBitmap1);
	::SelectObject(targetDc, hOldBitmap2);

	DeleteDC(memDc);
	DeleteDC(targetDc);

	//Here we can bitmap bits: pBuffer. Note:
	// 1. pBuffer contains 3 bytes per point
	// 2. Lines ane from the bottom to the top!
	// 3. Points in the line are from the left to the right
	// 4. Bytes in one point are BGR (blue, green, red) not RGB
	// 5. Don't delete pBuffer, it will be automatically deleted 
	//    when delete hTargetBitmap

	//DeleteObject(hSourceBitmap);
	//DeleteObject(hTargetBitmap);
	return hTargetBitmap;



}

Comme les couleurs et les pixels sont rangés bizarrement je ferme pas le post et je mettrais le code de rotation quand il sera fait...

Au passage c'est pas comme dans mon premier post

BitBlt(memDc,0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY);

mais

Code :

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

BitBlt(targetDc,0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY);

Quand on est pas môlin...

Merci pour les liens

[chronos]

Et bien voilà c'est fait pour mes petits enfants je laisse une trace de comment que c'est ti qu'il faut faire sous mobile 2003 pour tourner une image :

1 - On charge L'image :

Code :

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

1
2
HBITMAP hbm = SHLoadImageFile(TEXT("\\Storage\\Windows\\Start Menu\\Accessories\\a.jpg"));

2 - On fait tourner l'image :

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
HBITMAP TurnIt(HDC hDC, HBITMAP hSourceBitmap,int nAngle)
{
	if(nAngle != 0 && nAngle != 90 && nAngle != 180 && nAngle != 270)
		return NULL;

	//1. Creating new bitmap and receive pointer to it's bits.
	HBITMAP hTargetBitmap;
	void * lpDataSrc;

	BITMAP bm;
	if(GetObject(hSourceBitmap, sizeof(BITMAP), &bm) == 0)
	{
		return NULL;
	}

	//1.1 Initilize BITMAPINFO structure
	BITMAPINFO bi = {0};

	bi.bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
	bi.bmiHeader.biPlanes		= 1;
	bi.bmiHeader.biBitCount		= 32;
	bi.bmiHeader.biWidth		= bm.bmWidth;
	bi.bmiHeader.biHeight		= bm.bmHeight;
	bi.bmiHeader.biCompression	= BI_RGB;



	//1.2 Create bitmap and receive pointer to points into pBuffer
	hTargetBitmap = CreateDIBSection(hDC,&bi,DIB_RGB_COLORS,(void**)&lpDataSrc,NULL,0);

	if(hTargetBitmap == NULL)
	{
		return NULL;
	}


	//2. Copy source bitmap into the target bitmap.
	//2.1 Create 2 device contexts 
	HDC memDc    = CreateCompatibleDC(NULL);
	HDC targetDc = CreateCompatibleDC(NULL);
	if(memDc == NULL || targetDc == NULL)
	{
		DeleteObject(hTargetBitmap);
		return NULL;
	}

	//2.2 Select source bitmap into one DC, target into another
	HBITMAP hOldBitmap1 = (HBITMAP)::SelectObject(memDc, hSourceBitmap);
	HBITMAP hOldBitmap2 = (HBITMAP)::SelectObject(targetDc, hTargetBitmap);
	if(hOldBitmap1 == NULL || hOldBitmap2 == NULL)
	{
		DeleteObject(hTargetBitmap);
		DeleteDC(memDc);
		DeleteDC(targetDc);
		return NULL;
	}

	//2.3 Copy source bitmap into the target one
	if (BitBlt(targetDc,0, 0, bm.bmWidth, bm.bmHeight, memDc, 0, 0, SRCCOPY) == 0)
	{
		DeleteObject(hTargetBitmap);
		DeleteDC(memDc);
		DeleteDC(targetDc);
		return NULL;
	}

	//2.4 Restore device contexts
	::SelectObject(memDc, hOldBitmap1);
	::SelectObject(targetDc, hOldBitmap2);

	//2.5 Destroy device context
	DeleteDC(memDc);
	DeleteDC(targetDc);


	//Here we can bitmap bits: pBuffer.
	// Note:
	// 1. pBuffer contains 3 bytes per point
	// 2. Lines ane from the bottom to the top!
	// 3. Points in the line are from the left to the right
	// 4. Bytes in one point are BGR (blue, green, red) not RGB
	// 5. Don't delete lpDataSrc, it will be automatically deleted 
	//    when delete hTargetBitmap



	//3. Rotate the bitmap
	//3.1 Get source size
	SIZE sizeSrc = {0};
	sizeSrc.cx = bm.bmWidth;
	sizeSrc.cy = bm.bmHeight;


	//3.2 Compute dest size, hard calculation :op	
	SIZE sizeDst = sizeSrc;
	if(nAngle == 90 || nAngle == 270)
	{
		sizeDst.cx = sizeSrc.cy;
		sizeDst.cy = sizeSrc.cx;
	}

	//3.3 Allocate memory for our new bitmap
	DWORD dwSize = 4*sizeDst.cx*sizeDst.cy;
	LPVOID lpDataDst = VirtualAlloc(NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);
	if(lpDataDst == NULL)
	{
		DeleteObject(hTargetBitmap);
		return NULL;
	}

	//3.4 Get pixels and turn them
	for&#40;int xSrc = 0; xSrc < sizeSrc.cx; xSrc++&#41;
	&#123;
		for&#40;int ySrc = 0; ySrc < sizeSrc.cy; ySrc++&#41;
		&#123;
			// Dest pixels coordinates
			int xDst = 0;
			int yDst = 0;

			//compute dest coordinates
			//WARNING &#58;
			//After BitBlt w've got pixels bottum up
			//And for CreateBitmap bitmap pixels are top down
			//Must invert y coordinates
			switch&#40;nAngle&#41;
			&#123;
				case 90	&#58; xDst = sizeSrc.cy-ySrc-1;//compute x dest coordinate
						  yDst = &#40;sizeSrc.cx-1&#41; - xSrc;//xSrc should be goog but we need ton invert y
				break;

				case 180&#58; xDst = xSrc;
						  yDst = ySrc;
				break;

				case 270&#58; xDst = ySrc;
						  yDst = xSrc;
				break;
			&#125;

			//Compute the pixel addresse
			//Assuming they are in a one dim array
			LPDWORD lpSrc = &#40;LPDWORD&#41;lpDataSrc+ sizeSrc.cx*ySrc + xSrc;
			LPDWORD lpDst = &#40;LPDWORD&#41;lpDataDst+ sizeDst.cx*yDst + xDst;

			//Sets the dest pixel
			*lpDst = *lpSrc;

		&#125;
	&#125;

	//4. Create the new bitmap
	hTargetBitmap = CreateBitmap&#40;sizeDst.cx,sizeDst.cy,1,32/*Bit by pixels*/,lpDataDst/*pixel array*/&#41;;
	if &#40;hTargetBitmap == NULL&#41;
	&#123;
		DeleteObject&#40;hTargetBitmap&#41;;
		VirtualFree&#40;lpDataDst, 0, MEM_RELEASE&#41;;
		return NULL;
	&#125;


	//5. Cleanup
	VirtualFree&#40;lpDataDst, 0, MEM_RELEASE&#41;;

	return hTargetBitmap;
&#125;

Voilà c'est fini