filtre de canny

**gup** · 21/04/2007, 10h53

Bonjour,

J'essaie de mettre en place un filtre de canny. J'en suis à l'étape de non maximal suppression, mais je ne comprends pas trop ce qu'il faut faire. Quelqu'un aurait un algo clair pour cette étape s'il vous plait ?

**pseudocode** · 21/04/2007, 13h23

Dans cette etape on cherche a conserver les pixels qui participent au contour. En terme de gradient, cela signifie un "pic" dans la variation d'intensité.

Pour detecter un "pic", on regarde les pixels voisins. S'ils ont tous un gradient plus faible que le pixel observé, alors le pixel observé est un "pic".

On peut optimiser l'algorithme en regardant seulement les 2 pixels voisins qui suivent la ligne de gradient:

le pixel (x,y) observé est un "pic" si et seulement si

G(x,y) > G(xp,yp) et G(x,y) > G(xn,yn)

avec (xp,yp) et (xn,yn) les pixels precedent et suivant (dans le sens du gradient) du pixel observé, et G(x,y) = |Gx(x,y)| + |Gy(x,y)| la valeur du gradient.

Pour calculer xp,yp,xn,yn on suit la ligne de gradient:

xp = x - Gx(x,y) * scale
yp = y - Gy(x,y) * scale

et

xp = x + Gx(x,y) * scale
yp = y + Gy(x,y) * scale

avec "scale" un facteur d'echelle, permetant que (xp,yp) et (xn,yn) soient differents de (x,y). Par exemple

scale = 1 / Max( Gx(x,y) , Gy(x,y) )

Si Gx(x,y) = Gy(x,y) = 0, alors le gradient est nul ==> (x.y) n'est pas un pic

**gup** · 23/04/2007, 20h29

Je ne comprends pas tout, aurais-tu un algo qui détail cette méthode s'il te plait ?

**pseudocode** · 24/04/2007, 00h48

Mince, ca m'avait l'air clair...

bon, va pour l'algo:

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
 
private static boolean isLocalMaxima0(ImageMap c, int x, int y) {
 
	// gradient at current position
	double[] grad = gradient(c,x,y);
 
	// gradient direction
	double gx = grad[0];
	double gy = grad[1];
 
	// gradient ~= 0 => consider this is not a local maxima
	double gmax = Math.max( Math.abs(gx), Math.abs(gy) );
	if (gmax<EPSILON) return false;
 
	// scaling
	double scale = 1.0/gmax;
 
	// gradient value at next position in the gradient direction
	int nx = (int) (x + gx * scale);
	int ny = (int) (y + gy * scale);
	int ngrad = gradient(c,nx,ny);
 
	// gradient value at previous position in the gradient direction
	int px = (int) (x - gx * scale);
	int py = (int) (y - gy * scale);
	int pgrad = gradient(c, px, py);
 
	// is the current gradient value a local maxima ?
	if (norme(grad)>=norme(ngrad) && norme(grad)>=norme(pgrad)) return true;
 
	// otherwise
	return false;
}