Discussion :

[meera]

ah donc je dois remplir la zonne manuelement
la fonction rand ne marche pas

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
 
using System; 
using Hasard; 
 
namespace Hasard 
{ 
    public class Hasard 
    { 
        private static Random m_Random = new Random(); 
 
        public Hasard() 
        { 
        } 
 
        public static int Random( int valeur ) 
        { 
            if (valeur > 0) 
                return Hasard.m_Random.Next(valeur+1); 
            else 
                return valeur; 
        }

????
mais ici je sais pas commet determiner la dimension d l'image

[Médinoc]

La dimension, pour un bitmap 32bits, c'est assez facile: hauteur*largeur*4 octets.

Pour un bitmap 24bits, c'est un peu plus dur, mais ce doit être du genre:
((largeur*3)+3 & ~3) * hauteur.
(le calcul supplémentaire servant à arrondir la largeur aux 4 octets supérieurs).

[meera]

ah
merci pour votre aide
donc je px utiliser la fonction rand(int valeur)
et je dois spécifier la dimension de bitmap en avance
n'est ce pas

[Médinoc]

Pour moi, tu calcules la taille et tu passes à une fonction comme CryptGenRandom() ou une fonction personnelle:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void MemRandom(void *pVoid, size_t size)
{
	#ifdef __cplusplus
	char * const pMem = static_cast< char * >(pVoid);
	#else
	char * const pMem = pVoid;
	#endif
 
	size_t i;
	for(i=0 ; i<size ; i++)
	{
		pMem[i] = (char)(rand() >> 7); //Si RAND_MAX est bien >= 32767
	}
}

Note: je fais un décalage, car les bits inférieurs sont souvent moins aléatoires que les autres. Tu peux aussi passer par les conversions de double, mais c'est souvent beaucoup plus lent.
Attention, si RAND_MAX est inférieur à 32767, tu as intéret à réduire le décalage (voire à passer par les double).

[meera]

je vais essaier d'appliquer ça
j vous remercier du mon coeur

[meera]

svp est que vous pouvez me corriger une portion de mon code?
je prend une image
je la divise en bloc de 8*8
j'ajoute une nombre(-128)
j'applique DCT sur ce derniere

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
 
BOOL CImage::Compression(int qualite)
{
	if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
 
	// Détermination du nombre de couleurs
	int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : 0x1FF & (1 << BmSrcInfo->biBitCount);
 
// Copie du Header + palette ds le nouveau bitmap
	CopyMemory(biDest, biSrc, BmSrcInfo->biSize+nColors*sizeof(RGBQUAD));
 
	// Détermination de la zone des bits de l'image source et largeur lignes en octets
	BYTE* lpSrcBits = (BYTE*)BmSrcInfo+BmSrcInfo->biSize+nColors*sizeof(RGBQUAD);
	int nScanWidth = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);
 
	// Détermination de la zone des bits de l'image destination
	BYTE* lpDestBits = (BYTE*)BmDestInfo+BmDestInfo->biSize+nColors*sizeof(RGBQUAD);
 
 
		//Limitation du facteur de qualite
		if ( qualite>25)
		  qualite=25;
		else ( qualite<0)
		  qualite=1;
 
 
 
BYTE Q[8][8];
 
for (i=1;i<8;i++)
    for (j=1;j<8;j++)
	{
        Q[i][j]= 1 + (( 1 + (i-1) + (j-1)) * qualite);
	}
 
 
 
 
 
	///////////////////////////////////////*
 
 
 
//Note: là, on suppose que les dimensions de l'image sont multiples se 8,
.
.
	//	on suppose que les images ont des dimensions qui sont des multiples de 8       
	//nombre de matrice 8x8 dans la largeur de l'image
	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 (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*BmSrcInfo->bmWidth + xx ];
				lpDestBits[yy*BmSrcInfo->bmWidthh+xx] = lpSrcBits[yy*BmSrcInfo->bmWidth+xx]
								}
	// ici je veux que cette boucle sera  appliquer sur chaque  couleur (bleu , rouge et vert)
	// je sais pas est ce que je spécifie chaque couleur comme suit:
 
		/*	RGBQUAD Color;
 
			DWORD* dwSquares
	dwSquares[Color.rgbGreen-(int)pCubeInfo->rgbColor.rgbGreen]*/
 
	}
 
		}
 
}
 
 
 
   	 //on retranche 128 à tous les coefficients de la matrice
 
 
//construction d'une matrice que l'on va ajouter à  image destination
 
	 Byte P[8][8];
		for (i=1;i<8;i++)
			 for (j=1;j<8;j++)
				{
				    P[i][j]= 1 ;
				}
 
 
	int	temp=P*(-128);   //M88_128    
 
 
	for (x=0 ; x<nb_mat8_larg ; x++)
	{
	for (y=0 ; y<nb_mat8_haut ; y++)
		{
		lpDestBits[y*BmSrcInfo->bmWidthh+x] = lpSrcBits[y*BmSrcInfo->bmWidth+x] +temp;         // par exemlpe nomme M88DCT
 
		}
 
 
	}
		//calcul de la DCT sur cette matrice
 
 
 
 
//Calcul des coefficients de a tranformes de la  dct
//i,j sont les indices de la nouvelle matrice a
//u,v sont les indices de la matrice m
 
			  	for(int i=0; i<BmSrcInfo->biHeight-1; i++)
			for(int j=0; j<BmSrcInfo->biWidth-1; j++)
 	for(int k=0; k<BmSrcInfo->biHeight-1; k++)
			for(int l=0; l<BmSrcInfo->biWidth-1; l++)
			{
                //Test permettant de determiner la valeur des variables C1 et C2
                if u==0
                    c1=1/sqrt(2);
                else
                    c1=1;
 
 
 
                if v==0
                    c2=1/sqrt(2);
                else
                    c2=1;
         /////////////////////  ici je sais comment d'ecrire cette equation en vc++
/*
                M88DCT(i+1,j+1)=M88DCT(i+1,j+1)+1/sqrt(2*BmSrcInfo->biHeigh)*c1*c2*m(u+1,v+1)*cos(pi*u/BmSrcInfo->biHeigh*(i+1/2))*cos(pi*v/BmSrcInfo->biHeigh*(j+1/2));
 */
	 // matrice de quantification
         	  M_quantifiee = M88DCT./Q;

[Médinoc]

Code :

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

1
2
3
// Détermination de la zone des bits de l'image source et largeur lignes en octets
	BYTE* lpSrcBits = (BYTE*)BmSrcInfo+BmSrcInfo->biSize+nColors*sizeof(RGBQUAD);
	int nScanWidth = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);

Ne crois-tu pas que tu devrais calculer WIDTHBYTES avant l'allocation?

Code :

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

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

C'es normal que tu ne remplisses pas la colonne 0 et la ligne 0 ?

Code :

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

lpDestBits[yy*BmSrcInfo->bmWidthh+xx] = lpSrcBits[yy*BmSrcInfo->bmWidth+xx]

ça, ça ne peut marcher qu'avec le pointeur de la même taille qu'un pixel.
Pour un BYTE*, ça ne marcherait que sur une image 8bits.
Pour une image 32bits, le mieux est un RGBQUAD *.
Pour une image 24bits, il n'y a rien: Il va falloir compter les bytes trois par trois...
En plus, tu copies bêtements les bits de ton image source vers ton image de destination sans même passer par ta fameuse matrice 8*8, alors que je croyais que ces boucles étaient supposées remplir la matrice 8*8...

Code :

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

int	temp=P*(-128);   //M88_128

Ça ne marche pas. Il faut faire l'opération membre à membre ou utiliser des fonctions de calcul matriciel...(Windows n'en propose pas, il faudrait donc une bibliothèque ou des fonctions perso pour cela)


La suite est trop confuse pour moi.


Mais je me permets de te donner un conseil: Décompose un peu plus en fonction, et fait bien attention à ce que tu fais.
Ta DCT, tu dois la faire sur ta matrice 8*8. Le bitmap source doit n'etre utilisé que pour remplir la matrice, et le bitmap destination pour la vider.

Normalement, la fonction qui fait le calcul doit prendre des matrices 8*8 en entrée, sans se soucier d'où elles viennent (que ce soit d'un bitmap Windows ou de tout autre support).
Donc, tu devrais commencer par décomposer:

• Une fonction de lecture, qui lit le bitmap et remplit la matrice
• Une fonction de calcul sur la matrice
• Une fonction d'écriture vers le bitmap destination
• Et une fonction qui utilise les trois autres en boucle.

[meera]

oui oui trop des erreurs
j'ai habutiée à travailler en matlab, un jeu sur des matrces
en vc++, c compliqué pour moi que je suis encore une débutante
je te remercie pour ton superb aide
pour moi je refaite encore le code
et j'espére qu'il soit prochainemet avec peu d'erreurs
merci de nouveau

[meera]

bonjour
j'ai refait le code
mais je rencontre qlq pb

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
 
BOOL CImage::lectureBitmap()
{
if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
// Détermination du nombre de couleurs
	int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : 0x1FF & (1 << BmSrcInfo->biBitCount);
 
// Copie du Header + palette ds le nouveau bitmap
	CopyMemory(biDest, biSrc, BmSrcInfo->biSize+nColors*sizeof(RGBQUAD));
 
	// Détermination de la zone des bits de l'image source et largeur lignes en octets
	BYTE* lpSrcBits = (BYTE*)BmSrcInfo+BmSrcInfo->biSize+nColors*sizeof(RGBQUAD);
	int nScanWidth = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);
 
	// Détermination de la zone des bits de l'image destination
	BYTE* lpDestBits = (BYTE*)BmDestInfo+BmDestInfo->biSize+nColors*sizeof(RGBQUAD);
 
	//	on suppose que les images ont des dimensions qui sont des multiples de 8       
	//nombre de matrice 8x8 dans la largeur de l'image
	int 	nb_mat8_larg = BmSrcInfo->biHeight/8;
	//nombre de matrice 8x8 dans la hauteur de l'image
	int     nb_mat8_haut = BmSrcInfo->biWidth/8;
 
 
 
i if(BmSrcInfo->biBitCount==32) // 32 bits
	{
 
 
f 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++)
				{
 
				lpDestBits[yy*nScanWidth+xx] = lpSrcBits[yy*nScanWidth+xx];
		.
				}
			}
 
		}
 
}	}
}	}
 
 
	GlobalUnlock(m_hDib);
	GlobalUnlock(hNewDib);
	GlobalFree(m_hDib);
 
	// On supprime l'ancien DIB et on le remplace par le nouveau
	m_hDib = hNewDib;
	return TRUE;
}

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
 
BOOL CImage::ajoutmatt()
{
	Byte	temp[8][8];
	Byte P[8][8];
		for (i=0;i<8;i++)
			 for (j=0;j<8;j++)
				{
				    P[i][j]= 1 ;
				}
 
			 	for (i=0;i<8;i++)
			 for (j=0;j<8;j++)
			 {
 
				temp[i][j]=P[i][j]*(-128);
			 }
 
 
			 if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
	for(int y=0; y<BmSrcInfo->biHeight; y++)
			for(int x=0; x<BmSrcInfo->biWidth; x++)
			{
				lpDestBits[y*nScanWidth+x] = lpSrcBits[y*nScanWidth+x]+ temp[x][y]:
			}
 
	GlobalUnlock(m_hDib);
	GlobalUnlock(hNewDib);
	GlobalFree(m_hDib);
 
	// On supprime l'ancien DIB et on le remplace par le nouveau
	m_hDib = hNewDib;
	return TRUE;
 
}

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
 
BOOL CImage::calculDCT()
{
 
			 if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
int	M=BmSrcInfo->biHeight;
float pi=3.14;
 
	for(int i=0; i<BmSrcInfo->biHeight-1; i++)
			for(int j=0; j<BmSrcInfo->biWidth-1; j++)
 				for(int k=0; k<BmSrcInfo->biHeight-1; k++)
					for(int l=0; l<BmSrcInfo->biWidth-1; l++)
			{
                //Test permettant de determiner la valeur des variables C1 et C2
                if u==0
                    c1=1/sqrt(2);
                else
                    c1=1;
 
 
 
                if v==0
                    c2=1/sqrt(2);
                else
                    c2=1;
			//	a(u+1,v+1)=a(u+1,v+1)+1/sqrt(2*M)*c1*c2*m(i+1,j+1)*cos(pi*u/M*(i+1/2))*cos(pi*v/M*(j+1/2));               
lpDestBits[(u+1)*nScanWidth+(v+1)] = lpDestBits[(u+1)*nScanWidth+(v+1)]/sqrt(2*M)*c1*c2*lpSrcBits[(i+1)*nScanWidth+(j+1)]**cos(pi*u/M*(i+1/2))*cos(pi*v/M*(j+1/2)); 
 
					}
 
	GlobalUnlock(m_hDib);
	GlobalUnlock(hNewDib);
	GlobalFree(m_hDib);
 
	// On supprime l'ancien DIB et on le remplace par le nouveau
	m_hDib = hNewDib;
	return TRUE;
 
}

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
 
 
// ici je sias pas cmt je fait l'appel des fonctions:oops: 
BOOL CImage::General(int qualite)
 
{
 
			 if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
	BmSrcInfo.lectureBitmap();
	BmSrcInfo.ajoutmatt();
 
	BmSrcInfo.calculDCT();
.
.
.
 
}

[Médinoc]

Ouh, le désastre
Bon, je ne peux pas t'aider maintenant, car je suis au boulot et je prends du retard. Mais je vais essayer d'y jeter un oeil ce soir. Il y a une bonne partie à revoir de font en comble, et tu as énormément de code dupliqué...

PS: Tu devrais éviter d'utiliser les fonctions comme GlobalAlloc() à gogo. C'est fonctions sont quelque peux déconseillées de nos jours. Si tu tiens à utiliser les fonctions d'allocation de Windows, tu devrais utiliser HeapAlloc(GetProcessHeap()). Ainsi au moins, tu ne t'embarasserais pas de handles, ce serait déjà ça.

[meera]

ok merci
je sens que je dérange par mes fauts
moi je continuer d'utiliser la fonction GlobalLock car ds ma premiére partie de mon projet ( faire par exemple la binaraisation , négation, niveau de gris......)
je l' a utilisée

[Médinoc]

OK, pour les GlobalXxxx c'est pas bien grave. Mais ta séparation en fonctions a aggravé la situation au lieu de l'améliorer...

[meera]

ahhhhhhhhhhhh
vraiment à cet niveau je sis perturbée

[Médinoc]

Il faut des petites fonctions, dans ce genre:
(j'ai pas compilé, donc il y a surement des erreurs)

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
enum e_couleur { ROUGE, VERT, BLEU };

/* Fonction qui prend le bitmap 32 bits en entrée et remplit la matrice 8*8
   ------------------------------------------------------------------------ */
BOOL Get88Matrix32(
 VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits
 int nWidth,               //[in] Largeur du bitmap 32bits en pixels
 int x,                    //[in] Coordonnée X de la matrice 8*8
 int y,                    //[in] Coordonnée Y de la matrice 8*8
 BYTE pMatrice[8][8],      //[out] Matrice 8*8 à lire
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(pMatrice==NULL)
		return FALSE;

	RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits);

	//Parcours de la zone 8*8
	for( xx=0 ; xx<8 ; xx++)
	{
		for( yy=0 ; yy<8 ; yy++)
		{
			RGBQUAD const *pcRgb = pcRgbBits + (yy+8*y)*nWidth + (xx+8*x);
			switch(eCouleur)
			{
			case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed;   break;
			case VERT:  pMatrice[xx][yy] = pcRgb->rgbGreen; break;
			case BLEU:  pMatrice[xx][yy] = pcRgb->rgbBlue;  break;
			}
		}
	}
	return TRUE;
}

Edit : Une petite correction dans le code.

[meera]

je vais essaiyer de le compliler
merci pour ton aide

[Médinoc]

Si cette fonction marche, tu pourras l'appeler (ainsi que les suivantes) dans une grande boucle.

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
	//	on suppose que les images ont des dimensions qui sont des multiples de 8       
	//Je rappelle que width est la largeur et height est la hauteur
	//nombre de matrice 8x8 dans la largeur de l'image
	int 	nb_mat8_larg = BmSrcInfo->biWidth/8;
	//nombre de matrice 8x8 dans la hauteur de l'image
	int     nb_mat8_haut = BmSrcInfo->biHeight/8;



i if(BmSrcInfo->biBitCount==32) // 32 bits
	{


f for (x=0 ; x<nb_mat8_larg ; x++)
	{
	for (y=0 ; y<nb_mat8_haut ; y++)
		{
		//  -/----------------\-
		BYTE M88[8][8];
		Get88Matrix32(lpSrcBits, BmSrcInfo->biWidth, x, y, M88, ROUGE);

		//Traitement sur la matrice
		//...

		//Ecriture dans la destination
		//...

		//  -\----------------/-
		//On fait la même chose pour le vert et le bleu
		//...
		//...
		}
	}

Et là encore, on peut fragmenter : Pourquoi ne pas mettre le traitement interne de la boucle (entre les deux lignes rouge sombre) dans une fonction qu'on appellerait trois fois, prenant une enum e_couleur en paramètre ?
Là encore, on évite de la recopie de code...

[meera]

je le complile, il me donne juste une erreur

Code :

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

1
2
 
C:\Program Files\Microsoft Visual Studio\projects\esssssss\wassima\Demonstration\Image.cpp(2398) : error C2228: left of '.rgbRed' must have class/struct/union type

erreur pour chaque couleur

mais je sais pas ,si ce code ça marche ds ma application
car moi je ravaille ds la classe CImage
donc j'hérite des fonctions
et j'utilise par exemple :lpDestBits,nScanWidth,.........
je te montre un morceau de code qui fait la binaraisation de 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
 
BOOL CImage::Binarisation(int seuil){
 
	 if(!m_hDib)
		return FALSE;	// DIB non valide
 
	// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
	HGLOBAL hNewDib=GlobalAlloc(GHND, GlobalSize(m_hDib));
	if(!hNewDib)
		return FALSE;  // Pas assez de mémoire ou problème
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
	LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
	LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
	// Détermination du nombre de couleurs
	int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : 0x1FF & (1 << BmSrcInfo->biBitCount);
 
	// Copie du Header + palette ds le nouveau bitmap
	CopyMemory(biDest, biSrc, BmSrcInfo->biSize+nColors*sizeof(RGBQUAD));
 
	// Détermination de la zone des bits de l'image source et largeur lignes en octets
	BYTE* lpSrcBits = (BYTE*)BmSrcInfo+BmSrcInfo->biSize+nColors*sizeof(RGBQUAD);
	int nScanWidth = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);
 
	// Détermination de la zone des bits de l'image destination
	BYTE* lpDestBits = (BYTE*)BmDestInfo+BmDestInfo->biSize+nColors*sizeof(RGBQUAD);
 
	// Traitement différent selon nombre de bits/pixel
 
	if(BmSrcInfo->biBitCount==8) // 8 bits
	{
		for(int y=0; y<BmSrcInfo->biHeight; y++)
			for(int x=0; x<BmSrcInfo->biWidth; x++)
				lpDestBits[y*nScanWidth+x] = lpSrcBits[y*nScanWidth+x]>seuil?255:0;
	}
 
	GlobalUnlock(m_hDib);
	GlobalUnlock(hNewDib);
	GlobalFree(m_hDib);
 
	// On supprime l'ancien DIB et on le remplace par le nouveau
	m_hDib = hNewDib;
	return TRUE;
 
}
 
 
donc je sais pas c l'exéecution m'affiche qlq chose :oops: :oops:

[Médinoc]

Ton morceau de code, il ne fait rien d'autre que copier une image dans une autre...

Et dans mon code, il faut remplacer les points par des '->'

[meera]

ah ok je vais essayer de nouveau
je te remercie vivement

[meera]

salut
j'ai reécrit ces fontions
je sais pas cette fois si elles sont correctes

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
 
BOOL AjoutMatrix32(
 VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits
 int nWidth,               //[in] Largeur du bitmap 32bits en pixels
 int x,                    //[in] Coordonnée X de la matrice 8*8
 int y,                    //[in] Coordonnée Y de la matrice 8*8
 int valeur;
 BYTE pMatrice[8][8],      //[out] Matrice 8*8 à lire
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(pMatrice==NULL)
		return FALSE;
 
 
 
	Byte	temp[8][8];
	Byte P[8][8];
		for (int i=0;i<8;i++)
			{
			 for (int j=0;j<8;j++)
				{
				    P[i][j]= 1 ;
 
 
				temp[i][j]=P[i][j]*valeur;
				 }
		}
 
	RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits);
 
	//Parcours de la zone 8*8
	for(int  xx=0 ; xx<8 ; xx++)
	{
		for( int yy=0 ; yy<8 ; yy++)
		{
			RGBQUAD const *pcRgb = pcRgbBits + (yy*nWidth + xx) + temp[xx][yy];
			switch(eCouleur)
			{
			case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed;   break;
			case VERT:  pMatrice[xx][yy] = pcRgb->rgbGreen; break;
			case BLEU:  pMatrice[xx][yy] = pcRgb->rgbBlue;  break;
			}
		}
	}
	return TRUE;
}

et la fonction qui calcul la DCT:

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

BOOL DCTMatrix32(
 VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits
 int nWidth,               //[in] Largeur du bitmap 32bits en pixels
 int x,                    //[in] Coordonnée X de la matrice 8*8
 int y,                    //[in] Coordonnée Y de la matrice 8*8
 int valeur;
 BYTE pMatrice[8][8],      //[out] Matrice 8*8 à lire
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(pMatrice==NULL)
		return FALSE;

//Calcul des coefficients de a tranformes de la  dct
//u,v sont les indices de la nouvelle matrice a
//i,j sont les indices de la matrice m
	RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits);
for (int xx=0:xx<nWidth;xx++)
    for (int yy=0:yy<nWidth;yy++)
        for (int i=0:i<nWidth;i++)
            for (int j=0:j<nWidth;j++)
			{
                //Test permettant de determiner la valeur des variables C1 et C2
                if u==0
                    c1=1/sqrt(2);
                else
                    c1=1;
              
                if v==0
                    c2=1/sqrt(2);
                else
                    c2=1;
				//j'ai cette equation n matlab, je sais pas si j'ai bien convertit en vc++ et j'ai bien respecté les boules!!! ( M=size d'image)                
              //  a(u+1,v+1)=a(u+1,v+1)+1/sqrt(2*M)*c1*c2*m(i+1,j+1)*cos(pi*u/M*(i+1/2))*cos(pi*v/M*(j+1/2));               
  


	//Parcours de la zone 8*8
	
			RGBQUAD const *pcRgb = pcRgbBits + (2/nWidth)*((yy*nWidth + xx)*c1*c2* *cos(pi*u/nWidth*(i+1/2))*cos(pi*v/nWidth*(j+1/2)));
			switch(eCouleur)
			{
			case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed;   break;
			case VERT:  pMatrice[xx][yy] = pcRgb->rgbGreen; break;
			case BLEU:  pMatrice[xx][yy] = pcRgb->rgbBlue;  break;
			}
		}
	}
	return TRUE;
}

et la fonction quantification

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
 
OOL qantiMatrix32(
 VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits
 int nWidth,               //[in] Largeur du bitmap 32bits en pixels
 int x,                    //[in] Coordonnée X de la matrice 8*8
 int y,                    //[in] Coordonnée Y de la matrice 8*8
 int Fq;
 BYTE pMatrice[8][8],      //[out] Matrice 8*8 à lire
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(pMatrice==NULL)
		return FALSE;
 
 
 
for i=1:8
    for j=1:8
	{
        Q(i,j)= 1 + (( 1 + (i-1) + (j-1)) * Fq);
 
	}
 
	RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits);
 
	//Parcours de la zone 8*8
	for(int  xx=0 ; xx<8 ; xx++)
	{
		for( int yy=0 ; yy<8 ; yy++)
		{
			RGBQUAD const *pcRgb = pcRgbBits + (yy*nWidth + xx) /Q[xx][yy];          //mais ici je veux que l'image source soit divisr par Q ( çàd par q tt entir c pas par une valeur de Q selon xx rt yy
			switch(eCouleur)
			{
			case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed;   break;
			case VERT:  pMatrice[xx][yy] = pcRgb->rgbGreen; break;
			case BLEU:  pMatrice[xx][yy] = pcRgb->rgbBlue;  break;
			}
		}
	}
	return TRUE;
}

et la d'ecriture destination

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
 
BOOL destiMatrix32(
 VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits
 int nWidth,               //[in] Largeur du bitmap 32bits en pixels
 int x,                    //[in] Coordonnée X de la matrice 8*8
 int y,                    //[in] Coordonnée Y de la matrice 8*8
 BYTE pMatrice[8][8],      //[out] Matrice 8*8 à lire
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(pMatrice==NULL)
		return FALSE;
 
 
 
 
 
	RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits);
 
	//Parcours de la zone 8*8
	for(int  xx=0 ; xx<8 ; xx++)
	{
		for( int yy=0 ; yy<8 ; yy++)
		{
 
 
// ici je dois copier l'imag resultante de la quantification en l'image destination
//en chaque bloc 8*8
//Dectination( de(1+8*i) à  :(8*(i+1)),   de (1+8*j)   à  (8*(j+1)),k) = M_quantifiee;
 
 
			RGBQUAD const *pcRgb = pcRgbBits + (yy+8*y)*nWidth + (xx+8*x); !!!!!!!!!!!!!!!!!  // je sais pas cmt l'écrire
			switch(eCouleur)
			{
			case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed;   break;
			case VERT:  pMatrice[xx][yy] = pcRgb->rgbGreen; break;
			case BLEU:  pMatrice[xx][yy] = pcRgb->rgbBlue;  break;
			}
		}
	}
	return TRUE;
}

et la fontion globale:

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
 
BOOL CImage::Compression(int qualite)
{
	//on suppose que les images ont des dimensions qui sont des multiples de 8       
	//Je rappelle que width est la largeur et height est la hauteur
	//nombre de matrice 8x8 dans la largeur de l'image
	int 	nb_mat8_larg = BmSrcInfo->biWidth/8;
	//nombre de matrice 8x8 dans la hauteur de l'image
	int     nb_mat8_haut = BmSrcInfo->biHeight/8;
 
 
	//Limitation du facteur de qualite
		if ( qualite>25)
		  qualite=25;
		else ( qualite<0)
		  qualite=1;
 
 if(BmSrcInfo->biBitCount==32) // 32 bits
	{
 
 
 for (x=0 ; x<nb_mat8_larg ; x++)
	{
	for (y=0 ; y<nb_mat8_haut ; y++)
		{
		//  -/----------------\-
		BYTE M88[8][8];
		BYTE M88_128[8][8];
		BYTE M88DCT[8][8];
		BYTE M_quantifiee[8][8];
		Get88Matrix32(lpSrcBits, BmSrcInfo->biWidth, x, y, M88, ROUGE);
		AjoutMatrix32(M88, BmSrcInfo->biWidth, x, y,-128, M88_128, ROUGE);
		DCTMatrix32(M88_128, BmSrcInfo->biWidth, x, y, M88DCT, ROUGE);
		qantiMatrix32(M88DCT, BmSrcInfo->biWidth, x, y, Fq, M_quantifiee, ROUGE);
		destiMatrix32(M_quantifiee, BmSrcInfo->biWidth, x, y, lpDestBits, ROUGE);
 
 
	}
		}
 
}
 GlobalUnlock(m_hDib);
	GlobalUnlock(hNewDib);
	GlobalFree(m_hDib);
 
	// On supprime l'ancien DIB et on le remplace par le nouveau:oops: :oops: 
	m_hDib = hNewDib;
	return TRUE;
}

j ' ecrit le code juste pour le rouge
j'ai pas encore essayer d'aplique ce que tu me conseillé de faire