vc++ & matrice & image

**meera** · 18/09/2006, 23h07

car d'apres l'algorithme de l'insertion de la marque
j'ai d�duit que je dois construire ume marque ( matrice rempli al�atoirement par des valeurs comprise entre 0 et 1) puis l'ajouter � mon bitmap
(bien sur si j'applique l'insertion de marque ds le domaine DCT, je dois diviser mon image en bloc 8*8 et applique la DCT sur chaue bloc , puis ajouter au chaque bloc une matrice al�atoire(marque), avant d'appliquer la DCT inverse et recuperer mon image de nouveau puis l'affcher!!!)

**meera** · 19/09/2006, 12h07

bonjour
svp c inscrit ou exactement!!!! en quelle unit�
j'ai pass� un oil sur le somaire de la faq vc++ mais j'ai rien trouv�

**M�dinoc** · 19/09/2006, 12h26

Ce doit �tre dans la FAQ C (je n'ai pas la r�f�rence sous les yeux).

De toute fa�on, quand on sait que rand() retourne une valeur entre 0 et RAND_MAX, une petite r�gle de trois avec des flottants suffit g�n�ralement � r�gler le probl�me...

**meera** · 19/09/2006, 12h40

ah
est ce qu'on peut faire come �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
 
 
#define   RAND_MAX 32767 
 void generation_random( 
		BYTE matrand[8][8]
		)
{
 
	for (int  i=0; i<8; i++)
	{
		for (int j=0;j<8;j++)
		{
			matrand[i][j]=rand()/(1+(double)RAND_MAX);
		}
	}
}

???

**M�dinoc** · 19/09/2006, 13h35

C'est un truc du genre, mais n'oublie pas de multiplier par 255 ou 256 (je ne sais plus exactement)...

**meera** · 19/09/2006, 13h52

multipli�e par 255 ou 256 pourquoi????

**M�dinoc** · 19/09/2006, 15h19

Enfin, �a d�pend de ce que tu veux faire.

Si tu veux une valeur entre 0 et 255 dans ton BYTE, il te faut multiplier, car rand()/(float)RAND_MAX retourne une valeur flottante quelque part entre 0 et 1.

Si tu veux juste mettre 0 ou 1 dans ton BYTE, je te conseille plut�t:

soit de prendre juste un bit assez �lev� de la valeur retourn�e (genre le bit 13 ou le bit 14)
soit de traiter le r�sultat flottant pour �tre s�r qu'il puisse y avoir des 1 (par exemple, en multipliant par 2 ou en y ajoutant 0.5)...

**meera** · 19/09/2006, 15h20

salut
je additionne la marque sur chaque bloc de l'image ( apres l'application de DCT) puis j'applique la DCT inverse sur chaque bloc
le pb c que je sais pas cmt j'ecris la finction destination,
��d cmt je px reccup�rer mon image destination � partir de ces bloc 8*8
pour pouvoir l'afficher

merci d'avance

**M�dinoc** · 19/09/2006, 15h27

Ben, c'est pas tr�s diff�rent de la fonction de lecture: Tu �cris les valeurs d�-DCT-is�es dans les bitmap bits du bitmap destination dans le m�me ordre que la fonction de lectures les avait lues...

**meera** · 19/09/2006, 15h35

moi je veux que mon marque constitue des valeurs entre 0 et 255 al�atoire
je te mentre ici la photo de la marque
je la pris parmatlab

**meera** · 19/09/2006, 15h46

Tu �cris les valeurs d�-DCT-is�es dans les bitmap bits du bitmap destination dans le m�me ordre que la fonction de lectures les avait lues...

j'ai pas bien compris

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
 
BOOL Destination(
  BYTE eMatrice[8][8],      //[in] Matrice 8*8 de l'entrééé
 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
 VOID const *pcBitmapBits, //[out] Données (pixels) du bitmap 32bits à afficher 
 
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(eMatrice==NULL)
		return FALSE;
 
 
	//Parcours de la zone 8*8
	for(int  xx=0 ; xx<8 ; xx++)
	{
		for( int yy=0 ; yy<8 ; yy++)
                       *pcBitmapBits=       pMatrice[xx+8*x][yy+8*y] !!!!!!!!!!!!!
.
.
.
 
 
		{	return TRUE;
}

**M�dinoc** · 19/09/2006, 17h49

Tu devrais te servir d'un pointeurs sur RGBQUAD pour �crire les donn�es...

Et cette fois-ci, le pointeur de destination ne devra pas �tre const, alors que celui vers la matrice devra l'�tre...

**meera** · 19/09/2006, 18h11

franchement j'ai pas compris ce que tu me dis!!!
moi le pb que je rencontre c que : cmt je puisse affecter les valeurs de la matice eb bitmap

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
 
	RGBQUAD  *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 *pcRgb = pcRgbBits ;
			switch(eCouleur)
			{
			case ROUGE: pcRgb->rgbRed= pMatrice[xx+8*x][yy+8*y] ;   break; // !!!!!!!!!!!!!

vraiment, je sais plus

**M�dinoc** · 20/09/2006, 09h11

Oui, ben �a m'a l'air pas trop mal, �a...
Maintenant, tu peux supprimer les "const" en trop, les "c" qui vont avec dans les noms des pointeurs, et les rajouter l� o� il faut...

**meera** · 20/09/2006, 13h11

bonjour
est ce c comme �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
 
BOOL Destination(
  BYTE  const eMatrice[8][8],      //[in] Matrice 8*8 de l'entrééé
 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
 VOID  *pcBitmapBits, //[out] Données (pixels) du bitmap 32bits à afficher 
 enum e_couleur eCouleur   //[in] Couleur à lire
 )
{
	if(pcBitmapBits==NULL)
		return FALSE;
	if(eMatrice==NULL)
		return FALSE;
 
	RGBQUAD  *pcRgbBits = static_cast< RGBQUAD  * >(pcBitmapBits);
 
	//Parcours de la zone 8*8
	for(int  xx=0 ; xx<8 ; xx++)
	{
		for( int yy=0 ; yy<8 ; yy++)
		{
							RGBQUAD  *pcRgb = pcRgbBits ;
			switch(eCouleur)
			{
			case ROUGE: pcRgb->rgbRed= pMatrice[xx+8*x][yy+8*y] ;   break;
 
				//	case VERT:  pMatrice[xx+8*x][yy+8*y] = pcRgb->rgbGreen; break;
		//	case BLEU:  pMatrice[xx+8*x][yy+8*y] = pcRgb->rgbBlue;  break;
			}
 
		}
	}
return TRUE;
}

**M�dinoc** · 20/09/2006, 13h53

On dirait bien.

Juste, pour la petite histoire, le "c" � enlever dans pcBitmapBits...

**meera** · 20/09/2006, 13h55

ok je te remercie
je vais ex�cuter le programme pour voir que qu'il me donne

**meera** · 20/09/2006, 14h45

j'ai fait l'execution elle me donne 0 erreurs avec qlq warning bien sur
mais quand j'affiche une bitmap et je click sur bouton affiche DCt qui traite ts ces programmes
j'obtien une carreaux noir

qlq chose ne marche pas bien
�a peut que l'image que j'ai choisit n'etait pas de 32 bits, + j'ai fait les traitement tt simplement sur le rouge

stp pour traiter ts les couleurs est cela 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
 
 
 
if(BmSrcInfo->biBitCount==32) // 32 bits
	{
 
 
 for (int x=0 ; x<nb_mat8_larg ; x++)
	{
	for (int y=0 ; y<nb_mat8_haut ; y++)
		{
                             for( eCouleur=0;eCouleur<3;eCouleur++)
                                   {
		//  -/----------------\-
		BYTE M88[8][8];
		short M88DCT[8][8];
		BYTE matrand[8][8];
		BYTE Addmat[8][8];
		short M88IDCT[8][8];
		Get88Matrix32(lpSrcBits, BmSrcInfo->biWidth, x, y, M88, eCouleur);
 		DCTMatrice(M88 , M88DCT);
		generation_random( matrand);
	    Add_Random( M88DCT, matrand,  Addmat);
		IDCTMatrice(Addmat , M88IDCT);
		 Destination(M88IDCT,BmSrcInfo->biWidth, x, y, lpDestBits, eCouleur);
 
	}
		}
 
}

**M�dinoc** · 20/09/2006, 16h49

En fait, j'ai plut�t des doutes sur tes fonctions de DCT et de watermarking...

Pour commencer, tu devrais voir si tu arrives � faire DCT et DCT inverse correctement et en couleurs sans passer par le Watermarking. Et il faut t'assurer que le bitmap soit 32bits. Au pire s'il ne l'est pas, tu peux copier l'ancien bitmap vers un bitmap 32bits (avec les fonctions graphiques ou avec SetDIBits())...

Tes fonctions avec une troisi�me boucle ont des chances de marcher...

**meera** · 20/09/2006, 17h22

moi je connais la transformation de bitmap vers 24 ,8,.par exemple

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
 
 pDoc->m_image.Dither(IMG_TYPE_COL256 ,TRUE);      //16 bits
 pDoc->m_image.Dither(IMG_TYPE_COL24,TRUE);         // 24 bits

j'utilise la fonction Diteher c d�ja pr�d�finit ds la biblioth�que CImage

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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
#if defined(CIMAGE_DITHERING)
 
// Effectue le dithering de l'image, de m_nTypeImage vers nNewType
BOOL CImage::Dither(int nNewType, BOOL bDither)
{
	BOOL bRet=FALSE;
 
	if(!m_hDib)
		return FALSE;
 
	// Le type demandé est-il connu?
	if(nNewType<IMG_TYPE_COL24 || nNewType>IMG_TYPE_NB)
		return FALSE;
 
	// Cas spécial: image source en 16 ou 32 bits. Formats non supportés -> passage en 24 bits avant le dithering
	if(GetBPP()==32 || GetBPP()==16)
	{
		LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
		LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
		// Détermination du nombre de couleurs
		int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : NULL;
		int nScanWidthSrc = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);
 
		// 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);
 
		// Largeur des lignes du nouveau bitmap en 24 bits
		int nScanWidthDest = WIDTHBYTES(BmSrcInfo->biWidth * 24);
 
		// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
		HGLOBAL hNewDib=GlobalAlloc(GHND, BmSrcInfo->biSize+(nScanWidthDest*BmSrcInfo->biHeight));
		if(!hNewDib)
		{
			GlobalUnlock(m_hDib);
			return FALSE;  // Pas assez de mémoire ou problème
		}
 
		// Adresse du nouveau bitmap
		LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
		LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
		// Copie du Header ds le nouveau bitmap
		CopyMemory(biDest, biSrc, BmSrcInfo->biSize);
 
		// Changement des paramètres sur le nouveau bitmap
		BmDestInfo->biBitCount = 24;
		BmDestInfo->biClrUsed = 0;
		BmDestInfo->biSizeImage = nScanWidthDest*BmDestInfo->biHeight;
 
		// Détermination de la zone des bits de l'image source et largeur lignes en octets
		BYTE* lpDestBits = (BYTE*)BmDestInfo+BmDestInfo->biSize;
 
		// Copie Pixel à pixel de l'ancien vers le nouveau bitmap
		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
				}
			}
		}
		else  // 16 vers 24 bits (32000 couleurs, pas 65000)
		{
			for(int y=0; y<BmDestInfo->biHeight; y++)
			{
				WORD* lpSrc = (WORD*)(lpSrcBits + (y*nScanWidthSrc));
				BYTE* lpDest = lpDestBits + (y*nScanWidthDest);
				for(int x=0; x<BmDestInfo->biWidth; x++)
				{
					*(lpDest++) = (BYTE)((*(lpSrc) & 0x1F) * 8.2258 + 0.5);
					*(lpDest++) = (BYTE)(((*(lpSrc)>>5) & 0x1F) * 8.2258 + 0.5);
					*(lpDest++) = (BYTE)(((*(lpSrc)>>10) & 0x1F) * 8.2258 + 0.5);
					lpSrc++; // on passe au pixel suivant
				}
			}
		}
 
		// Pas de couleur transparente en 32 ou 16 bits
		m_dwTransparentColor = NULL;
 
		GlobalUnlock(m_hDib);
		GlobalUnlock(hNewDib);
		GlobalFree(m_hDib);
 
		// On supprime l'ancien DIB et on le remplace par le nouveau
		m_hDib = hNewDib;
		m_nTypeImage = IMG_TYPE_COL24;
	}
 
	// Pas de dithering si le type demandé est celui en cours (ou que la transformation en 24 bits a suffit)
	if(nNewType==m_nTypeImage)
		return TRUE;
 
	// Si type actuel non connu -> on le cherche (couleur par défaut)
	if(m_nTypeImage==IMG_TYPE_UNKNOWN)
		m_nTypeImage = GetDefaultType(GetBPP());
 
	// Si transparent -> On retrouve la position d'un pixel transparent
	BOOL bOk = FALSE;
	BOOL bDoIt = FALSE;
	int xTrans = 0;
	int yTrans = 0;
	if(m_dwTransparentColor & 0x80000000L)
	{
		LPBITMAPINFOHEADER BmInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
		int nColors = BmInfo->biClrUsed ? BmInfo->biClrUsed : 0x1FF & (1 << BmInfo->biBitCount);
		BYTE* lpBits = (BYTE*)BmInfo+BmInfo->biSize+nColors*sizeof(RGBQUAD);
		int nScanWidth = WIDTHBYTES(BmInfo->biWidth * BmInfo->biBitCount);
		DWORD dwColor = m_dwTransparentColor & 0x7FFFFFFFL;
		for(yTrans=0; yTrans<BmInfo->biHeight && !bOk; yTrans++)
			for(int xTrans=0; xTrans<BmInfo->biWidth && !bOk; xTrans++)
				if(dwColor == GetPixel(xTrans, yTrans, BmInfo, nColors, nScanWidth, lpBits))
					bOk = TRUE;
		GlobalUnlock(m_hDib);
	}
 
	// De 24 bits vers tous les autres
	if(m_nTypeImage==IMG_TYPE_COL24)
	{
		switch(nNewType)
		{
			case IMG_TYPE_COL256:
				bRet = DitherQuantize(256, bDither);
				if(bRet)
					bDoIt = TRUE;
				break;
			case IMG_TYPE_COL16:
				bRet = DitherQuantize(16, bDither);
				if(bRet)
					bDoIt = TRUE;
				break;
			case IMG_TYPE_NG256:
				bRet = DitherGrayScale();
				// Cas particulier du 24 bits vers
				//   256NG: réduction facile, sans dithering
				{
					LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
					LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
					// Si != de 24 bits -> c'est pas bon
					if(BmSrcInfo->biBitCount!=24)
					{
						GlobalUnlock(m_hDib);
						return FALSE;  // Pas assez de mémoire ou problème
					}
 
					// Détermination du nombre de couleurs
					int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : 0x1FF & (1 << BmSrcInfo->biBitCount);
 
					// 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 nScanWidthSrc = WIDTHBYTES(BmSrcInfo->biWidth * BmSrcInfo->biBitCount);
 
					// Largeur des lignes du nouveau bitmap
					int nScanWidthDest = WIDTHBYTES(BmSrcInfo->biWidth * 8);
 
					// On crée une nouvelle zone mémoire pour accueillir le nouveau bitmap
					HGLOBAL hNewDib=GlobalAlloc(GHND, BmSrcInfo->biSize+256*sizeof(RGBQUAD)
						+ (nScanWidthDest*BmSrcInfo->biHeight));
					if(!hNewDib)
					{
						GlobalUnlock(m_hDib);
						return FALSE;  // Pas assez de mémoire ou problème
					}
 
					// Adresse du nouveau bitmap
					LPBITMAPINFOHEADER BmDestInfo=(LPBITMAPINFOHEADER)GlobalLock(hNewDib);
					LPBITMAPINFO biDest=(LPBITMAPINFO)BmDestInfo;
 
					// Copie du Header ds le nouveau bitmap
					CopyMemory(biDest, biSrc, BmSrcInfo->biSize);
 
					// Création palette en 256NG
					for(int i=0; i<256; i++)
						biDest->bmiColors[i].rgbRed = biDest->bmiColors[i].rgbGreen
							= biDest->bmiColors[i].rgbBlue = i;
 
					// Changement de paramètres ds la structure
					BmDestInfo->biBitCount = 8;
					BmDestInfo->biClrImportant = BmDestInfo->biClrUsed = 256;
					BmDestInfo->biSizeImage = nScanWidthDest*BmSrcInfo->biHeight;
 
					// Détermination de la zone des bits de l'image source et largeur lignes en octets
					BYTE* lpDestBits = (BYTE*)BmDestInfo+BmDestInfo->biSize+256*sizeof(RGBQUAD);
 
					// Copie des octets
					BYTE* lpDest = lpDestBits;
					BYTE* lpSrc = lpSrcBits;
					int j;
					for(i=0; i<BmSrcInfo->biHeight; i++)
					{
						for(j=0; j<BmSrcInfo->biWidth; j++)
						{
							*(lpDest++) = *lpSrc;
							lpSrc += 3;
						}
						lpDestBits += nScanWidthDest;
						lpSrcBits += nScanWidthSrc;
						lpDest = lpDestBits;
						lpSrc = lpSrcBits;
					}
					GlobalUnlock(m_hDib);
					GlobalUnlock(hNewDib);
					GlobalFree(m_hDib);
					m_hDib = hNewDib;
					bRet = TRUE;
				}
				break;
			case IMG_TYPE_NG16:
				if(bRet = DitherQuantize(16, bDither))
					if(bRet = DitherGrayScale())
						bDoIt = TRUE;
				break;
			case IMG_TYPE_NB:
				if(bRet = DitherQuantize(2, bDither))
					m_dwTransparentColor = NULL;
				break;
		}
	}
                .
                .
                .
              }

mais l'inverse ( ��d de 8,16,24, ==>32bits) je sais plus

cmt je px utiliser la fonction SetDIBits())...

vc++ & matrice & image

Visual C++

Discussions similaires

Partager

Partager