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