vc++ & matrice & image

Version imprimable

Voir 40 message(s) de cette discussion en une page

04/09/2006, 16h26
Médinoc

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?
04/09/2006, 16h53
meera

je dois diviser la petite matrice extraite8*8 par la matrice q
ect ce que si possible d'ecrire :
M_quantifiee = M88/Q;
04/09/2006, 17h22
Médinoc

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...

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

Code:

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:

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);
	}

04/09/2006, 20h18
Médinoc
1. Ça ne me montre pas la déclaration de M88
2. Code:
  
  M88=RGBQUAD *pPixel ;
  
  Ça compile, ça?
04/09/2006, 21h35
meera

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++
04/09/2006, 21h48
Médinoc

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

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

Code:

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

??????????

04/09/2006, 23h26
Médinoc

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 ?
04/09/2006, 23h37
meera

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!!!!!!!!!!!
05/09/2006, 06h37
Médinoc

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.
05/09/2006, 14h57
meera

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 :? :?
05/09/2006, 15h07
Médinoc

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.

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

Code:

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));

:oops: :oops:

05/09/2006, 15h40
Médinoc

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.
05/09/2006, 16h22
meera

aaaaaah merci
j'essaire d'appliquer ce methode
et esperons qu'ele marche
merci
06/09/2006, 13h21
meera

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.....)
:oops:
06/09/2006, 13h44
Médinoc

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é).
06/09/2006, 14h38
meera

il y a une fonction qui faire ça
en matlab la fonction randn permet de generer une sequence pseudo aleatoire
est ce que c la meme chos en vc++
06/09/2006, 14h55
Médinoc

Sinon, tu peux aussi utiliser CryptGenRandom(), mais je doute que ça vaille la peine de mettre en branle la CryptoAPI juste pour cette fonction...

Voir 40 message(s) de cette discussion en une page