1. #1
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut [Image] Filtre de Canny pour ImageJ

    Filtre de Canny (detection de contour) pour Image J



    Code java : 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
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    import ij.IJ;
    import ij.ImagePlus;
    import ij.gui.GenericDialog;
    import ij.plugin.filter.PlugInFilter;
    import ij.process.ByteProcessor;
    import ij.process.ImageProcessor;
     
    import java.util.ArrayList;
    import java.util.List;
     
    /**
     * Canny Filter (edge detector)
     * 
     * @author Xavier Philippeau
     *
     */
    public class Canny_ implements PlugInFilter {
     
    	private int[][] gaussianKernel = null;
    	private int gaussianKernelFactor = 0;
     
    	private int lowThreshold=0;
    	private int highThreshold=0;
     
    	// About...
    	private void showAbout() {
    		IJ.showMessage("Canny...","Canny Filter by Pseudocode");
    	}
     
    	public int setup(String arg, ImagePlus imp) {
     
    		// about...
    		if (arg.equals("about")) {
    			showAbout(); 
    			return DONE;
    		}
     
    		// else...
    		if (imp==null) return DONE;
     
    		// Configuration dialog.
    		GenericDialog gd = new GenericDialog("Parameters");
    		gd.addNumericField("Gaussian kernel size",7,0);
    		gd.addNumericField("Gaussian sigma2",3.0,1);
    		gd.addNumericField("Hysteresis low value",30,0);
    		gd.addNumericField("Hysteresis high value",100,0);
     
    		int gaussianwindow = 0;
    		double gaussiansigma2 = 0;
    		int lowvalue = 0;
    		int highvalue = 0;
     
    		while(true) {
    			gd.showDialog();
    			if ( gd.wasCanceled() )	return DONE;
     
    			gaussianwindow = (int) gd.getNextNumber();
    			gaussiansigma2 = (double) gd.getNextNumber();
    			lowvalue       = (int) gd.getNextNumber();
    			highvalue      = (int) gd.getNextNumber();
     
    			if (gaussianwindow<=0) continue;
    			if (gaussiansigma2<=0) continue;
    			if (lowvalue<=0) continue;
    			if (highvalue<lowvalue) continue;
    			break;
    		}
    		gd.dispose();
     
    		initGaussianKernel(gaussianwindow,gaussiansigma2);
    		this.lowThreshold=lowvalue;
    		this.highThreshold=highvalue;
     
    		return PlugInFilter.DOES_8G;
    	}
     
    	public void run(ImageProcessor ip) {
     
    		// ImageProcessor -> ByteProcessor conversion
    		ByteProcessor bp = new ByteProcessor(ip.getWidth(),ip.getHeight());
    		for (int y = 0; y < ip.getHeight(); y++) {
    			for (int x = 0; x < ip.getWidth(); x++) {
    				bp.set(x,y,ip.getPixel(x,y));
    			}
    		}
     
    		// canny filter
    		ByteProcessor newbp = filter( bp, this.lowThreshold, this.highThreshold );
     
    		// ByteProcessor -> ImageProcessor conversion
    		ImageProcessor out = new ByteProcessor(ip.getWidth(),ip.getHeight());
    		for (int y = 0; y < ip.getHeight(); y++) {
    			for (int x = 0; x < ip.getWidth(); x++) {
    				out.set(x,y,newbp.get(x,y));
    			}
    		}
    		ImagePlus newImg = new ImagePlus("Canny Filter Result", out);
    		newImg.show();
     
    	}
     
    	// ---------------------------------------------------------------------------------
     
     
    	/**
             * Compute the gaussian kernel G(x,y) = Exp[ - (x^2+y^2)/(2*sigma^2) ]
             * 
             * @param window size of the kernel
             * @param sigma std-dev of the gaussian
             */
    	private void initGaussianKernel(int window, double sigma2) {
    		int aperture = window/2;
    		this.gaussianKernel = new int[2*aperture+1][2*aperture+1];
     
    		// factor to have only integers in the kernel 
    		int intFactor = 1000;
     
    		this.gaussianKernelFactor = 0;
    		for(int dy=-aperture;dy<=aperture;dy++) {
    			for(int dx=-aperture;dx<=aperture;dx++) {
    				double e = Math.exp( - (dx*dx+dy*dy) / (2*sigma2) );
    				int k = (int) Math.rint(intFactor * e); 
    				this.gaussianKernel[dx+aperture][dy+aperture]=k;
    				this.gaussianKernelFactor += k;
    			}
    		}
    	}
     
    	/**
             * Histogram stretching
             * 
             * @param c Image map
             */
    	public static void histogramStretch(ByteProcessor bp) {
    		int width = bp.getWidth();
    		int height = bp.getHeight();
     
    		// search min/max value in the image 
    		int min=255,max=0;
    		for (int y=0; y<height; y++) {
    			for (int x=0; x<width; x++) {
    				int v =  bp.get(x, y);
    				if (v<min) min=v;
    				if (v>max) max=v;
    			}
    		}
     
    		// compute translation table
    		int color[] = new int[256];
    		for(int i=0;i<256;i++) {
    			double t = (double)(i-min)/(double)(max-min);
    			if (t<0) t=0;
    			if (t>1) t=1;
    			int v = (int)(255*t);
    			color[i] = v;
    		}
     
    		// replace value in the image
    		for (int y=0; y<height; y++) {
    			for (int x=0; x<width; x++) {
    				int v =  bp.get(x, y);
    				bp.set(x, y, color[v]);
    			}
    		}
    	}
     
    	/**
             * Perform convolution (Image x Kernel) at a single point
             * 
             * @param c Image map
             * @param x x coord of the computation
             * @param y y coord of the computation
             * @param kernel the kernel matrix
             * @param factor the kernel factor
             * @return convolution result
             */
    	private int convolve(ByteProcessor bp, int x, int y, int[][] kernel, int factor) {
    		int width = bp.getWidth();
    		int height = bp.getHeight();
     
    		// assume a square kernel
    		int aperture = kernel[0].length/2;  
     
    		int v = 0;
    		for(int dy=-aperture;dy<=aperture;dy++) {
    			for(int dx=-aperture;dx<=aperture;dx++) {
    				int xk = x + dx;
    				int yk = y + dy;
    				if (xk<0) xk=0;
    				if (xk>=width) xk=width-1;
    				if (yk<0) yk=0;
    				if (yk>=height) yk=height-1;
    				int vk = bp.getPixel(xk,yk);
    				v += kernel[aperture+dy][aperture+dx] * vk;
    			}
    		}
    		v/=factor;
     
    		return v;
    	}
     
     
    	/**
             * Compute the local gradient
             * 
             * @param c Image map
             * @param x x coord of the computation (int)
             * @param y y coord of the computation (int)
             * @return norme and direction (-pi...pi) of the gradient
             */
    	private double[] gradient(ByteProcessor bp, int x, int y) {
    		int width = bp.getWidth();
    		int height = bp.getHeight();
     
    		int px = x - 1;  // previous x
    		int nx = x + 1;  // next x
    		int py = y - 1;  // previous y
    		int ny = y + 1;  // next y
     
    		// limit to image dimension
    		if (px < 0)	px = 0;
    		if (nx >= width) nx = width - 1;
    		if (py < 0)	py = 0;
    		if (ny >= height) ny = height - 1;
     
    		// Intesity of the 8 neighbors
    		int Ipp = bp.getPixel(px,py);
    		int Icp = bp.getPixel( x,py);
    		int Inp = bp.getPixel(nx,py);
    		int Ipc = bp.getPixel(px, y);
    		int Inc = bp.getPixel(nx, y);
    		int Ipn = bp.getPixel(px,ny);
    		int Icn = bp.getPixel( x,ny);
    		int Inn = bp.getPixel(nx,ny);
     
    		// Local gradient
    		double r2 = 2*Math.sqrt(2);
    		double gradx = (Inc-Ipc)/2.0 + (Inn-Ipp)/r2 + (Inp-Ipn)/r2; // horizontal + 2 diagonals
    		double grady = (Icn-Icp)/2.0 + (Inn-Ipp)/r2 + (Ipn-Inp)/r2; // vertical + 2 diagonals
     
    		// compute polar coordinates
    		double norme = Math.sqrt(gradx*gradx+grady*grady);
    		double angle = Math.atan2(grady, gradx);
     
    		// multiply norme by 8/3, to have the same values as Sobel Kernel 3x3
    		return new double[] { norme*8.0/3.0, angle };
    	}
     
     
    	/**
             * Compute the local gradient (subpixel with bilinear interpolation)
             * 
             * @param c Image map
             * @param x x coord of the computation (double)
             * @param y y coord of the computation (double)
             * @return norme and direction (-pi...pi) of the gradient
             */
    	 private double[] gradientInterpolated(ByteProcessor bp, double x, double y) {
     
    		 double wx = x - (int)x;
    		 double wy = y - (int)y;
     
    		 double[] Gpp = gradient(bp,(int)x,(int)y);
    		 double[] Gnp = gradient(bp,(int)x+1,(int)y);
    		 double[] Gpn = gradient(bp,(int)x,(int)y+1);
    		 double[] Gnn = gradient(bp,(int)x+1,(int)y+1);
     
    		 double norme = (1-wx)*(1-wy)*Gpp[0] + wx*(1-wy)*Gnp[0] + (1-wx)*wy*Gpn[0] + wx*wy*Gnn[0];
    		 double angle = (1-wx)*(1-wy)*Gpp[1] + wx*(1-wy)*Gnp[1] + (1-wx)*wy*Gpn[1] + wx*wy*Gnn[1];
     
    		 return new double[] { norme, angle };
    	 }
     
     
    	/**
             * compute if a position is a local maxima
             * 
             * @param c Image map
             * @param x x coord of the computation
             * @param y y coord of the computation
             * @return true if position is a local maxima
             */
    	private boolean isLocalMaxima(ByteProcessor bp, int x, int y) {
     
    		// gradient at current position
    		double[] grad = gradient(bp,x,y);
     
    		// gradient direction
    		double gx = Math.cos(grad[1]);
    		double gy = Math.sin(grad[1]);
     
    		// gradient value at next position in the gradient direction
    		double nx = x + gx;
    		double ny = y + gy;
    		double[] gradn = gradientInterpolated(bp,nx,ny);
     
    		// gradient value at previous position in the gradient direction
    		double px = x - gx;
    		double py = y - gy;
    		double[] gradp = gradientInterpolated(bp,px,py);
     
    		// is the current gradient value a local maxima ?
     
    		// synthetic image
    		if (grad[0]==gradn[0] && grad[0]!=gradp[0]) return (x>nx || y>ny);
    		if (grad[0]!=gradn[0] && grad[0]==gradp[0]) return (x>px || y>py);
     
    		// real world image
    		double EPSILON=1E-7;
    		if ((grad[0]-gradn[0])<EPSILON) return false;
    		if ((grad[0]-gradp[0])<EPSILON) return false;
     
    		return true;
    	}
     
    	/**
             * Perfom Canny filtering
             * 
             * @param c Image map
             * @param lowThreshold low value of the hysteresis
             * @param highThreshold high value of the hysteresis
             * @return filtered image map
             */
    	public ByteProcessor filter(ByteProcessor c, int lowThreshold, int highThreshold) {
    		int width = c.getWidth();
    		int height = c.getHeight();
     
    		// Gaussian filter
    		ByteProcessor bpg = new ByteProcessor(width,height);
    		for (int y=0; y<height; y++) {
    			for (int x=0; x<width; x++) {
    				int v = convolve(c,x,y,this.gaussianKernel,this.gaussianKernelFactor);
    				bpg.set(x,y,v);
    			}
    		}
     
    		// histogram stretching (compensate the loss of energy caused by gaussian filtering)
    		histogramStretch(bpg);
     
    		ByteProcessor out = new ByteProcessor(width,height);
    		List<int[]> highpixels = new ArrayList<int[]>();
     
    		// gradient thresholding
    		for (int y=0; y<height; y++) {
    			for (int x=0; x<width; x++) {
     
    				// gradient intesity
    				double g = gradient(bpg,x,y)[0];
     
    				// low-threshold -> not an edge
    				if (g<lowThreshold) continue;
     
    				// not a local maxima -> not an edge
    				if (!isLocalMaxima(bpg,x,y)) continue;
     
    				// high-threshold -> is an edge
    				if (g>highThreshold) {
    					out.set(x,y,255);
    					highpixels.add(new int[]{x,y});
    					continue;
    				}
     
    				// between thresholds -> "unknown state" (depends on neighbors)
    				out.set(x,y,128);
    			}
    		}
     
    		// edge continuation
    		int[] dx8 = new int[] {-1, 0, 1, 1, 1, 0,-1,-1};
    		int[] dy8 = new int[] {-1,-1,-1, 0, 1, 1, 1, 0};
    		List<int[]> newhighpixels = new ArrayList<int[]>();
     
    		while(!highpixels.isEmpty()) {
    			newhighpixels.clear();
    			for(int[] pixel : highpixels) {
    				int x=pixel[0], y=pixel[1];
     
    				// move low-state pixel in the 3x3 neighborhood to high-state
    				for(int k=0;k<8;k++) {
    					int xk=x+dx8[k], yk=y+dy8[k];
    					if (xk<0 || xk>=width) continue;
    					if (yk<0 || yk>=height) continue;
    					if (out.get(xk, yk)==128) {
    						out.set(xk, yk, 255);
    						newhighpixels.add(new int[]{xk, yk});
    					}
    				}
    			}
     
    			// swap highpixels lists
    			List<int[]> swap = highpixels; highpixels = newhighpixels; newhighpixels = swap;
    		}
     
    		// remove remaining low-state pixels
    		for (int y=0; y<height; y++)
    			for (int x=0; x<width; x++)
    				if (out.get(x, y)!=255) out.set(x,y,0);
     
    		return out;
    	}
    }

    Edit: J'ai reposté la version complete du filtre, avec utilsation du gradient vectoriel, interpolation bi-lineaire et extension d'histogramme... Necessite de compiler avec un compilateur java 5 (ou +) => ne pas utiliser l'option "compil & run" de ImageJ

    PRomu@ld : sources
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  2. #2
    Membre régulier
    Profil pro
    Inscrit en
    janvier 2006
    Messages
    118
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : janvier 2006
    Messages : 118
    Points : 109
    Points
    109

    Par défaut

    Merci pour tout ce boulot !
    Je m'en suis inspiré, car j'étais justement entrain d'implémenter cette méthode (faut croire que c'est à la mode Canny en ce moment. En tous cas, le hasard fait bien les choses ! ).
    Je dis ptet une connerie, mais une ligne me semble bizarre :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    // gradient direction
    double gx = Math.cos(grad[1]);
    double gy = -Math.sin(grad[1]);
    perso, j'utilise ceci et ça marche beaucoup mieux :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    // gradient direction
    double gx = Math.cos(grad[1]);
    double gy = Math.sin(grad[1]);
    C'est ptet juste parce que le reste de mon code n'est pas pareil, mais j'avoue que ce " - " me semble bizarre...

    Mais dans tous les cas, merci pour cette formidable contribution !

    Fumidu
    Vous aussi, passez pour un dieu du bon français grâce à Firefox et sa correction orthographique

  3. #3
    Rédacteur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 937
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2006
    Messages : 6 937
    Points : 9 555
    Points
    9 555

    Par défaut

    Je l'ai porté pour ma biblio, mais je trouve le code des fois un peu pas super. Pis pas vraiment sécurisé :p
    Enfin, merci quand même pour ça

    Tu peux me donner un exemple d'appel qui marche (genre tu as mis quoi pour l'exemple dans seuilHaut, seuilBas et le sigma (et le rayon))
    Je ne répondrai à aucune question technique en privé

  4. #4
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par fumidu
    C'est ptet juste parce que le reste de mon code n'est pas pareil, mais j'avoue que ce " - " me semble bizarre...
    AAAAAAAAARRRRRRRRRRRRRRRGGGGGGGGGG !!!!!

    Je viens de me rendre compte que j'ai inversé les kernels de Sobel X et Y !

    D'un autre coté, comme j'ai inversé aussi la convolution, ca ne se voit pas.

    J'ai tout remis d'aplomb et j'en ai profité pour changer les signes du kernel de Sobel Y, afin de ne plus avoir le signe - devant le sinus.

    Mais dans tous les cas, merci pour cette formidable contribution !
    lol. N'exagerons pas quand meme, ca reste du filtrage de base.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  5. #5
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par millie
    Je l'ai porté pour ma biblio, mais je trouve le code des fois un peu pas super. Pis pas vraiment sécurisé :p
    Enfin, merci quand même pour ça
    Bah j'hesite a ecrire du code Java optimisé, car on risque de ne plus comprendre l'algo. (en particulier la continuation des contours: le ArrayList c'est pas optimisé, mais c'est plus clair)

    Le but c'est quand meme de comprendre l'algo et pas de repomper le code

    Citation Envoyé par millie
    Tu peux me donner un exemple d'appel qui marche (genre tu as mis quoi pour l'exemple dans seuilHaut, seuilBas et le sigma (et le rayon))
    Pour le kernel gaussien, generalement je met WindowSize=5 et sigma=1.4

    Pour les seuils, comme je n'ai pas normalisé le gradient, on va avoir des valeurs entre 0 et 4*255.

    Pour ma copine Lena Soderberg, j'ai testé avec Low=30 et High=100:
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  6. #6
    Rédacteur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 937
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2006
    Messages : 6 937
    Points : 9 555
    Points
    9 555

    Par défaut

    Youpi, ça marche.

    J'ai perdu 1 heure car un fichier n'avait pas été recompilé

    Bon, maintenant, on va chercher à comprendre l'algo
    Je ne répondrai à aucune question technique en privé

  7. #7
    gup
    gup est déconnecté
    Nouveau membre du Club
    Profil pro
    Inscrit en
    juin 2005
    Messages
    39
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2005
    Messages : 39
    Points : 28
    Points
    28

    Par défaut canny

    merci pour ce code

  8. #8
    Rédacteur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 937
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2006
    Messages : 6 937
    Points : 9 555
    Points
    9 555

    Par défaut

    J'ai une question, entre l'unoise inpaint et là, j'ai remarqué que les calculs du gradient se fait de deux manières :

    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
    void InpaintOperator::gradient(const Image& c, int x, int y, int canal, float * norme, float * angle)
    {
        int width = c.getWidth();
        int height = c.getHeight();
    
        const float cst1 = (0.25f*(2-sqrt(2.0f)));
        const float cst2 = (0.5f*(sqrt(2.0f)-1.0f));
    
        int px = x-1;
        int nx = x+1;
        int py = y-1;
        int ny = y+1;
        if (px<0)
            px=0;
        if (nx>=width)
            nx=width-1;
        if (py<0)
            py=0;
        if (ny>=height)
            ny=height-1;
    
        float Ipp=c.getPixel(px,py, canal);
        float Ipc=c.getPixel(px,y, canal) ;
        float Ipn=c.getPixel(px,ny, canal);
        float Icp=c.getPixel(x,py, canal);
        float Icn=c.getPixel(x,ny, canal);
        float Inp=c.getPixel(nx,py, canal);
        float Inc=c.getPixel(nx,y, canal) ;
        float Inn=c.getPixel(nx,ny, canal);
    
        float IppInn = cst1*(Inn-Ipp);
        float IpnInp = cst1*(Ipn-Inp);
        float gradx = (IppInn-IpnInp-cst2*Ipc+cst2*Inc);
        float grady = (IppInn+IpnInp-cst2*Icp+cst2*Icn);
    
        *norme = sqrt( gradx*gradx + grady*grady );
    
        *angle = 0.0f;
        if (*norme>0.01f)
        {
            *angle = acos(gradx/ *norme);
            if (grady>0.01f)
                *angle = 2.0f*M_PI - *angle;
        }
    
        *norme/=255.0f;
    
    }
    Ou :
    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
    static void computeGradient(Image & c, int x, int y, int canal, float & norme, float & angle)
    {
      static const KernelSobelHorizontal sobelY;
      static const KernelSobelVertical sobelX;
      float gx = convolvePosition(c, x, y, canal, sobelX);
      float gy = convolvePosition(c, x, y, canal, sobelY);
    
      norme = sqrt(gx*gx+gy*gy);
      angle = 0.0f;
      if (norme>0.00f)
      {
        angle = acos(gx/ norme);
        if (gy>0.00f)
          angle = 2.0f*M_PI - angle;
      }
    }
    Pourquoi cette différence ?

    EDIT ; Ah, en fait, ça provient de l'algorithmique de Canny : http://fr.wikipedia.org/wiki/Canny
    Je ne répondrai à aucune question technique en privé

  9. #9
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par millie
    J'ai une question, entre l'unoise inpaint et là, j'ai remarqué que les calculs du gradient se fait de deux manières :

    Pourquoi cette différence ?

    EDIT ; Ah, en fait, ça provient de l'algorithmique de Canny : http://fr.wikipedia.org/wiki/Canny
    En fait, ces 2 ecritures sont equivalentes. La 1ere est une approche plus "geometrique" (calcul de pente) et la 2nde une approche plus matricielle (transformations). La 1ere est plus précise, et peut etre affinée/simplifiée/généralisée suivant les besoins.

    Calcul de la formule geometrique pour l'axe X:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    Voisinage du pixel I
    
    -------------
    |Ipp|   |Inp|
    |   |   |   |
    -------------
    |Ipc| I |Inc|
    |   |   |   |
    -------------
    |Ipn|   |Inn|
    |   |   |   |
    -------------
    La notation signifie: Ipp = I[previous][previous], Icp = I[current][previous], Ipn = I[previous][next], ... = intensité du pixel en (x,y)

    Pour calculer le gradient sur X, on va calculer la pente sur X du plan centré en I et qui s'appuie sur les pixels voisins.

    Si on regarde en coupe, en considerant que l'intensité du pixel représente une altitude, on a :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    intensité
    ^
    |
    |          Inc
    |           X
    |  Ipc      |
    |   X       |
    |   |       |
    |   |       |
    +---|---|---|----> x du pixel
       x-1  x  x+1
    Si on considere seulement les 2 pixels Inc et Ipc, la pente sur X vaut donc: Inc-Ipc / 2

    On peut maintenant affiner en ajoutant les pixels Ipp et Inn, ... Pour cela, il suffit de tourner notre plan de coupe pour qu'il contienent les point Ipp, I et Inn.

    Dans ce nouveau plan, la pente sur X est Inn-Ipp / 2*Racine(2) .
    Idem sur le plan Ipn,I,Inp

    La formule du gradient sur X est donc
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
            Inc-Ipc     Inn-Ipp       Inp-Ipn
    Gradx = ------- + ----------- + -----------
               2      2*Racine(2)   2*Racine(2)
    Note: Les coefficients dans le code de la fonction "inpaint/unnoise" sont pré-normalisés en divisant cette formule par 2+2*racine(2).

    Donc, on peut remplacer le calcul du gradient par Sobel par celui la (*)

    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
    private double[] gradient(Channel c, int x, int y) {
    	int width = c.getWidth();
    	int height = c.getHeight();
    
    	int px = x - 1;  // previous x
    	int nx = x + 1;  // next x
    	int py = y - 1;  // previous y
    	int ny = y + 1;  // next y
    		
    	// limit to image dimension
    	if (px < 0)	px = 0;
    	if (nx >= width) nx = width - 1;
    	if (py < 0)	py = 0;
    	if (ny >= height) ny = height - 1;
    		
    	// Intensity of the 8 neighbors
    	int Ipp = c.getValue(px,py);
    	int Icp = c.getValue( x,py);
    	int Inp = c.getValue(nx,py);
    	int Ipc = c.getValue(px, y);
    	int Inc = c.getValue(nx, y);
    	int Ipn = c.getValue(px,ny);
    	int Icn = c.getValue( x,ny);
    	int Inn = c.getValue(nx,ny);
    		
    	// Local gradient
    	double r2 = 2*Math.sqrt(2);
    	double gradx = (Inc-Ipc)/2.0 + (Inn-Ipp)/r2 + (Inp-Ipn)/r2; // horizontal + 2 diagonals
    	double grady = (Icn-Icp)/2.0 + (Inn-Ipp)/r2 + (Ipn-Inp)/r2; // vertical + 2 diagonals
    		
    	// compute polar coordinates
    	double norme = Math.sqrt(gradx*gradx+grady*grady);
    	double angle = Math.atan2(grady, gradx);
    		
    	// multiply norme by 8/3, to have the same value as Sobel Kernel 3x3
    	return new double[] { 8*norme/3, angle };  
    }
    (*) ca permettra aux pompeurs de code d'avoir des versions differentes et d'eviter le 0/20 pour "copie sauvage"
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  10. #10
    Membre averti Avatar de Flo.
    Homme Profil pro
    Inscrit en
    mai 2002
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : mai 2002
    Messages : 379
    Points : 402
    Points
    402

    Par défaut

    Bonjour,

    D'abord, je suis content qu'une telle rubrique existe ... de même qu'un forum spécifique au traitement d'image.

    Le résultat a l'air correct. Par contre, je me permets de signaler qu'il y a quelques erreurs, il me semble (je ne suis pas un expert ).

    Dans l'approche donnée par Canny de la détection des contours, je crois me rappeler qu'une des 3 contraintes de la problématique est liée à l'unicité de la réponse. C'est à dire qu'un contour est détecté une seule fois ... Si on ajoute à cela, les 2 autres contraintes "bonne localisation" et "bonne détection", je crois que le résultat n'est pas satisfaisant.

    Sur l'image résultat, on peut effectivement trouver des amas de pixels qui ne devraient pas exister. Je les ai entourés en rouge.



    Bon après ça peut venir de mauvais réglages ou autres ... à voir.

    J'ai pas pris le temps de lire correctement le code ... mais souvent ce genre de résultats vient de l'absence d'interpolation quant à la détection des maximas.

    Si ça peut aider ...

    J'ai vu également qu'il y avait un lissage gaussien (j'en suis pas sur)... attention car la limite entre un lissage et un flou est floue (pas fait exprés !!!) : un lissage est un flou. Et un flou n'est pas recommandé pour une extraction de contours.

    N'hésitez pas à me dire si je me vourvoie totalement .

    Encore bravo et merci pour le code.

    Flo.

  11. #11
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par Flo.
    Le résultat a l'air correct. Par contre, je me permets de signaler qu'il y a quelques erreurs, il me semble (je ne suis pas un expert ).
    Il y a largement plus que "quelques" erreurs...

    Le filtre donné ici est vraiment hyper basique. La detection est basée sur la norme d'un gradient approximatif ( ) et la detection sur l'intensité des 2 pixels voisins (re ). Les résultats sont donc plutot moyen.

    Je n'ai pas ecrit ce bout de code pour fournir un filtre de contour hautement efficace (ca se saurait). Il y a plein de logiciel/code qui existent et qui font cela tres bien. L'idée est plus d'avoir une base pour assimiler le principe, comprendre les limitations et si necessaire ameliorer le fonctionnement.

    Si cela vous tente, vous pouvez poster vos améliorations.... par exemple un meilleur gradient (surface 3D, sub pixel), une meilleur detection (minmod, hessiane, ...). La plupart de ces techniques sont expliquées ici ou ailleurs.

    J'ai pas pris le temps de lire correctement le code ... mais souvent ce genre de résultats vient de l'absence d'interpolation quant à la détection des maximas.
    Oui, c'est exact. Voici une amélioration possible:

    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
    private double gradientNormeInterpolated(Channel c, double x, double y) {
    	double wx = x - (int)x;
    	double wy = y - (int)y;
    		 
    	double Gpp = gradient(c,(int)x,(int)y)[0];
    	double Gnp = gradient(c,(int)x+1,(int)y)[0];
    	double Gpn = gradient(c,(int)x,(int)y+1)[0];
    	double Gnn = gradient(c,(int)x+1,(int)y+1)[0];
    		 
    	double g = (1-wx)*(1-wy)*Gpp + wx*(1-wy)*Gnp + (1-wx)*wy*Gpn + wx*wy*Gnn;
    	return g;
    }
    
    private boolean isLocalMaxima(ByteProcessor c, int x, int y) {
    (...)
    	// gradient value at next position in the gradient direction
    	double nx = x + gx * scale;
    	double ny = y + gy * scale;
    	double gradn = gradientNormeInterpolated(c,nx,ny);
    			
    	// gradient value at previous position in the gradient direction
    	double px = x - gx * scale;
    	double py = y - gy * scale;
    	double gradp = gradientNormeInterpolated(c,px,py);
    
    	// is the current gradient value a local maxima ?
    	if (grad[0]>gradn && grad[0]>gradp) return true;
    (...)
    }


    J'ai vu également qu'il y avait un lissage gaussien (j'en suis pas sur)... attention car la limite entre un lissage et un flou est floue (pas fait exprés !!!) : un lissage est un flou. Et un flou n'est pas recommandé pour une extraction de contours.
    Non ! Au contraire, abusez du flou. Le lissage permet d'attenuer les "faux positifs" (les fausses detections de contours dues au bruit). Pour autant, les vrais contours seront toujours présents car le lissage ne fait pas disparaitre les maxima. Ils sont juste "moins haut". ll faudra donc baisser le seuil de detection.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  12. #12
    Membre averti Avatar de Flo.
    Homme Profil pro
    Inscrit en
    mai 2002
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations forums :
    Inscription : mai 2002
    Messages : 379
    Points : 402
    Points
    402

    Par défaut

    Non ! Au contraire, abusez du flou. Le lissage permet d'attenuer les "faux positifs" (les fausses detections de contours dues au bruit). Pour autant, les vrais contours seront toujours présents car le lissage ne fait pas disparaitre les maxima. Ils sont juste "moins haut". ll faudra donc baisser le seuil de detection.
    Je ne suis pas tout à fait d'accord. Dans ce cas, pourquoi pas un filtre médian plutôt. Le flou va diminuer le gradient et risque "d'étaler" le contour. J'ai bien vu sur le site de Wikipedia qu'ils préconisaient (le ou les auteurs de l'article) un lissage. Mais je ne considère pas que le lissage doive faire partie intégrale de l'algo d'un extracteur de contours.

    Libre aux gens d'utiliser ou pas un lissage. Qui plus est, libre aux gens d'utiliser un autre opérateur de lissage que celui que tu proposes.

    Quant à abuser du flou ... dire qu'il y en a qui se prennent la tête pour faire des photos nettes . Autant les prendre floues dès le début.

    Enfin bref, ton résultat ton semble plus correct ...

    Bravo encore ... Bien des gens seront contents d'avoir ce type d'algo à disposition.

    Flo.

  13. #13
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par Flo.
    Mais je ne considère pas que le lissage doive faire partie intégrale de l'algo d'un extracteur de contours
    Dans le "cas general" d'un extracteur de contours : non.

    Dans le cas de canny qui utilise "gradient" et "maxima locaux du gradient": oui

    Le calcul du gradient est extremement sensible au bruit. Et meme avec une photo tres propre, les images réelles on beaucoup de bruit. Ce n'est pas le cas avec les images de syntheses (c'est a ca qu'on les reconnait).

    Quant à abuser du flou ... dire qu'il y en a qui se prennent la tête pour faire des photos nettes . Autant les prendre floues dès le début.
    lol. T'as deja vu mes photos, on dirait

    Non, sans rire, le lissage gaussien ne supprime pas (trop) les informations de contours. C'est vrai qu'il supprime (plus) les informations de contraste, ce qui visuellement nous donne l'impression que l'image est deteriorée. Mais les maximas et minimas sont toujours la, et a la meme place.

    Enfin bref, ton résultat semble plus correct ...
    Plus on affine les calculs, plus ca devient beau. Le mieux c'est de passer en sub-pixel et de calculer le passage par zero du laplacien (dans le sens du gradient). Mais ca sort du cadre de ce post
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  14. #14
    Rédacteur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 937
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2006
    Messages : 6 937
    Points : 9 555
    Points
    9 555

    Par défaut

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    	double px = x - gx * scale;
    	double py = y - gy * scale;
    	double gradp = gradientNormeInterpolated(c,px,py);
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    private double gradientNormeInterpolated(Channel c, double x, double y) {
    	double wx = x - (int)x;
    	double wy = y - (int)y;
    		 
    	double Gpp = gradient(c,(int)x,(int)y)[0];
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    private double[] gradient(Channel c, int x, int y) {
    ...
    
    	int Icp = c.getValue( x,py);
    Il y a un risque non négligeable que x soit hors borne dans cette suite d'appel. J'ai eu en fait le problème, et j'ai dû vérifier la valeur de x et de y au moment de l'appel : double Gpp = gradient(c,(int)x,(int)y)[0];. Je suis étonné que ça ait marché chez toi sans lancé d'exception. ?
    Je ne répondrai à aucune question technique en privé

  15. #15
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par millie
    Je suis étonné que ça ait marché chez toi sans lancé d'exception. ?
    Ca marche parceque le code de Channel.getValue(x,y) me protege des depassements:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    public int getValue(int x,int y) {
    	if (x<0) return x=0;
    	if (x>=this.width) return x=this.width-1;
    	if (y<0) return y=0;
    	if (y>=this.height) return y=this.height-1;
    	return this.values[x][y];
    }
    On va pas se compliquer la vie, quand meme.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  16. #16
    Modérateur
    Avatar de ToTo13
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    janvier 2006
    Messages
    5 729
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 729
    Points : 9 725
    Points
    9 725

    Par défaut

    Bonjour,

    je viens de faire un "Compile and Run" de cette classe par ImageJ et j'ai l'erreur suivante :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    Note: sun.tools.javac.Main has been deprecated.
    /Applications/ImageJ/plugins/Filters/Canny_.java:350: '(' expected.
    		List<int[]> pixels = new ArrayList<int[]>();
    		                                  ^
    1 error, 1 warning
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  17. #17
    Rédacteur

    Avatar de millie
    Profil pro
    Inscrit en
    juin 2006
    Messages
    6 937
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : juin 2006
    Messages : 6 937
    Points : 9 555
    Points
    9 555

    Par défaut

    N'as tu pas une vieille version du JDK ? Le tiens peut il utiliser les generics ?
    Je ne répondrai à aucune question technique en privé

  18. #18
    Modérateur
    Avatar de ToTo13
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    janvier 2006
    Messages
    5 729
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Santé

    Informations forums :
    Inscription : janvier 2006
    Messages : 5 729
    Points : 9 725
    Points
    9 725

    Par défaut

    Non, j'ai une mise à jour automatique
    Consignes aux jeunes padawans : une image vaut 1000 mots !
    - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe, mettre les ACCENTS et les BALISES) => ECRIRE clairement et en Français tu DOIS.
    - Le côté obscur je sens dans le MP => Tous tes MPs je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci)
    - ton poste tu dois marquer quand la bonne réponse tu as obtenu.

  19. #19
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    10 027
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : décembre 2006
    Messages : 10 027
    Points : 15 578
    Points
    15 578

    Par défaut

    Citation Envoyé par ToTo13 Voir le message
    Non, j'ai une mise à jour automatique
    Le plugin "compile and run" d'ImageJ ne sait pas compiler les sources en version 5 ou 6. Il faut compiler le filtre a la main.

    1. creer/copier le fichier "Canny_.java" dans ImageJ/plugins/Filters
    2. Dans un shell, se déplacer dans le repertoire racine d'ImageJ et lancer la commande:
    Code shell : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    javac  -classpath  ij.jar  plugins/Filters/Canny_.java
    3. Executer ImageJ. Le filtre doit etre dispo dans le menu Plugins->Filters
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

Discussions similaires

  1. Filtre de Canny pour Image
    Par amanimona dans le forum Images
    Réponses: 3
    Dernier message: 04/06/2014, 07h29
  2. [Image] Détecteur de Harris pour ImageJ
    Par pseudocode dans le forum Contribuez
    Réponses: 91
    Dernier message: 22/01/2013, 23h44
  3. Réponses: 0
    Dernier message: 22/04/2008, 12h49
  4. [Image] Filtre UnNoise pour ImageJ
    Par pseudocode dans le forum Contribuez
    Réponses: 37
    Dernier message: 07/03/2008, 16h23
  5. [Image] Filtre UnNoise pour ImageJ
    Par pseudocode dans le forum Général Algorithmique
    Réponses: 10
    Dernier message: 03/04/2007, 23h38

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo