vc++ & matrice & image

**meera** · 02/09/2006, 17h38

bonjour
j'ai fait un programme sur matlab pour tester une algorithme
mais quand je le reprogramme en vc++, j'ai rencontré quelques pb
par exemple,matlab considére l'image comme une matrice
par contre en vc++ n'est plus le cas

par exemple je veux convertir ce code matlab en vc+++

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
 
 
 RGBuint8 = imread('CLOWN.BMP');  % lecture de l'image bmp couleur
 matrice = double(RGBuint8);   %conversion des coefficients au format double
 qualite=10;
% en vc++ c pas le cas , càd j'ouvre l'image suivant une chemin
%recuperation des dimensions de la matrice (hauteur, largeur)
dim = size(matrice(:,:,1));
 
%on suppose que les images ont des dimensions qui sont des multiples de 8       
%nombre de matrice 8x8 dans la largeur de l'image
nb_mat8_larg = dim(1)/8;
%nombre de matrice 8x8 dans la hauteur de l'image
nb_mat8_haut = dim(2)/8;
 
%fabrication de la matrice 8x8 de quantification
M_Q = mat_quant(qualite);
 
for k=1:3
    for i=0:(nb_mat8_larg-1)
	    for j=0:(nb_mat8_haut-1)
		  %matrice 8x8 temporaire sur laquelle on va faire la DCT
		  M88 = matrice((1+8*i):(8*(i+1)),(1+8*j):(8*(j+1)),k);
end;
end;

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
 
function[res]=ajoute(m,valeur)
%fonction qui permet d'ajouter ou de retrancher une certaine valeur à tous
%les coefficients d'une matrice
%parametres d'entree
%   -m la matrice sur laquelle va porter le calcul
%   -valeur la valeur a ajouter (ou retrancher si nombre negatif)
%parametres de sortie
%   -res la matrice du resultat
 
 
%recuperation de la taille de la matrice
taille = size(m);
 
%construction d'une matrice que l'on va ajouter à m
temp = ones(taille(1),taille(2)) * valeur;
 
res = m + temp;

par conte en vc++ j'ecris:

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
 
 
OOL CImage::Compression(int qualite)
{
	 if(!m_hDib)
		return FALSE;	// DIB non valide
	 if(!m_hDib)
		return FALSE;	// DIB non valide
 
	LPBITMAPINFOHEADER BmSrcInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
	LPBITMAPINFO biSrc=(LPBITMAPINFO)BmSrcInfo;
 
 
	// Détermination du nombre de couleurs
	int nColors = BmSrcInfo->biClrUsed ? BmSrcInfo->biClrUsed : 0x1FF & (1 << BmSrcInfo->biBitCount);
 
//	on suppose que les images ont des dimensions qui sont des multiples de 8       
	//nombre de matrice 8x8 dans la largeur de l'image
		nb_mat8_larg = BmInfo->biHeight/8;
	//nombre de matrice 8x8 dans la hauteur de l'image
		nb_mat8_haut = BmInfo->biWidth/8

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
 
// Ramène la largeur du bitmap
int CImage::GetWidth() const
{
	int nRet=NULL;
 
	if(m_hDib)
	{
		LPBITMAPINFOHEADER BmInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
		nRet=BmInfo->biWidth;
		GlobalUnlock(m_hDib);
	}
	return nRet;
}
 
// Ramène la hauteur du bitmap
int CImage::GetHeight() const
{
	int nRet=NULL;
 
	if(m_hDib)
	{
		LPBITMAPINFOHEADER BmInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
		nRet=BmInfo->biHeight;
		GlobalUnlock(m_hDib);
	}
	return nRet;
}
 
voila j'ai pas arriver à completer le code en vc++
cmment je convertis la boucle pour  disingner que 3 signifie chaque couleur (vert, bleu, rouge)
 
est quelqu'un peut me completer le code:cry: :cry:

**meera** · 02/09/2006, 17h41

comme vous voyez j'ai pas arriver à convertir le code matlab en vc++
par exemple en matle la premiere boucle
for k=1:3
designe que je fais le traitement sur chaque couler ( bleu, rouge,vert)
par contre en vc++, je sais pas commet j'accéde au couleur et .....

est quelqu'un me converir le code pour me voir comment il les considérent
merci d'avance

**Médinoc** · 02/09/2006, 18h27

Eh bien, ça dépend du mode de l'image.
Mais si on travaille en bitmap 32 bits (seul le système est généralement capable de les afficher, mais c'est plus facile en interne. On peut les convertir en 24 bits par la suite), les données sont un tableau de mots de 32 bits. Et c'est tant mieux, car les lignes d'une image doivent être DWORD-aligned.
Chaque pixel peut être également considéré comme une structure RGBQUAD, qui fait 32bits également.

Donc en clair, les données d'un bitmap 32 bits sont un tableau de structures RGBQUAD...

**meera** · 02/09/2006, 19h15

j'ai pas compris exactement ce que vous écrit
par exmple j'ai ce code en matlab

Code :

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

1
2
3
4
 
matrice = imread('CLOWN.BMP');
dim = size(matrice(:,:,1));
nb_mat8_larg = dim(1)/8;

comment je l'reécrit en vc++
sachant uqe l'image est une bitmap 24bits
et j'ai les fonctions GetWidth() et GetHeight() qui detérminent la largeur el hauteur de l'image
???

**Médinoc** · 02/09/2006, 20h20

Je ne comprends pas le code matlab, mais c'est pratiquement impossible d'accéder directement aux pixels d'une image 24bits.
Je pense que le mieux serait de la convertir en image 32 bits. La fonction CreateDIBSection() permettrait de créer une image 32bits, et la fonction SetDIBits() permettrait de convertir les données 24bits existantes vers l'image 32 bits.
(Ou bien, on pourrait aussi faire une recopie de l'image, mais il y a plus de code à mettre, car il faudra utiliser des Device Context (DC)...)

Ensuite, l'image 32bits pourra être manipulée plus facilement en mémoire.

**meera** · 02/09/2006, 21h44

supposons que l'image est de 32 bits
moi je sais pas comment accéder à chaque pixel de l'image
en matlab , c simple , 'image se comporte comme une matrice x(i,j,k)
i et j les dimensions
k luminance

mais en vc++ comment se comporte une image!!!!

**Médinoc** · 02/09/2006, 23h38

Ce n'est pas "en VC++", c'est "en .bmp".

Mais en fait, ça dépend de ce que tu veux faire exactement. Tu peux manipuler l'image en tant que données binaires, ou la manipuler en tant qu'image et utiliser les fonctions de dessin...

En données binaires, tu peux accéder aux pixels d'un bitmap 32 bits à partir d'un pointeur sur les données.

Code :

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

1
2
RGBQUAD *pPixels = GetPointeurSurLesPixels();
pPixels[ y*largeur + x ].rgbRed = 42;

**meera** · 03/09/2006, 00h25

ah comme ci le cas:

Code :

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

1
2
3
4
5
6
 
{
		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;
	}

t est ce que si la meme chose si je veux acceder à une suele couleur soit le vert , le bleu ou bien le rouge!!!

**Médinoc** · 03/09/2006, 11h08

Dans un bitmap 32bits, c'est très facile: Les champs de la structure RGBQUAD sont là pour ça.

**meera** · 03/09/2006, 19h56

si je veux faire des operations sut les pixeles d'image
par exemple multiplier la hauteur par 2 et soustraire la longeur de 10
commt je le fais????

**Médinoc** · 03/09/2006, 21h06

Eh bien pour cela, je verrais plutôt les fonctions de gestion d'image.
Tu dois alors te renseigner sur CreateDC(), GetDC()+CreateCompatibleDC(), SelectObject(), puis les fonctions de dessin comme BitBlt(), StretchBlt(), MoveToEx()+LineTo(), FillRect(), etc.

**meera** · 03/09/2006, 21h45

aaaaaaaah
toutes ces fonctions!!!!!

pour une simple operation, c dommage

**Médinoc** · 03/09/2006, 22h24

Euh... Redimensionner une image, ce n'est pas une simple opération.
Pour cela, on peut utiliser StretchBlt(), mais il faut d'abord que l'image soit placée dans un Device Context (DC) pour cela (toutes les opérations graphiques se font sur des DC).

Bien sûr, tu peux toujours faire des trucs en travaillant directement sur la mémoire (mais le mode 24bits est le plus impraticable pour ça)...

**meera** · 03/09/2006, 23h19

franchement, j'ai pas compris ts que tu as dit

car je suis débutante en vc++
moi je prend une image
voila le code

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
 
LPBITMAPINFOHEADER BmInfo=(LPBITMAPINFOHEADER)GlobalLock(m_hDib);
// je devise la longueur et la hauteur de bitmap par 8
	int 	nb_mat8_larg = BmSrcInfo->biHeight/8;
	int     nb_mat8_haut = BmSrcInfo->biWidth/8;
 
// je fais une boucle
for (x=0:x(nb_mat8_larg-1;x++)
	    for (y=0:y(nb_mat8_haut-1;y++)
		{
// ici je sais pas ce que dois faire
//  pour chaque vaelur de x et y, je veus multiplier les dimensions de l'image par ce formulaire( je fais la DCT)
//  pour la longueur il doit etre comme ça  for (1+8*x)  to (8*(x+1))
 // pour largeur                                     for  (1+8*y)   to (8*(y+1)
 
 M88=lpDestBits[y*nScanWidth+x]????????????!!!!!!!

je sais commet faire

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

OK...

C'est normal que ta formule ignore le premier pixel (coordonnée zéro) ?
Je suppose que non.

Un petit pseudocode (avec un bitmap 32bits) :

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
//Note: là, on suppose que les dimensions de l'image sont multiples se 8,
//sinon ça arrondit aux 8 inférieurs.
//Note: Height=hauteur, width=largeur...
int nb_mat8_haut = BmSrcInfo->biHeight/8;
int nb_mat8_larg = BmSrcInfo->biWidth/8;
 
LPBITMAPINFOHEADER pBmi = ...
LPVOID const pBits = ...
RGBQUAD * const pRgb = static_cast< RGBQUAD * >(pBits);
 
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 ];
				//Et après, tu fais ce que tu veux avec les valeurs
				//pointées par pPixel:
				pPixel->rgbRed ...
				}
			}
 
		}
	}

Et ça, ça ne marche qu'en 32bits. Avec un bitmap 24bits, on ne peut pas utiliser de RGBQUAD.

**meera** · 04/09/2006, 13h13

je te remercie du mon coeur
mais j'ai d'autre question

si je veux par exemple que l'image destintion reçcoit ces modificatons
q'on l'appele par exemple M88
et je veux de nouveau prendre ces dimensions pour completer les calculs
est ce si ossible faire

larg=M88.Width();
haut=M88.Height();

???

**Médinoc** · 04/09/2006, 13h17

Là, je n'arrive pas à comprendre ton post, ni ce que tu veux faire.
En tout cas, on ne change pas les dimensions d'un bitmap en claquant des doigts. Soit on utilise les fonctions de redimentionnement (plus exactement: De dessin redimensionné d'une image), soit on trafique soi-même la mémoire pour que ça "rentre"...

**meera** · 04/09/2006, 13h43

moi je fait la methode de compression jpeg grace à DCT( tranformée de cosinus discret)
donc je dois faire des operations sur l'images

**Médinoc** · 04/09/2006, 15h38

Tant que tu ne joues pas à changer les dimensions d'une image, tu peux faire ce que tu veux en bossant directement sur ses pixels en mémoire. C'est d'ailleurs la méthode la plus rapide (mais la plus chaude à programmer).

**meera** · 04/09/2006, 15h54

oui c ça , j'ai trop de calcul et des operations
et aussi je dois diviser l'image par une matrice
je sais pas si ce le cas comme matlab,
for( i=0;i<10;i++)
for(j=0;j<10;j++)
q[i][j]= (i+j)*10+5;

et ce possible de lmettre h=M88/Q????

car en ce dernier l'image se comporte comme une matice
donc ts ces operatios sont tres faciles!!!

vc++ & matrice & image

Visual C++

Discussions similaires

Partager

Partager