Problème de Fermeture des contours en Canny

**SMI66** · 23/06/2012, 14h08

Bonjour à tous
Comme le montre l'intitulé, je travaille sur un code Canny pour la détection des contours, les premières démarche fonctionnent bien sauf le seuilllage celle de -fusion- des deux seuil bas ainsi que le haut l'image est toute noire:
voilà les étapes suivies:

**Si la norme du gradient est supérieure au seuil haut, c'est un point de contour sûr, qu'on code par 1.
**Si la norme du gradient est inférieure au seuil bas, alors ce n'est pas un point de contour, qu'on code par 0.
**Si la norme du gradient est entre les deux, alors c'est un contour de fermeture, i.e un contour potentiel et qu'on code par 2. Ces contours sont transformés en contours sûrs s'ils sont adjacents à un contour codé 1.

voilà 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
 
 
/////////////////////////////////Hysteresis////////////////////////////////
					if(ddddd[g*step+h]>=sh)// || (ddddd[g*step+h]<sb))
					{
						ddddd[g*step+h]=1;
					}
					if((ddddd[g*step+h]<sh) && (ddddd[g*step+h]>=sb))
					{
						ddddd[g*step+h]=2;
					}
					if(ddddd[g*step+h]<sb)
					{
						ddddd[g*step+h]=0;
					}
				}
			}
			////////////////////////////////Fermeture//////////////////////////
			for(g=0;g<H;g++)
			{
				for(h=0;h<W;h++)
				{
					if(ddddd[g*step+h]==2)
					{
						if((ddddd[(g-1)*step+(h-1)]==1) || (ddddd[(g-1)*step+h]==1) || (ddddd[(g-1)*step+(h+1)]==1) || (ddddd[g*step+(h-1)]==1) || (ddddd[g*step+(h+1)]==1) || (ddddd[(g+1)*step+(h-1)]==1) || (ddddd[(g+1)*step+h]==1) || (ddddd[(g+1)*step+(h+1)]==1))
						{
							ddddd[g*step+h]=1;
						}
					}
				}
			}

qu'est ce qui ne vas pas au juste?
Merci pour votre attention

**takout** · 24/06/2012, 10h58

Bonjour,

Vu le titre de ton topic je ne comprends pas trop ce que tu cherches à faire.
Si tu es intéressé par la fermeture de contour, je pense que tu peux t'orienter vers la morphologie mathématique en utilisant une fermeture, ou t'orienter vers les méthodes de fermeture automatique.

**pseudocode** · 24/06/2012, 12h49

Envoyé par SMI66

qu'est ce qui ne vas pas au juste?
Merci pour votre attention

Il faut ré-appliquer la "fermeture" tant que des points potentiels (2) sont transformés en point du contour (1).

Ca permet de propager itérativement l'information de contour le long des lignes de points potentiels.

**SMI66** · 11/07/2012, 00h00

Bonsoir,
j'ai essayé d'ajouter un nombre d'itération pour que le code de fermeture re-boucle mais ca change toujours pas mon image.

voilà le code après des petites modifications :

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
for(g=0;g<H;g++) {
  for(h=0;h<W;h++) {
    if((ddddd[g*step+h]>sb) && (ddddd[g*step+h]<=sh)) {
      ddddd[g*step+h]=2;
    }
  }
}
 
while((compteur==1) && (nbreiteration<tailimg)) {
  for(g=0;g<H;g++) {
    for(h=0;h<W;h++) {
      if(ddddd[g*step+h]==2) {
        if((ddddd[(g-1)*step+(h-1)]==1) || (ddddd[(g-1)*step+h]==1) || (ddddd[(g-1)*step+(h+1)]==1) || (ddddd[g*step+(h-1)]==1) || (ddddd[g*step+(h+1)]==1) || (ddddd[(g+1)*step+(h-1)]==1) || (ddddd[(g+1)*step+h]==1) || (ddddd[(g+1)*step+(h+1)]==1)) {
          ddddd[g*step+h]=1;
          compteur=compteur+5;
        }
      }
    }
  }
  nbreiteration++;
}

S'il vous plait s'il vous plait dites moi vos remarques qu 'est ce qui ne marche pas au juste?

Merci pour votre attention

**pseudocode** · 11/07/2012, 00h24

Envoyé par SMI66

S'il vous plait s'il vous plait dites moi vos remarques qu 'est ce qui ne marche pas au juste?

Mis à part la variable "compteur" qui empêche la boucle de faire plus d'une itération, ca devrait marcher.

Bon, c'est loin d'être optimal, mais ca devrait fonctionner.

**SMI66** · 11/07/2012, 00h54

La variable "compteur" était ajouté pour reduire le temps d'éxecution.
Vous dites que ca devrai marcher aprés avoir retirer la variable "compteur" ?

**SMI66** · 11/07/2012, 01h00

J'ai lancé le programme sans utiliser "compteur" et ca tourne tjrs !
le temps d'execution est vrmt trés grand.

**pseudocode** · 11/07/2012, 01h00

Envoyé par SMI66

La variable "compteur" était ajouté pour reduire le temps d'éxecution.
Vous dites que ca devrai marcher aprés avoir retirer la variable "compteur" ?

D'après ce que je comprend du code, oui ca devrait marcher.

Pour optimiser les performances, il est préférable de ne pas retraiter tous les pixels a chaque itération mais seulement ceux qu'on a promu en HIGH.

Ca s'implémente très bien avec des listes/FIFO. En pseudocode, ca donnerait un truc du genre

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
/* les pixels au dessus du seuil haut sont  */
/* stockés dans une liste (highlist)        */
for(y=0;y<H;y++) {
  for(x=0;x<W;x++) {
    pixel = image[x][y];
    if (pixel>=HIGH) {
      highlist.push({x,y});
    }
  }
}
 
/* pour chaque pixel dans la highlist */
while( highlist.isempty() == false ) {
  x,y = highlist.pop();
 
  /* explore le voisinage 3x3 */
  neighborhood = get_8_connected(x,y);
  while( neighborhood.isempty() == false ) {
    i,j = neighborhood.pop();
    pixel = image[i][j];
 
    /* si le pixel du voisinage est entre les 2 seuils */
    /* on le considère comme étant HIGH (propagation)  */
    if (pixel>LOW && pixel<HIGH) {
      image[i][j]=HIGH;
      highlist.push({i,j});
    }
  }
 
}
 
/* on a parcouru tous les pixels de la highlist */
/* meme ceux ajoutés par propagation. On a fini */

**SMI66** · 11/07/2012, 01h12

Franchement je n'ai pas compris grand chose, en partant du principe de mon programme il est simple et répond aux conditions de fermeture sauf que ca donne pas de résultats pourtant ca doit fonctionner.
Je suis toute pérdue.
vous pouvez me simplifier l'algorithme de fermeture.
Merciii

**pseudocode** · 11/07/2012, 09h47

Envoyé par SMI66

Franchement je n'ai pas compris grand chose, en partant du principe de mon programme il est simple et répond aux conditions de fermeture sauf que ca donne pas de résultats pourtant ca doit fonctionner.
Je suis toute pérdue.
vous pouvez me simplifier l'algorithme de fermeture.
Merciii

C'est un seuillage par hystérésis, et je ne pense pas qu'on puisse faire plus simple que l'algorithme que tu as donné au post #4.

En quoi ca ne répond pas aux "conditions de fermeture" ?

**takout** · 11/07/2012, 10h02

Le seuillage par hystérésis comme sont nom l'indique va seuiler ton image.
On l'utilise pour palier les défauts d'un seuillage simple.
Si tu veux vraiment faire de la fermeture de contour il faut t'orienter vers d'autres méthodes.
En morphoMath il y a la fermeture qui va combler les vides.
Sinon il y a des algos qui vont tenter de déterminer le chemin le plus probable que doit suivre le contour, la poursuite de contour (je n'ai jamais essayé).

**saturn1** · 23/07/2012, 20h39

Envoyé par pseudocode

D'après ce que je comprend du code, oui ca devrait marcher.

Pour optimiser les performances, il est préférable de ne pas retraiter tous les pixels a chaque itération mais seulement ceux qu'on a promu en HIGH.

Ca s'implémente très bien avec des listes/FIFO. En pseudocode, ca donnerait un truc du genre

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
/* les pixels au dessus du seuil haut sont  */
/* stockés dans une liste (highlist)        */
for(y=0;y<H;y++) {
  for(x=0;x<W;x++) {
    pixel = image[x][y];
    if (pixel>=HIGH) {
      highlist.push({x,y});
    }
  }
}
 
/* pour chaque pixel dans la highlist */
while( highlist.isempty() == false ) {
  x,y = highlist.pop();
 
  /* explore le voisinage 3x3 */
  neighborhood = get_8_connected(x,y);
  while( neighborhood.isempty() == false ) {
    i,j = neighborhood.pop();
    pixel = image[i][j];
 
    /* si le pixel du voisinage est entre les 2 seuils */
    /* on le considère comme étant HIGH (propagation)  */
    if (pixel>LOW && pixel<HIGH) {
      image[i][j]=HIGH;
      highlist.push({i,j});
    }
  }
 
}
 
/* on a parcouru tous les pixels de la highlist */
/* meme ceux ajoutés par propagation. On a fini */

Bonjour, la variable image dans l'exemple donne est l'image raw en grayscale?
(car une fois le canny applique on a plus que des pixels noirs/blancs?!)

Le seuillage par hystérésis comme sont nom l'indique va seuiler ton image.
On l'utilise pour palier les défauts d'un seuillage simple.
Si tu veux vraiment faire de la fermeture de contour il faut t'orienter vers d'autres méthodes.
En morphoMath il y a la fermeture qui va combler les vides.
Sinon il y a des algos qui vont tenter de déterminer le chemin le plus probable que doit suivre le contour, la poursuite de contour (je n'ai jamais essayé).

Peux-tu citer des noms d'articles sur le morphoMath?
En gros je cherche a fermer des contours et supprimer les contours de petites tailles et qui ne matchent pas la forme principale.
Ma forme principale est approximer par un detourage plus grossier (initialisation de snake) et doit matcher avec le contour de l'image canny.

Merci de votre aide.

**takout** · 23/07/2012, 23h33

yes I !

tiens regarde la page 238 :
http://www.scribd.com/doc/40552001/3...e-des-contours

Problème de Fermeture des contours en Canny

Traitement d'images

Discussions similaires

Partager

Partager