Morphologie mathématique (images binaires)

Version imprimable

27/03/2007, 17h57
bahiatoon

Morphologie mathématique (images binaires)

Bonjour,
Je voudrai implémenter les opérateurs de morphologie mathématique (érosion, dilatation) sur des images binaires en utilisant un élément structurant carré (3x3 par exemple), j’ai trouvé des documents sur google qui expliquent la méthode mais j’ai un grand souci dés que je les implémente ça ne donne rien:aie: .
Je sais que pour certains la morphologie est très simple, mais pour moi c’est le pire de mes cauchemars:pleure: .
Si vous faites partie de ces gens la n’hésitez pas à me laisser un message ;)
27/03/2007, 18h12
roulious

Pour la dilatation, tu translates ton élément structurant en chaque point de l'image et tu affectes au point courant l'intensité maximale des points dans l'ES. Pour l'érosion, même chose avec l'intensité minimale.

En binaire, on peut avoir quelque chose de plus rapide :
Dilatation : pour chaque point P du fond, si l'ES translaté contient un point de la figure, mettre P dans la figure
Érosion : pour chaque point P de la figure, si l'ES translaté contient un point du fond, mettre P dans le fond.
27/03/2007, 18h59
bahiatoon

Salut,

Citation:

En binaire, on peut avoir quelque chose de plus rapide :
Dilatation : pour chaque point P du fond, si l'ES translaté contient un point de la figure, mettre P dans la figure
Érosion : pour chaque point P de la figure, si l'ES translaté contient un point du fond, mettre P dans le fond

plus de précision STP:coucou:

A+
27/03/2007, 19h02
roulious

Pour la dilatation, un truc du genre :

Soit P le point courant.
Si P est dans la figure, on ne fait rien de plus
Sinon, pour chaque point Q de ton élément structurant, si P+Q est dans la figure
mettre P dans la figure.

Et quelque chose de similaire pour l'érosion.
28/03/2007, 09h01
parp1

Voir voir ici j'explique dans un tutoriel les bases de la dilatation, et de l'érosion, d'une facon théorique, puis logiciel.

Essaye de nous mettre un peu de code histoire que l'on comprenne.

Cordialement.
28/03/2007, 10h42
ToTo13

Bonjour,

Pour la dilatation, tu dois utiliser deux images :
- Pour tous les pixels pleins de l'image source
Ajouter l'élément structurant à l'image résultat.

Pour l'érosion, c'est une dilatation du complémentaire.

Je ne sais pas quels cours tu as trouvé sur google, mais saches que les cours du créateur de la MorphoMath (Jean Serra, école des mines de Paris) sont en Français et d'une qualité irréprochable.

Bonne continuation...
28/03/2007, 14h17
Flo.

Salut,

en complément à toutes les réponses :

- une erosion c'est une propagation des minimas locaux (on affecte à un pixel la valeur minimale trouvée dans son entourage) : on baisse le niveau de gris moyen

- une dilatation (c'est l'inverse) c'est une propagation des maximas locaux (on affecte à un pixel la valeur maximale trouvée dans son entourage) : on augmente le niveau de gris moyen

Enfin, ces 2 opérations utilisent des filtres séparables, c'est à dire que :

erosion(de [I] par 3x3) = erosion(de [erosion(de [I] par 1x3)] par 3x1)

Ce qui est bien utile quant on tape dans des tailles de filtres importantes.

Flo.

Salut,

Citation:

Voir voir ici j'explique dans un tutoriel les bases de la dilatation, et de l'érosion, d'une facon théorique, puis logiciel.

Essaye de nous mettre un peu de code histoire que l'on comprenne.

je viens de lire ton tutorial et je suis vraiment rassuré:mrgreen:

j'ai déja implémenté les opérateurs morphologiques en niveaux de gris et je croyais que c'était différent pour les images binaires:oops:

pour l'érosion voici mon code:

Code:

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 tri[9],d1[9];
H=Image1->Picture->Bitmap->Height;
W=Image1->Picture->Bitmap->Width;
for(int x=0;x<W;x++)
        for(int y=0;y<H;y++)
        {
        a=Image1->Picture->Bitmap->Canvas->Pixels[x][y];
        b=a%256;
        g=(a/256)%256;
        r=(a/(256*256))%256;
        image[x][y]=(int)(r*0.299+g*0.587+b*0.114);
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {
                for (int i=-1;i<2;i++)
                {
                tri[i+1]=image[x+i][y-1];
                tri[i+4]=image[x+i][y];
                tri[i+7]=image[x+i][y+1];
                }
        typedef vector<int>::iterator iterator;
        int d1[9] = {tri[0],tri[1],tri[2],tri[3],tri[4],tri[5],tri[6],tri[7],tri[8]};
        vector<int>      v1(d1,d1 + 9);
        iterator it5 = min_element(v1.begin(), v1.end(),less<int>());
        Image[x][y]= *it5;
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {
        Image1->Canvas->Pixels[x][y]=(TColor)((int)(Image[x][y]+256*Image[x][y]+256*256*Image[x][y]));
        }

et pour la dilatation:

Code:

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 tri[9],d1[9];
H=Image1->Picture->Bitmap->Height;
W=Image1->Picture->Bitmap->Width;
for(int x=0;x<W;x++)
        for(int y=0;y<H;y++)
        {
        a=Image1->Picture->Bitmap->Canvas->Pixels[x][y];
        b=a%256;
        g=(a/256)%256;
        r=(a/(256*256))%256;
        image[x][y]=(int)(r*0.299+g*0.587+b*0.114);
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {
                for (int i=-1;i<2;i++)
                {
                tri[i+1]=image[x+i][y-1];
                tri[i+4]=image[x+i][y];
                tri[i+7]=image[x+i][y+1];
                }
        typedef vector<int>::iterator iterator;
        int d1[9] = {tri[0],tri[1],tri[2],tri[3],tri[4],tri[5],tri[6],tri[7],tri[8]};
        vector<int>      v1(d1,d1 + 9);
        iterator it5 = max_element(v1.begin(), v1.end(),less<int>());
        Image[x][y]= *it5;
        }
for(int x=1;x<W;x++)
        for(int y=1;y<H;y++)
        {
        Image1->Canvas->Pixels[x][y]=(TColor)((int)(Image[x][y]+256*Image[x][y]+256*256*Image[x][y]));
        }

A+

Bonjour,

Code:

1
2
3
tri[i+1]=image[x+i][y-1];
tri[i+4]=image[x+i][y];
tri[i+7]=image[x+i][y+1];

Ca fait un peu bidouillage :s au niveau programmation.

Voilà ce que je fait en Java pour une dilatation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
public static Image Dilatation(Image Original, ElementStructurant ES)
	{
	int i, j, k, l ;
	int largeur = Original.getWidth() ;
	int hauteur = Original.getHeight() ;
	int ordre = ES.getOrdre() ;
	Image image = new Image(largeur, hauteur) ;
 
	for (i=0 ; i < hauteur ; i++) // On parcour l'image
		for (j=0 ; j < largeur ; j++)
			{
			for (k=-ordre ; k < ordre+1 ; k++) // On parcours l'élément structurant
				for (l=-ordre ; l < ordre+1 ; l++)
					if ( ES.getValeur(k+ordre, l+ordre) == 1 ) // on regarde la forme de l'élément structurant
						if ( (i+k >= 0) && (i+k < hauteur) ) // on vérifit que l'on ne déborde pas
							if ( (j+l >= 0) && (j+l < largeur) ) // idem
								if ( image.getPixel(i+k,j+l) < Original.getPixel(i,j) ) image.setPixel(i+k, j+l, Original.getPixel(i,j)) ;
			}
	return image ;
	}

01/04/2007, 01h14
maamar

http://cmm.ensmp.fr/~serra/cours/index.htm