vc++ & matrice & image

**Médinoc** · 04/09/2006, 16h26

Attends.
Qu'est-ce que tu dois diviser par une matrice: L'image entière ou la petite matrice 8*8 extraite de l'image?

**meera** · 04/09/2006, 16h53

je dois diviser la petite matrice extraite8*8 par la matrice q
ect ce que si possible d'ecrire :
M_quantifiee = M88/Q;

**Médinoc** · 04/09/2006, 17h22

Non.
Du moins, pas si M88 est un simple tableau à deux dimensions.
Par contre, si M88 est une instance d'une classe de matrice, peut-être que la classe en question redéfinit l'opérateur '/' pour la division matricielle...

**meera** · 04/09/2006, 19h27

M88 c'est la matrice 8*8 qu'on a calculé par:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
for (x=0 ; x<nb_mat8_larg ; x++)
	{
	for (y=0 ; y<nb_mat8_haut ; y++)
		{
		//Parcours de la zone 8*8
		for( xx=0+8*x ; xx<8+8*x ; xx++)
			{
			for( yy=0+8*y ; yy<8+8*y ; yy++)
				{
				RGBQUAD *pPixel = &pRgb[ yy*pBmi->bmWidth + xx ];
                           M88=RGBQUAD *pPixel ;

et ce possible de mettre M_128=M88/Q;
avec Q:

Code :

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

1
2
3
4
5
6
7
8
 
 
 
for (i=1;i<8;i++)
    for (j=1;j<8;j++)
	{
        Q[i][j]= 1 + (( 1 + (i-1) + (j-1)) *10);
	}

**Médinoc** · 04/09/2006, 20h18

Ça ne me montre pas la déclaration de M88
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
M88=RGBQUAD *pPixel ;
```
Ça compile, ça?

**meera** · 04/09/2006, 21h35

non non cela donne uner erreur bien sur
moi je te montre juste l'algorithme
on ne peut pas faire affectation comme cela en vc++

**Médinoc** · 04/09/2006, 21h48

C'est bien ce qui me semblait.
Donc, M88 est déclaré comment?

**meera** · 04/09/2006, 23h08

je sais pas si je fais ce truc , est ce qu' il va marcher
:

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
 
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
 
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
	int 	nb_mat8_larg = BmSrcInfo->biHeight/8;
	//nombre de matrice 8x8 dans la hauteur de l'image
	int     nb_mat8_haut = BmSrcInfo->biWidth/8;
 
 
 
for (i=1;i<8;i++)
    for (j=1;j<8;j++)
	{
        Q[i][j]= 1 + (( 1 + (i-1) + (j-1)) * qualite);
	}
 
	BYTE* lpSrcBits = (BYTE*)BmSrcInfo+BmSrcInfo->biSize+nColors*sizeof(RGBQUAD);
 
 
for (x=0 ; x<nb_mat8_larg ; x++)
	{
	for (y=0 ; y<nb_mat8_haut ; y++)
		{
		//Parcours de la zone 8*8
		for( xx=0+8*x ; xx<8+8*x ; xx++)
			{
			for( yy=0+8*y ; yy<8+8*y ; yy++)
				{
				BYTE *lpSrcBits = lpSrcBits[ yy*pBmi->bmWidth + xx ];
lpDestBits[yy*nScanWidth+xx ]=lpSrcBits[yy*nScanWidth+xx];
 
pDestBits->mSrcInfo=M88

??????????

**Médinoc** · 04/09/2006, 23h26

Je ne vois pas trop ce que tu cherches à faire, là...

Et tu n'as toujours pas répondu à ma question: Comment est déclaré (et défini) M88 ?

**meera** · 04/09/2006, 23h37

ce que je veux faire
c de prendre une image
divise en bloc 8*8 (M88)
applique l'algorithme DCt sur chaque bloc (M_DCT)
diviser cette matrice par Q (m_Quantifiee)=M_DCT/Q)
voila l'algorithe
mnt je vx programmer ça en vc++
jusq'au mnt je sais pas comment declarer M88
en matlab , juste on joue sur les matrices
ici c pas le cas

voila mon grand pb!!!!!!!!!!!

**Médinoc** · 05/09/2006, 06h37

Tu peux toujours chercher sur le net une bibliothèque de calcul matriciel.
Sinon, tu déclare M88 comme un bète tableau à deux dimensions, et tu fais les calcules (divisions,etc.) manuellement.

**meera** · 05/09/2006, 14h57

oui, je préfére ce deuxiéme choix , c de declarer M88 comme une matrice 8*8
mais il reste tjs le pb d'affectation , car dans mon programme j'ai enoremement des affectations

**Médinoc** · 05/09/2006, 15h07

Eh bien pour affecter depuis le bitmap, c'est une affectation terme à terme (64 affectation par zone de 8*8).
Et pour copier une matrice 8*8 dans une autre, un simple memcpy() peut suffire.

**meera** · 05/09/2006, 15h15

j'ecris ce code mias je sais s'il m'aider

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
 
 
if(BmSrcInfo->biBitCount==32) // de 32 vers 24 bits
		{
			for(int y=0; y<BmDestInfo->biHeight; y++)
			{
				BYTE* lpSrc = lpSrcBits + (y*nScanWidthSrc);
				BYTE* lpDest = lpDestBits + (y*nScanWidthDest);
				for(int x=0; x<BmDestInfo->biWidth; x++)
				{
					*(lpDest++) = *(lpSrc++);
					*(lpDest++) = *(lpSrc++);
					*(lpDest++) = *(lpSrc++);
					lpSrc++; // on saute un octet pour chaque pixel
				}
			}
		}
 
 
 
// ou bien juste 
// Copie du Header + palette ds le nouveau bitmap
	CopyMemory(biDest, biSrc, BmSrcInfo->biSize+nColors*sizeof(RGBQUAD));

**Médinoc** · 05/09/2006, 15h40

Je ne sais pas si ça ira très bien, car il y a des contraintes d'alignement.

Ce que je te conseillerais, c'est de créer un bitmap 32 bits avec CreateDIBSection(), et de lui passer les données 24 bits avec SetDIBits(). Ensuite, tu appelles GdiFlush() et hop, tu peux travailler sur tes données 32 bits.

**meera** · 05/09/2006, 16h22

aaaaaah merci
j'essaire d'appliquer ce methode
et esperons qu'ele marche
merci

**meera** · 06/09/2006, 13h21

svp , j'ai une question
commnt je peux obtenir une image de valeur pseudo aleatoire (random)
de taille quelqconque ( 256*256 ou bien 512*512.....)

**Médinoc** · 06/09/2006, 13h44

Pour là, je ne vois pas trente-six solutions: À la main.

Le plus rapide à programmer, je pense, c'est de faire ça directement pour toute la zone mémoire, octet par octet, sans se préoccuper de la taille d'un pixel (on calcule une fois la taille de la mémoire et hop, c'est parti, on écrit n'imp dedans).

L'inconvénient sur les bitmaps 32bits, c'est que l'octet supplémentaire se retrouve lui aussi à une valeur aléatoire (mais si tu ne fais pas d'Alpha Blending, il me semble qu'il est tout simplement ignoré).