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

**meera** · 13/09/2006, 18h18

j'ai trouvé cette algorithme de RLE,
ce site décrit l'algorithme RLE
http://translate.google.com/translat...l%3Dfr%26lr%3D

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
 
 
int compressionRLE(char tab[],char tabcompresse[]) 
{ 
    int i,nbrepet=1,position=0,j=0; 
 
        for (i=0;i<NB_CARACTERES_MAX;i++) 
        { 
            nbrepet=1;     
            if (tab[i]==tab[i+1])             /*teste si les valeurs qui se suivent*/ 
            {                             /*sont identiques*/ 
 
                while (tab[i]==tab[i+1]) /*compte le nombre de valeurs identiques*/ 
                {                 /*se suivant*/ 
                            nbrepet=nbrepet+1; 
                            i++; 
                        } 
                                             /*écrit les données de tabcompresse*/ 
                        tabcompresse[position]='$';     
                        tabcompresse[position+1]=(char)nbrepet+'0'; 
                        tabcompresse[position+2]=tab[i]; 
 
                        position=position+3; /*positionnement 3 cases aprés sur tabcompresse*/ 
                } 
 
            else 
                { 
                            /*si les valeurs se suivant dans tab ne sont pas identiques*/ 
                    tabcompresse[position]=tab[i];    /*écrit la valeur unique dans*/ 
                    position=position+1;            /* tabcompresse*/ 
                } 
        } 
}

**Médinoc** · 14/09/2006, 11h01

Je ne connais pas assez pour me plonger là-dedans.

Déjà, essaie de faire marcher l'enregistrement non-compressé. N'essaie de compresser que lorsque tout le reste marchera.

**meera** · 14/09/2006, 12h37

moi je fais l'exécution, tout marche ( 0 erreurs),ça de coté informatique
par contre pour voir si tt ce quon a fait marche bien,il faut terminer tt l'algorithme et voir si on a arrivé à afficher une image compressé

**Médinoc** · 14/09/2006, 13h21

Ben, pour pouvoir l'afficher, il faut

Soit enregistrer l'image au format JPEG (que je ne connais pas)
Soit faire l'algorithme inverse pour retransformer les données compressées en bitmap.

**meera** · 14/09/2006, 13h37

oui je pense qu'il faut enregistrer l'image au format Jpeg, pour pouvoir l'affiché compressée
sinon, (si on fait la decompression) , on n'affiche pas l'image compressée) ,on reterouvenotre image source

moi meme je sais pas cmt l'enregistrer en ce format

j'ai trouvé c code ds la librairie que j'utilise mais j'ai pas comprs grandes choses:

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
 
// Sauvegarde d'une image au format JPEG
BOOL CImage::SaveJPEG(HANDLE hFile, int nQuality)
{
	if(!m_hDib)
		return FALSE;
 
	BOOL bGrayScale = FALSE;
 
	// Vérification qu'il s'agit bien d'une image en 256 NG ou 24 bits
	LPBITMAPINFO bi = (LPBITMAPINFO)GlobalLock(m_hDib);
 
	if(bi->bmiHeader.biBitCount<8)
	{
		GlobalUnlock(m_hDib);
		return FALSE;
	}
 
	int nColors = bi->bmiHeader.biClrUsed ? bi->bmiHeader.biClrUsed : 0x1FF & (1 << bi->bmiHeader.biBitCount);
	if(bi->bmiHeader.biBitCount!=24)
	{
		bGrayScale = TRUE;
		for(int i=0; i<nColors; i++)
			if(bi->bmiColors[i].rgbRed!=bi->bmiColors[i].rgbGreen
				|| bi->bmiColors[i].rgbRed !=bi->bmiColors[i].rgbBlue)
			{
				// Image en couleur avec palettes -> pas supporté
				GlobalUnlock(m_hDib);
				return FALSE;
			}
	}
 
	int nLineSize = bi->bmiHeader.biWidth*(bGrayScale?1:3);
	BYTE* pScanLine = (BYTE*)malloc(nLineSize);
	if(!pScanLine)
	{
		GlobalUnlock(m_hDib);
		return FALSE;
	}
 
	jpeg_compress_struct cinfo;
	jpeg_error_mgr jerr;
 
	cinfo.err = jpeg_std_error(&jerr);
	jerr.error_exit = CImageJpegErrorExit;  // Register custom error manager.
 
	typedef struct
	{
		void* pBuffer;
		HANDLE hFile;
	} JPegData;
 
	JPegData JData;
	JData.pBuffer = m_LoadBuffer;
	JData.hFile = hFile;
 
	try
	{
		jpeg_create_compress(&cinfo);
 
		// Specify data destination
		jpeg_destination_mgr dest;
		dest.next_output_byte = (JOCTET *)m_LoadBuffer;
		dest.free_in_buffer = SIZE_SAVE_BUFFER-4;
		dest.init_destination = CImageJpegInitDest;
		dest.empty_output_buffer = CImageJpegEmptyOutputBuffer;
		dest.term_destination = CImageJpegTermDest;
		cinfo.dest = &dest;
		cinfo.client_data = &JData;
 
		// Spécifications de l'image
		cinfo.image_width = bi->bmiHeader.biWidth;
		cinfo.image_height = bi->bmiHeader.biHeight;
		cinfo.input_components = bGrayScale ? 1 : 3;
		cinfo.in_color_space = bGrayScale ? JCS_GRAYSCALE : JCS_RGB;
		jpeg_set_defaults(&cinfo);
 
		// Affinage des paramètres de sortie
		jpeg_set_quality(&cinfo, nQuality, TRUE);
		cinfo.dct_method = JDCT_ISLOW;
		cinfo.optimize_coding = TRUE;
		cinfo.density_unit = 1;
		cinfo.X_density = (int)PPM2DPI(bi->bmiHeader.biXPelsPerMeter);
		cinfo.Y_density = (int)PPM2DPI(bi->bmiHeader.biYPelsPerMeter);
 
		// Start compressor
		jpeg_start_compress(&cinfo, TRUE);
 
		// Ecriture successive des lignes
		int nScanWidth = WIDTHBYTES(bi->bmiHeader.biWidth * bi->bmiHeader.biBitCount);
		BYTE* pSrcLine = (BYTE*)bi+bi->bmiHeader.biSize+nColors*sizeof(RGBQUAD)
			+nScanWidth*(bi->bmiHeader.biHeight-1);
		while(cinfo.next_scanline < cinfo.image_height)
		{
			memcpy(pScanLine, pSrcLine, nLineSize);
			if(bGrayScale)
				for(int i=0; i<nLineSize; i++)
					pScanLine[i] = bi->bmiColors[pScanLine[i]].rgbRed;
			else
			{
				BYTE cDummy;
				for(int i=0; i<nLineSize; i+=3)
				{
					cDummy = *(pScanLine+i);
					*(pScanLine+i) = *(pScanLine+i+2);
					*(pScanLine+i+2) = cDummy;
				}
			}
			jpeg_write_scanlines(&cinfo, &pScanLine, 1);
			pSrcLine -= nScanWidth;
		}
 
		// Finish compression
		jpeg_finish_compress(&cinfo);
 
		// Release JPEG decompression object
		jpeg_destroy_compress(&cinfo);
 
		free(pScanLine);
		GlobalUnlock(m_hDib);
 
		return TRUE;
	}
	catch(...)
	{
		jpeg_abort_compress(&cinfo);
		GlobalUnlock(m_hDib);
		free(pScanLine);
		return FALSE;
	}
}
 
// Init de la destination JPEG -> ne fait rien
METHODDEF(void) CImageJpegInitDest(j_compress_ptr cinfo)
{
}
 
// Ecrit le buffer de sauvegarde sur disque
METHODDEF(boolean) CImageJpegEmptyOutputBuffer(j_compress_ptr cinfo)
{
	typedef struct
	{
		void* pBuffer;
		HANDLE hFile;
	} JPegData;
	DWORD dwByteWrite;
 
	JPegData* JData = (JPegData*)cinfo->client_data;
	WriteFile(JData->hFile, JData->pBuffer, SIZE_SAVE_BUFFER-4,
		&dwByteWrite, NULL);
	memset(JData->pBuffer, 0, SIZE_SAVE_BUFFER);
	cinfo->dest->next_output_byte = (JOCTET *)JData->pBuffer;
	cinfo->dest->free_in_buffer = SIZE_SAVE_BUFFER-4;
 
	return TRUE;
}
 
// Termine source ou destination JPeg -> ne fait rien
METHODDEF(void) CImageJpegTermDest(j_compress_ptr cinfo)
{
	typedef struct
	{
		void* pBuffer;
		HANDLE hFile;
	} JPegData;
	DWORD dwByteWrite;
 
	JPegData* JData = (JPegData*)cinfo->client_data;
	int nSize = (int)((BYTE*)cinfo->dest->next_output_byte - (BYTE*)JData->pBuffer);
	if(nSize<1 || nSize>SIZE_SAVE_BUFFER-4)
		return;
	WriteFile(JData->hFile, JData->pBuffer, nSize, &dwByteWrite, NULL);
}
#endif  // CIMAGE_USE_JPEG

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

**meera** · 20/09/2006, 23h57

quand j'ai lu la documentation de ce classe , je trouve que les images 32bits non supportable ds ce classe

citation:

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
 
Classe "CImage"
Image.cpp - Image.h :
Version 2.7
Réalisée par Philippe MIGNARD
Email : philippe.mignard@hotpop.com
CImage est une classe maintenant un DIB (image indépendante du périphérique utilisé) et toutes les fonctions nécessaires au travail sur ce DIB. Les possibilités de cette classe sont :
•	Support des images 1, 4, 8 et 24 bits/pixel (toutes les fonctions supportent tous les types d’images, sauf sauvegarde sur disque selon le type d’image et le type de fichier de sauvegarde demandé), en couleur ou niveaux de gris pour les images 4 et 8 bits/pixel. Les filtres 24 bits ne sont applicables que sur des images en 24 bits.
•	Affichage de l’image avec plein d’options disponibles (clip, stretch avec ratio ou non, transparent...) sur l’écran (fonctions rapides de Video For Windows ou GDI au choix) ou sur imprimante (fonctions GDI).
•	Chargement et sauvegarde à partir du disque d’images de type BMP, DIB, BMP OS/2, RLE, PCX, TGA (Targa), GIF, JPEG*, TIFF*, PNG*.
* Nécessitent l’utilisation de la librairie externe
•	Chargement à partir d’une ressource (tout format).
•	Copie de l’image dans le Presse-papiers et inversement.
•	Miroir horizontal et vertical de l’image.
•	Rotation de 90°, 180° ou 270°de l’image.
•	Passage de l’image en négatif.
•	Sélection d’un canal RVB.
•	Ajustement du contraste et de la lumière.
•	Correction des couleurs (linéairement), de la saturation, de la teinte et du facteur gamma.
•	Dithering, selon la méthode Floyd-Steinberg en 2 passes pour la réduction de couleurs, mais peut passer de n’importe quel type d’image à n’importe quel autre.
•	Initialisation facile, copie de classe à classe ou de Handle à classe...
•	Compilation sélective selon les besoins du programmeur à l’aide de #define dans le stdafx.h du projet.

**Médinoc** · 21/09/2006, 09h16

Où as-tu trouvé cela?
Tu veux dire que tu n'utilises pas la CImage de ATL/MFC ?
CImage est supposée être définie dans atlimage.h...

**meera** · 21/09/2006, 11h25

bonjour
mo j'ai tétéchargé cette bibliothéque à partir de net, cette une librairie contient beaucoup def fonctions de traitement d'image déja prédéfini:
Image Doc (Français).doc
voila le doc
si tu vx que jet'envoie la bibliothéque ok

vc++ & matrice & image

Visual C++

Vue hybride

Discussions similaires

Partager

Partager