Discussion :

[clement_74]

Bonjour,

je suis novice en traitement d'image et je souhaiterais avoir quelques conseils pour le traitement d'une image (voir ci-dessous)
j'aimerais "optimiser" la distinction des "grains" qu'on devine sur la photo brute en nuances de gris.
l'idéal serait de réussir à filtrer/convertir chaque nuance de gris pour en contraster sont contenu par rapport à ce qu'il y a à côté.

le simple fait de travailler sur du contraste/luminosité ne suffit pas.
j'ai essayé des méthodes de seuillage après binarisation mais je n'arrive pas à obtenir quelque chose d’intéressant.

Quel type de démarche est à envisager selon vous?
travailler en nuance de gris? appliquer quel type de filtrage/seuillage?

merci,
cordialement,

[mach1974]

il faudrait prendre GIMP et jouer avec la PCA pour avoir justement un seuillage un peu plus efficace que la binarisation pour avoir la structure des grains .
tu peux aussi essayer le seuillage avec le filtre d'OTSU .

[Guesset]

Bonjour,

Cette première utilise juste une optimisation globale. Cela rends les détails un peu plus visibles tout en restant peu sensible au bruit.

Cette seconde image commence par un filtrage sélectif (accentuations des tracés et passe bas sur les autres plages) pour atténuer le bruit sans manger les contours. Elle est suivie par une mise en évidence des contours et la saturation des couleurs.

Bien sûr on peut toujours la mettre en noir et blanc mais il est en général plus profitable de ne le faire que dans les dernières étapes à cause de l'appauvrissement des données qui en résulte.

Salutations

[wiwaxia]

Bonjour,

Il est possible, en l'absence de tout traitement préalable de l'image susceptible d'en accroître le contraste par augmentation de sa clarté, d'obtenir un contour détaillé et lisible des grains présents dans l'image; il suffit pour l'essentiel:
- de procéder à des calculs séparés pour chacune des trois composantes couleur, en faisant en sorte d'amener chacune d'entre elles à son plus grand maximum (255), ce qui favorise la préservation des détails - comme un intervenant l'a déjà signalé; et
- d'éliminer les plus faibles valeurs ne dépassant pas un seuil arbitraire, afin de faire disparaître le bruit de fond affectant inéluctablement toute méthode différentielle.

1°) On part de la matrice (Matrice_1) du corps de l'image, matrice de dimensions (Larg_ImagexHaut_Image) dont les éléments sont des pixels:

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
TYPE Pixel = ARRAY[1..3] OF Byte;
     Tab_Pix = ARRAY[0..Dim_Max, 0..Dim_Max] OF Pixel;
VAR Matrice_1, Matrice_2: Tab_Pix;

Le filtre de Sobel permet, par le calcul des composantes cartésiennes (Gx, Gy) du gradient de chaque couleur, la détermination des normes euclidiennes correspondantes

Ng = Round((Gx² + Gy²)^1/2) ,

dont on peut consigner les valeurs dans une matrice de triplets d'entiers au format Word puisqu'elles admettent pour limité supérieure: 4*255*√2 ≈ 1442 ;
D'où la première partie du programme:

Code Pascal :

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
 TYPE Tr_W    = ARRAY[1..3] OF Word;
      Tab_TW = ARRAY[0..Nmax_TW, 0..Nmax_TW] OF Tr_W;
      Tr_R   = ARRAY[1..3] OF Reel;
 
 VAR Cmax: Tr_W; Mat_PW: Tab_TW;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Calcul de la norme du gradient local pour chaque couleur
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 FUNCTION N_Grad(x, y: Z_32; VAR W_: Tr_W; VAR Ma1: Tab_Pix): Tr_W;
   VAR i: Byte; Gx2, Gy2, S1, S2: Z_32; Ng, Wm: Tr_W;
   BEGIN
     Wm:= W_;
     FOR i:= 1 TO 3 DO
       BEGIN
         S1:= 2 * Ma1[x + 1, y][i];
         Inc(S1, Ma1[x + 1, y + 1][i]); Inc(S1, Ma1[x + 1, y - 1][i]);
         S2:= 2 * Ma1[x - 1, y][i];
         Inc(S2, Ma1[x - 1, y + 1][i]); Inc(S2, Ma1[x - 1, y - 1][i]);
         Gx2:= Sqr(S1 - S2);
 
         S1:= 2 * Ma1[x, y + 1][i];
         Inc(S1, Ma1[x + 1, y + 1][i]); Inc(S1, Ma1[x - 1, y + 1][i]);
         S2:= 2 * Ma1[x, y - 1][i];
         Inc(S2, Ma1[x + 1, y - 1][i]); Inc(S2, Ma1[x - 1, y - 1][i]);
         Gy2:= Sqr(S1 - S2);
 
         Ng[i]:= Round(Sqrt(Gx2 + Gy2));
         IF (Wm[i]<Ng[i]) THEN Wm[i]:= Ng[i]
       END;
     W_:= Wm; Result:= Ng
   END;
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Calcul de la norme du gradient local pour chaque couleur
 
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 PROCEDURE Aff_CmS;
   CONST o = 9;
   BEGIN
     E(0015); Wt(5, 40, 'Cmax = ');
     E(0010); Write(Cmax[1]:o, Cmax[2]:o, Cmax[3]:o);
     E(0015); Write(' ':o, 'Seuil = ');
     E(0012); Write(Seuil:o)
   END;
 
 PROCEDURE Calc_Mat_PW(La, Ha: Z_32; VAR C_m: Tr_W; VAR Ma_: Tab_TW);
   CONST Pcoul: Tr_W = (0, 255, 255); P000: Tr_W = (0, 0, 0);
   VAR Xm, Ym: Z_32; Wmax: Tr_W; TestX, TestY: Bool;
   BEGIN
     Wmax:= P000;
     FOR Xm:= 0 TO (La - 1) DO
       BEGIN
         TestX:= (Xm=0) OR (Xm=(La - 1));
         FOR Ym:= 0 TO (Ha - 1) DO
           BEGIN
             TestY:= (Ym=0) OR (Ym=(Ha - 1));
             IF (TestX OR TestY) THEN Ma_[Xm, Ym]:= Pcoul
                                 ELSE Ma_[Xm, Ym]:= N_Grad(Xm, Ym, Wmax,
                                                           Matrice_1)
           END
       END;
     C_m:= Wmax; Aff_CmS
   END;

On mémorise au cours du balayage du tableau les valeurs maximales des normes dans la variable Cmax .

2°) Intervient alors le calcul de la matrice (Matrice_2) du corps de la seconde image, qui implique le choix d'une fonction appropriée; on peut ici envisager, sur le domaine [0 ; 1]
a) une fonction linéaire y = x ;
b) une fonction parabolique présentant une tangente horizontale y = 1 - (1 - x)² ;
c) une fonction parabolique présentant une tangente verticale y = x^1/2 ;
d) une quadrique d'équation y = 1 - (1 - x⁴)^1/4 .

En l'absence de tout seuillage, on obtient les images suivantes:

On constate que la fonction dont le graphe est le plus incurvé conduit au meilleur contraste ... mais aussi au bruit de fond le plus marqué: d'où la nécessité d'éliminer les plus faibles valeurs.

On relance donc le programme avec un seuil désormais non nul, et prenant successivement les valeurs: 25 , 30 , 35 :



Il ne subsiste ainsi que les contours désirés. Le choix de la valeur définitive est affaire d'appréciation (Seuil = 30 ?).

Code Pascal :

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
 
VAR Cmax: Tr_W; Mat_PW: Tab_TW;
 
 
(*HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
 
 Trac‚ des contours
 
HHHHHHHHHHHHHHH1HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH*)
 
 FUNCTION Min_TW(W: Tr_W): Word;
   VAR m: Word;
   BEGIN
     IF (W[1]<W[2]) THEN m:= W[1] ELSE m:= W[2];
     IF (m>W[3]) THEN m:= W[3];
     Result:= m
   END;
 
 PROCEDURE Calc_Mat_Im2_B(La, Ha: Z_32; Cm: Tr_W;
                          VAR Ma_: Tab_TW; VAR Ma2: Tab_Pix);
   CONST Max = 255.499;
   VAR i: Byte; Wmin: Word; Xm, Ym: Z_32; u, v, w: Reel;
       Px: Pixel; Tw: Tr_W; K: Tr_R;
   BEGIN;
     Wmin:= Min_TW(Cmax);
     FOR i:= 1 TO 3 DO BEGIN
                         K[i]:= 1 / (Cm[i] - Seuil)
                       END;
 
     FOR Xm:= 1 TO (La - 2) DO
       FOR Ym:= 1 TO (Ha - 2) DO
         BEGIN
           Tw:= Ma_[Xm, Ym];
           FOR i:= 1 TO 3 DO
             IF (Tw[i]>Seuil) THEN BEGIN
                                     u:= K[i] * (Tw[i] - Seuil);
                                     v:= Sqr(Sqr(1 - u));            // **
                                     w:= Sqrt(Sqrt(1 - v));          // **
                                     Px[i]:= 255 - Round(Max * w);
                                   END
                              ELSE Px[i]:= 255;
           Ma2[Xm, Ym]:= Px
         END
   END;

Le choix des fonctions intervient au niveau des deux lignes marquées d'un double astérisque, et résulte de modifications très simples affectant les expressions des variables (v) et (w):

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
                                     v:= 1 - u;                 // **
                                     w:= 1 - v;                 // ** équivalant à w:= u
 
                                     v:= Sqr(1 - u);            // **
                                     w:= 1 - v;                 // ** équivalant à w:= 1 - (1 - u)^2
 
                                     v:= Sqr(1 - u);            // **
                                     w:= Sqrt(1 - v);           // ** équivalant à w:= (1 - (1 - u)^2)^(1/2)

Comme on voit mieux des détails sombres sur fond clair, les images obtenus sont en réalité des négatifs, et le renversement résulte de l'instruction finale:

Code Pascal :

Sélectionner tout - Visualiser dans une fenêtre à part

Px[i]:= 255 - Round(Max * w);

[ToTo13]

Vu que tu souhaites extraire les grains, as tu essayé un top-hat ?