Discussion :

[avator]

Bonjour, je travaille maintenant dans l'analyse d'images de microscopie en Matlab. (des images 3D) Les images de microscopie ont souvent un très haut "background" pixelleux nous devons les filtrer (on film des chromosomes en mouvement image par image, donc imaginez le zoom!). Pour ceci nous utilisons une fonction Gauss et puisque je suis très "noob" en maths et en traitement d'image ca m'a pris un bon bout de temps à bien comprendre ce que la fonction fesait. (convolution, kernel, etc)

Mais là il semble que qqn du labo a changé la fonction pour utiliser la transformé de Fourier ce qui améliore le temps d'exécution du filtre. (ce qui est très important car nos images sont lourdes!)

Par contre, malgré toutes ses explications et malgré le pouvoir de google... je ne comprend toujours pas ce que ça fait une transformé de Fourier
En faite, j'aimerais savoir quel est l'avantage de cette chose la avec une explication simple simple Je sais ce que ca fait un Intégral mais j'en ai pas fait des compliqués et j'en ai pas fait du tout depuis 5 ans donc voila. Donc si vous auriez à expliquer a votre grand-mère pourquoi vous faites une transfo de Fourier pour une Gaussian--- ca devrait etre assez clair pour moi comme explication

Merci

[DocteurV]

Bonjour avator

Pour que tu comprennes, il faut déjà se pencher sur ce tu fais avec un filtre gaussien :
En appliquant un gaussien, tu induis une forme de flou qui a pour avantage de retirer les petits défauts. D'un point de vue "signal", ces petits défauts correspondent à des variations importantes d'intensités sur une petite longueur. Si on parlait d'un signal, on dirait que ce sont des "hautes fréquences".

La transformée de Fourier permet de décomposer un signal -- ici ton image -- en une série de descripteurs qui traduisent l'ensemble des fréquences présentes dans ton image. Pour schématiser (beaucoup), on recense toutes les fréquences présentes dans l'image et on les ordonne de la plus petite à la plus grande. De plus la transformée de Fourier a l'avantage d'être très facilement inversible : De l'image on passe facilement aux fréquences, et des fréquences on passe aisément à l'image. Ainsi, on peut (comme avec un gaussien) supprimer les hautes fréquences de l'image en créant ce qu'on appelle un filtre passe-bas :

1. On passe dans l'espace de Fourier (espace fréquentiel)
2. On supprime les données relatives aux hautes fréquences
3. On inverse la transformée de Fourier pour revenir à l'image (mais cette fois les hautes fréquences ont disparu).

Quoique les résultats soient généralement différents, ces deux traitements ont pour effet d'éliminer une partie du bruit.

[millie]

Pour calculer un flou gaussien, il y a 2 moyens standards :
- produit de convolution avec un noyau gaussien
- passage dans l'espace de Fourier

Dans le premier cas,
Si l'on veut un flou qui prenne en compte un grand nombre de pixel autour du pixel de destination, il est nécessaire d'augmenter le rayon du noyau (dans le cas d'un produit de convolution standard avec un noyau gaussien).

As-tu remarqué ce qu'il se passait lorsque l'on augmentait la taille du noyau (par exemple 30*30) ?


L'avantage de passer dans l'espace de Fourier, c'est que l'on peut appliquer un flou gaussien de n'importe quel rayon (dans ce cas, ce n'est plus vraiment un rayon) pour un même temps d'exécution.
Pour faire le plus simple possible, quand tu as un noyau de convolution G et une image I, et G*I le produit de convolution entre G et I.
Alors, si on note F la transformée de Fourier ("en général"), on a la propriété suivante : F(G * I) = F(G).F(I) Le produit de convolution (opération lente) se transforme en produit simple (opération rapide).
Pour un noyau gaussien, l'avantage étant que F(G) est une formule connue (donc pas besoin de calculer la transformée de Fourier dans le programme, c'est déjà donné par une formule mathématiques, voir 3.2 du lien suivant).

Pour plus d'informations (mais un peu compliqué) : http://humbert-florent.developpez.co...ement/fourier/

EDIT : Par contre, il existe des algorithmes rapide pour des flous gaussiens, qui marchent en général pas trop mal.
Exemple codé vite fait à partir d'une source vue sur le web (que je ne sais pas trop ce que ça fait, je sais, c'est mal) :

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
 
package filmlooking;
 
import java.awt.image.BufferedImage;
 
import millie.plugins.GenericPluginFilter;
import millie.plugins.PluginInfo;
import millie.plugins.parameters.IntSliderParameter;
 
/**
 * @author millie
 */
@PluginInfo(name = "Fast Blur", category = "Flou")
public class FastBlurFilter extends GenericPluginFilter {
 
	public FastBlurFilter() {
		setPluginName("Fast Blur");
		setRefreshable(true);
		setLongProcessing(true);
 
		addParameter(new IntSliderParameter("rayon", "Rayon", 1, 50, 3));
 
	}
 
	@Override
	public BufferedImage filter() throws Exception {
		BufferedImage input = getInputImage();
		BufferedImage output = new BufferedImage(input.getWidth(), input
				.getHeight(), input.getType());
		int rayon = getIntValue("rayon");
 
		int w = input.getWidth();
		int h = input.getHeight();
		int wm = w - 1;
		int hm = h - 1;
		int wh = w * h;
		int div = 2 * rayon + 1;
		int r[] = new int[wh];
		int g[] = new int[wh];
		int b[] = new int[wh];
		int rsum, gsum, bsum, x, y, i, p, p1, p2, yp, yi, yw;
		int vmin[] = new int[Math.max(w, h)];
		int vmax[] = new int[Math.max(w, h)];
		int[] pix = input.getRGB(0, 0, w, h, null, 0, w);
 
		int dv[] = new int[256 * div];
		for (i = 0; i < 256 * div; i++) {
			dv[i] = (i / div);
		}
 
		yw = yi = 0;
 
		for (y = 0; y < h; y++) {
			rsum = gsum = bsum = 0;
			for (i = -rayon; i <= rayon; i++) {
				p = pix[yi + Math.min(wm, Math.max(i, 0))];
				rsum += (p & 0xff0000) >> 16;
				gsum += (p & 0x00ff00) >> 8;
				bsum += p & 0x0000ff;
			}
			for (x = 0; x < w; x++) {
 
				r[yi] = dv[rsum];
				g[yi] = dv[gsum];
				b[yi] = dv[bsum];
 
				if (y == 0) {
					vmin[x] = Math.min(x + rayon + 1, wm);
					vmax[x] = Math.max(x - rayon, 0);
				}
				p1 = pix[yw + vmin[x]];
				p2 = pix[yw + vmax[x]];
 
				rsum += ((p1 & 0xff0000) - (p2 & 0xff0000)) >> 16;
				gsum += ((p1 & 0x00ff00) - (p2 & 0x00ff00)) >> 8;
				bsum += (p1 & 0x0000ff) - (p2 & 0x0000ff);
				yi++;
			}
			yw += w;
		}
 
		for (x = 0; x < w; x++) {
			rsum = gsum = bsum = 0;
			yp = -rayon * w;
			for (i = -rayon; i <= rayon; i++) {
				yi = Math.max(0, yp) + x;
				rsum += r[yi];
				gsum += g[yi];
				bsum += b[yi];
				yp += w;
			}
			yi = x;
			for (y = 0; y < h; y++) {
				pix[yi] = 0xff000000 | (dv[rsum] << 16) | (dv[gsum] << 8)
						| dv[bsum];
				if (x == 0) {
					vmin[y] = Math.min(y + rayon + 1, hm) * w;
					vmax[y] = Math.max(y - rayon, 0) * w;
				}
				p1 = x + vmin[y];
				p2 = x + vmax[y];
 
				rsum += r[p1] - r[p2];
				gsum += g[p1] - g[p2];
				bsum += b[p1] - b[p2];
 
				yi += w;
			}
		}
 
		output.setRGB(0, 0, w, h, pix, 0, w);
		return output;
	}
 
}

A vu de nez, ça ressemble au "Flou par moyenne" de photoshop.

[avator]

Merci beaucoup ^^