Discussion :

[Aliveli]

Bonjour,

Ce bout de code permet de convoluer une image mais
l'image de sortie (gaussian loaded) est tronqué seul apparaît une
petite (1/10) portion d'image en commençant du haut de la fenêtre. A quoi est-ce dû cette étrange chose, l'algorithme pour une image grayscale ou couleur diffère-t-elle?

Code c++ :

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
 
#include <stdio.h>
#include <cv.h>
#include <cvaux.h>
#include <highgui.h>
 
#define edge_w 3
#define edge_h 3    
 
float kernel[edge_w][edge_h]={{-1,-1,-1},{-1,9,-1},{-1,-1,-1}}; //filtre
 
int main()
{
	IplImage* test=0;
	CvCapture* capture = 0;
	IplImage* gaussian=0;
	cvNamedWindow( "Image normal loaded", 1 );
	cvNamedWindow( "gaussian loaded", 1 );
 
	IplImage* img = cvLoadImage("mandel.pgm",CV_LOAD_IMAGE_GRAYSCALE);
 
    int nl= img->height; // number of lines
    int nc= img->width * img->nChannels; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvSize(img->width,img->height), IPL_DEPTH_8U  ,1);
	//cvCopy(img, gs);
 
	// get the pointer to the image buffer
    unsigned char *data= reinterpret_cast<unsigned char *>(img->imageData);
	unsigned char *datags= reinterpret_cast<unsigned char *>(gs->imageData);
 
	cvShowImage( "Image normal loaded", img );
	cvWaitKey(2);
 
//	gs->origin = img->origin;
 
	Sleep(5000); 
 
    int pix,a,b; 
    for (int i=1; i<nl-1; i++)
	  {
		for (int j=0; j<nc-1; j++ /*j += image->nChannels*/) 
		 {
 
		   float accumulation = 0;
		   float weightsum = 0; 
 
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					  unsigned char k = data[(j+ii)*nc, i+jj];
					  accumulation += k * (kernel[1+ii][1+jj]);
					  weightsum += kernel[1+ii][1+jj];
 
					}//end loop i
				}//end loop j
				datags[i*nc,j] = unsigned char (accumulation/weightsum);
 
		 }
	  }
 
 
	cvShowImage( "gaussian loaded", gs );
	cvWaitKey(2);
 
	Sleep(2000);
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
 
	return 0;
}

Merci

[ToTo13]

Bonjour,

et si tu nous montrais une image résultat...

PS : c'est de l'opencv, donc je déplace la discussion.

[snowpy]

Code c++ :

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

1
2
3
	IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,1);

avec ca ?

[Aliveli]

Bonjour,

En ayant remplacer remplacer par cette ligne:
IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U ,1);

j'ai le même résultat.
Et voici l'image en annexe.

[snowpy]

ton image est en noir et blanc (.pgm) or pour convertir il a besoin de faire une moyenne particulière entre les 3 channels je doute qu'il apprécie, ceci n'est qu'une piste je ne vois pas grand chose d'autre
au cas ou :
http://en.wikipedia.org/wiki/Netpbm_format
donc il fait un truc bizarre vue que le niveau de gris est directement encodé dans le channel.

[Aliveli]

Désolé erreur de ma part, à l'image de mon dernier post j'ai pas mis le nouveau code. il s'agit cette fois d'une image couleur mais ouvert en niveau de gris, dont voici 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
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
 
#include <stdio.h>
#include <cv.h>
#include <cvaux.h>
#include <highgui.h>
 
#define edge_w 3
#define edge_h 3    
 
float kernel[edge_w][edge_h]={{-1,-1,-1},{-1,9,-1},{-1,-1,-1}}; //filtre
 
int main()
{
	IplImage* test=0;
	CvCapture* capture = 0;
	IplImage* gaussian=0;
	cvNamedWindow( "Image normal loaded", 1 );
	cvNamedWindow( "gaussian loaded", 1 );
 
	IplImage* img = cvLoadImage("baby-child.jpg",CV_LOAD_IMAGE_GRAYSCALE);
 
    int nl= img->height; // number of lines
    int nc= img->width * img->nChannels; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,1);
	//cvCopy(img, gs);
 
	// get the pointer to the image buffer
    unsigned char *data= reinterpret_cast<unsigned char *>(img->imageData);
	unsigned char *datags= reinterpret_cast<unsigned char *>(gs->imageData);
 
	cvShowImage( "Image normal loaded", img );
	cvWaitKey(2);
 
//	gs->origin = img->origin;
 
	Sleep(5000); 
 
    int pix,a,b; 
    for (int i=1; i<nl-1; i++)
	  {
		for (int j=0; j<nc-1; j++ /*j += image->nChannels*/) 
		 {
 
		   float accumulation = 0;
		   float weightsum = 0; 
 
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					  unsigned char k = data[(j+ii)*nc, i+jj];
					  accumulation += k * (kernel[1+ii][1+jj]);
					  weightsum += kernel[1+ii][1+jj];
 
					}//end loop i
				}//end loop j
				datags[i*nc,j] = unsigned char (accumulation/weightsum);
 
		 }
	  }
 
 
	cvShowImage( "gaussian loaded", gs );
	cvWaitKey(2000);
 
	Sleep(20);
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
 
	return 0;
}

Merci

[snowpy]

tu n'as pas le droit de faire un cvload sur une image couleur en lui disant qu'elle est grise.
Essaye plutot avec ca:

Code :

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

1
2
3
4
5
6
public:
static void cvCvtColor(
	IntPtr src, 
	IntPtr dst, 
	COLOR_CONVERSION code
)

et tu prends pour conversion BGR2GRAY

[Aliveli]

Ok,

J'ai cette fois une sortie différente avec l'ajout de cvCvtColor et le code voici :

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
 
int main()
{
	IplImage* test=0;
	CvCapture* capture = 0;
	IplImage* gaussian=0;
	//cvNamedWindow( "Image normal loaded", 1 );
	//cvNamedWindow( "gaussian loaded", 1 );
 	cvNamedWindow( "Image normal loadedgray", 1 );
	cvNamedWindow( "gaussian loadedgray", 1 );
 
	IplImage* img = cvLoadImage("baby-child.jpg",CV_LOAD_IMAGE_COLOR);
	IplImage* imggray = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,1);
 	cvCvtColor( img, imggray, CV_BGR2GRAY );
 
    int nl= img->height; // number of lines
    int nc= img->width * img->nChannels; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,3);
	IplImage* gsgray = cvCreateImage(cvGetSize(gs), IPL_DEPTH_8U  ,1);
 	cvCvtColor( gs, gsgray, CV_BGR2GRAY );
 
	//cvCopy(img, gs);
 
	// get the pointer to the image buffer
    unsigned char *data= reinterpret_cast<unsigned char *>(imggray->imageData);
	unsigned char *datags= reinterpret_cast<unsigned char *>(gsgray->imageData);
 
 	cvShowImage( "Image normal loadedgray", imggray );
	cvWaitKey(2);
//	gs->origin = img->origin;
 	Sleep(5000); 
 
    int pix,a,b; 
    for (int i=1; i<nl-1; i++)
	  {
		for (int j=0; j<nc-1; j++ /*j += image->nChannels*/) 
		 {
 		   float accumulation = 0;
		   float weightsum = 0; 
 
 			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
					  unsigned char k = data[(j+ii)*nc, i+jj];
					  accumulation += k * (kernel[1+ii][1+jj]);
					  weightsum += kernel[1+ii][1+jj];
 
					}//end loop i
				}//end loop j
				datags[i*nc,j] = unsigned char (accumulation/weightsum);
 		 }
	  }
 
 
//	cvShowImage( "gaussian loaded", gs );
//	cvWaitKey(2000);
 
	cvShowImage( "gaussian loadedgray", gsgray );
	cvWaitKey(2000);
 
	Sleep(20);
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
	cvReleaseImage(&imggray);
	cvReleaseImage(&gsgray);
 
	return 0;
}

[glen1789]

Je ne comprends vraiment pas d'ou viens l'erreur mais ca doit venir de l'utilisation du buffer.
En tous cas avec ce code ca devrait 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
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
 
//creation of the images
	IplImage *img = cvLoadImage("winter.jpg",CV_LOAD_IMAGE_GRAYSCALE);
	int nl= img->height; // number of lines
    int nc= img->width ; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvSize(img->width,img->height), IPL_DEPTH_8U  ,1);
	//cvCopy(img, gs);
 
	cvShowImage( "Image normal loaded", img );
	cvWaitKey(0);
 
 
 
    int pix,a,b; 
    for (int i=0; i<nl-1; i++)
	  {
		for (int j=0; j<nc-1; j++ /*j += image->nChannels*/) 
		 {
 
		   float accumulation = 0;
		   float weightsum = 0; 
			bool bord =false;
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					  //unsigned char k = data[(j+ii)*nc, i+jj];
					if( i + ii >0 && j+jj >0 && i+ ii <nl-1 && j+jj<nc-1)
					{
						int k = cvGetReal2D(img,i+ii,j+jj);
						accumulation += k * (kernel[1+ii][1+jj]);
						weightsum += kernel[1+ii][1+jj];
					}
					else
					{
						bord=true;
					}
 
				}//end loop i
			}
			//cout<< weightsum << endl;//end loop j
				//datags[i,j] = unsigned char (accumulation/weightsum);
					if(!bord)
					{
						cvSetReal2D(gs,i,j,(double)accumulation/weightsum);
					}
					else
					{
						cvSet2D(gs,i,j,cvGet2D(img,i,j));
					}
 
		 }
	  }
 
 
	cvShowImage( "gaussian loaded", gs );
	cvWaitKey(0);
 
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
 
	return 0;
 
}

[Aliveli]

Merci glen,

Effectivement avec ce code ça fonctionnne pour autant que l'image de départ soit réellement en grayscale (jai pris une image .pgm), autrement dit sans passer par les artifices de conversions couleur vers grayscale ça fonctionne bien.

Mais donc le problème viendrait peut-être des canaux RGB et le passage vers un seul canal ?

En tous cas il faut faire en sorte qu'on puisse avoir un code fonctionnel en grayscale pour continuer en couleur.

Le code ci-dessous fonctionne bien mais par quoi puis je remplacer les fonctions cvGet et cvSet d'opencv pour être dans le cas ou j'étais auparavant cad en bas niveau , en travaillant avec les arrays (*->imageData) ?

merci

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
 
 
float kernel[edge_w][edge_h]={{-1,-1,-1},{-1,9,-1},{-1,-1,-1}}; //filtre
 
int main()
{
	IplImage* test=0;
	CvCapture* capture = 0;
	IplImage* gaussian=0;
	cvNamedWindow( "Image normal loaded", 1 );
	cvNamedWindow( "gaussian loaded", 1 );
 
	IplImage* img = cvLoadImage("fichier.pgm",CV_LOAD_IMAGE_GRAYSCALE);
 
    int nl= img->height; // number of lines
    int nc= img->width ;//* img->nChannels; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,1);
 
	// get the pointer to the image buffer
    unsigned char *data= reinterpret_cast<unsigned char *>(img->imageData);
	unsigned char *datags= reinterpret_cast<unsigned char *>(gs->imageData);
 
	cvShowImage( "Image normal loaded", img );
	cvWaitKey(2);
 
	Sleep(5000); 
 
    int pix,a,b; 
    for (int i=0; i<nl-1; i++)
	{
		for (int j=0; j<nc-1; j++ ) //	for (int j=0; j<nc-1; j += image->nChannels) 
		{
			float accumulation = 0;
			float weightsum = 0; 
 
			bool bord = false;
 
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					if( (i + ii >0) && (j+jj >0) && (i+ ii <nl-1) && (j+jj<nc-1))
					{
						int k = cvGetReal2D(img,i+ii,j+jj);
						accumulation += k * (kernel[1+ii][1+jj]);
						weightsum += kernel[1+ii][1+jj];
					}
					else
					{
						bord=true;
					}
 
					if(!bord)
					{
						cvSetReal2D(gs,i,j,(double)accumulation/weightsum);
					}
					else
					{
						cvSet2D(gs,i,j,cvGet2D(img,i,j));
					}
 
				}//end loop i
			}//end loop j
		//int pos = (i * nc) + j;
		//	char res =sum/9;
		//	datags[j*1,i] = res;
		}
	}
 
	cvShowImage( "gaussian loaded", gs );
	cvWaitKey(2000);
 
	Sleep(20);
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
 
 
	return 0;
}

[Aliveli]

Afin d'être en bas niveau, j'ai modifier dans le code précédent cette portion de code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
....
		if(!bord)
		{
			//cvSetReal2D(gs,i,j,(double)accumulation/weightsum);
			datags[i*1,j] = (double)accumulation/weightsum;
		}
		else
		{
			//cvSet2D(gs,i,j,cvGet2D(img,i,j));
			datags[i*1,j] =  data[i,j];
		}
...

Mais j'ai à nouveau une fenêtre noire. Ce serait plus un problème de données dans le buffeur. Mais je ne vois toujours pas quoi ?

Merci

[snowpy]

hum si j'ai bien compris tu veux faire un gaussian mais pourquoi tu n'utilise pas tout simplement la fonction faite pour ca ? au lieu de le faire à la main avec le kernel

[Aliveli]

Snowpy effectivement avec ce bout de code je parviens à mes fins.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
	CvMat* kernelmat = cvCreateMat( 3, 3, CV_32FC1);
	cvmSet( kernelmat, 0,0, -1 ); 
	cvmSet( kernelmat, 0,1, -1 );
	cvmSet( kernelmat, 0,2, -1 );
	cvmSet( kernelmat, 1,0, -1 );
	cvmSet( kernelmat, 1,1,  9 );
	cvmSet( kernelmat, 1,2, -1 ); 
	cvmSet( kernelmat, 2,0, -1 );
	cvmSet( kernelmat, 2,1, -1 );
	cvmSet( kernelmat, 2,2, -1 );
	cvFilter2D( imggray, gsgray, kernelmat);

Mais je voudrais plus comprendre le code bas niveau et l'algorithme pour y arriver.

Pourrais tu me guider sur ce point ?


Merci

[Aliveli]

Ok,

Pour la fenêtre noire c'était dû au fait que je n'indexais pas bien l'accès au pixel
j'ai revu mon algo maintenant c'est bon avec le code ci-dessous je distingue bien les formes 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
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
 
float kernel[edge_w][edge_h]={{-1,-1,-1},{-1,9,-1},{-1,-1,-1}}; //filtre
 
 int round(float a) {
return int(a + 0.5);
}
 
int main()
{
	IplImage* test=0;
	CvCapture* capture = 0;
	IplImage* gaussian=0;
	cvNamedWindow( "Image normal loaded", 1 );
	cvNamedWindow( "gaussian loaded", 1 );
 
	IplImage* img = cvLoadImage("boat.jpg",CV_LOAD_IMAGE_GRAYSCALE);
 
    int nl= img->height; // number of lines
    int nc= img->width ;//* img->nChannels; // total number of element per line
    int step= img->widthStep; // effective width
 
	IplImage* gs = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U  ,1);
 
	// get the pointer to the image buffer
    unsigned char *data= reinterpret_cast<unsigned char *>(img->imageData);
	unsigned char *datags= reinterpret_cast<unsigned char *>(gs->imageData);
 
	cvShowImage( "Image normal loaded", img );
	cvWaitKey(2);
 
	Sleep(3000);
 
    int pix,a,b; 
    for (int i=1; i<nl-1; i++)
	{
		for (int j=1; j<nc-1; j++ ) //	for (int j=0; j<nc-1; j += image->nChannels) 
		{
			float accumulation = 0;
			float weightsum = 0; 
 
			bool bord = false;
 
			int pos = ((i*nc) +j ) * img->nChannels;
 
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					int posf = (((i+ii)*nc) + (j+jj) ) * img->nChannels;
 
					float k =  data[posf];
					accumulation += k * (kernel[1+jj][1+ii]);
					weightsum += kernel[1+jj][1+ii];
					datags[pos] = round(accumulation/weightsum);
 
				}//end loop i
			}//end loop j
		}
	}
 
/*
	CvMat* kernelmat = cvCreateMat( 3, 3, CV_32FC1);
	cvmSet( kernelmat, 0,0, -1 ); 
	cvmSet( kernelmat, 0,1, -1 );
	cvmSet( kernelmat, 0,2, -1 );
	cvmSet( kernelmat, 1,0, -1 );
	cvmSet( kernelmat, 1,1,  9 );
	cvmSet( kernelmat, 1,2, -1 ); 
	cvmSet( kernelmat, 2,0, -1 );
	cvmSet( kernelmat, 2,1, -1 );
	cvmSet( kernelmat, 2,2, -1 );
	cvFilter2D( imggray, gsgray, kernelmat);
*/
	cvShowImage( "gaussian loaded", gs );
	cvWaitKey(2000);
 
	Sleep(20);
	cvReleaseImage(&img);
	cvReleaseImage(&gs);
 
 
	return 0;
}

Mais le filtre ne donne pas vraiment le résultat que cvFilter2D() donne
Il s'agit sans doute de problème de type de données ?

Quelqu'un aurait il une idée ?

Merci

[glen1789]

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
 
int pix,a,b; 
    for (int i=0; i<nl; i++)
	{
		for (int j=0; j<nc; j++ ) //	for (int j=0; j<nc-1; j += image->nChannels) 
		{
			float accumulation = 0;
			float weightsum = 0; 
 
			bool bord = false;
 
			int pos = ((i*nc) +j ) * img->nChannels;
 
			for(int ii=-1;ii<=1;ii++)
			{
				for(int jj=-1;jj<=1;jj++)
				{   
 
					int posf = ((i*nc+ii*nc) + (j+jj) ) * img->nChannels;
 
					float k =  data[posf];
					accumulation += k * (kernel[1+jj][1+ii]);
					weightsum += kernel[1+jj][1+ii];
					if (accumulation < 0)
						datags[pos] = round(accumulation/weightsum)*-1;
					else
						datags[pos] = round(accumulation/weightsum);
				}//end loop i
			}//end loop j
	             }
	}

Je pense que le probleme viens de deux petites erreurs :les valeurs negatives que tu rentres, car si je comprends bien accumulation peut-etre negatif (je crois) et le posf qui selon moi ne pouvait pas avoir les bonnes valeurs.
Donc teste avec ce petit bout de code a la place de ta boucle et dis moi si ca marche.

[snowpy]

ben l'algo c'est juste la convolution de la matrice du filtre par ton carré de pixel ( tu peux choisir différente taille) c'est ca que tu veux comprendre ?

[Aliveli]

Glen j'ai remplacer ma boucle avec la tienne
mais le programme plante à cette ligne :

float k = data[posf];

et posf a comme valeur -741.
Ne faut-il justement pas mettre nl-1 et nc-1 pour éviter les débordements ?

Snowpy oui c'était pour bien vérifier l'algorithme

Peut être que c'est un problème avec le widthStep car à ma connaissance Opencv rajoute des pixels dans la dimension width pour avoir un contrôle sur le rapport width/heigth. ?

Merci

[Aliveli]

Par contre en ayant initialiser à 1 et pas à 0 les boucles de l'image le programme
fonctionne sans bugue mais le résultat du filtre est meiux que par rapport à mon code mais c'est pas encore le résultat voulu.

Code :

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

1
2
3
4
5
6
 
..
     for (int i=1; i<nl; i++)
	{
		for (int j=1; j<nc; j++ ) 
..

Il semble que c'est un détail qui nous échappe car l'algorithme est juste non?

Merci

[glen1789]

Moi je ne vois plus d'erreur dans l'algo (mais ca ne veut pas dire qu'il y en a pas). Mais peut-etre comme tu dis il y a un truc qui nous echappe, peut etre par rapport a comment les images sont codees en memoire. Je ne m'y connais pas assez pour t'aider sur ca. Bonne chance et tiens nous au courant si tu trouves le probleme.

[Aliveli]

Ok,

Je pense que cela vient de la manière dont Opencv ecrit etc..

car avec ce bout de code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
      CvMat* kernelmat = cvCreateMat( 3, 3, CV_32FC1);
      cvmSet( kernelmat, 0,0, -1 );
      cvmSet( kernelmat, 0,1, -1 );
      cvmSet( kernelmat, 0,2, -1 );
      cvmSet( kernelmat, 1,0, -1 );
      cvmSet( kernelmat, 1,1,  9 );
      cvmSet( kernelmat, 1,2, -1 );
      cvmSet( kernelmat, 2,0, -1 );
      cvmSet( kernelmat, 2,1, -1 );
      cvmSet( kernelmat, 2,2, -1 );
      cvFilter2D( img, gs, kernelmat);

j'ai un résultat correct alors que mon code manuel est correct aussi.
Donc soit je comprends comment et qu'estce que Opencv écrit lis dans
ces structs soit je continu avec mes boucles et utilisent alors autre chose
que ça :

unsigned char *data= reinterpret_cast<unsigned char *>(img->imageData);

pour accéder et écrire mes pixels ?

Peut être qqlq à une idée ?

Merci