Discussion :

[progfou]

Bonjour à tous !
J'ai une question de traitement d'images...
Supposons que l'on souhaite reconstruire un bout d'image légèrement "cassé"...
J'explique mon cas, qui peut être généralisé je pense.
J'élimine des lignes qui sont horizontales sur presque la totalité de l'image, et ce, en prenant les chrominances rouge et bleue.
Le truc, c'est de pouvoir "parfaitement" reconstruire la ligne en luminance.
En clair, je vais avoir, autour de mon résidu de ligne, des pixels ayant une valeur assez proches, et dedans, deux pixels ayant une valeur différente (plus grande), comme un contour en quelque sorte.
Mais je ne peux pas considérer ça comme un contour et je souhaite donc l'éliminer "au mieux".
Il me faut donc faire une interpolation, en utilisant les pixels valides. Pour ça, de base, je la fais avec les pixels situés au-dessus et en-dessus...

Mais peut-être que ma ligne intervient au niveau d'un contour plutôt à 45°, je prédit mal, et c'est visible !

Voilà, j'ai essayé de vous expliquer mon soucis...
Merci d'avance !

[ToTo13]

Bonjour,

s'il s'agit de ligne supprimées, tu peux faire comme ceci :
- calculer la variance et l'écart type pour chaque pixel de l'image.
- faire une transformée de hough pour les pixels ayant la plus grande variance.

Ca devrait marcher pour des droites dans n'importe quelle direction...

[ToTo13]

Bonjour,

s'il s'agit de droite supprimées dans ton image, tu peux faire ceci :
- Calculer la variance et l'écart type pour chaque pixel.
- Appliquer une transformée de Hough sur les pixels ayant une variance importante.

Ca doit être robuste pour n'importe quelle orientation de droite...

[ToTo13]

(oups, mon navigateur a merdé... il m'avait affiché un echec pour la première réponse... désolé)

[progfou]

Détecter la ou les lignes, ça fonctionne assez bien.
Mon idée, c'est plutôt que j'ai des résidus de cette ligne dans ma composante luminance, et que pour prédire avec une assez bonne précision le pixel "original", il me faut déterminer si je suis sur un contour ou non, afin de prendre les valeurs diagonales ou horizontales/verticales...
En clair, je fais ça (code matlab) :

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
for n=3:height-2
    for m=3:width-2
        if ((cr_thresh(n,m) == 0) || (cb_thresh(n,m) == 0))
            d135 = abs(x(n-2,m-2) - x(n+2,m+2)); %Estimation du gradient 135°
            d45  = abs(x(n+2,m-2) - x(n-2,m+2));
            d90  = abs(x(n-2, m)  - x(n+2, m ));
            d0   = abs(x(n, m-2)  - x(n, m+2 ));
            [dmin, ind_min] = min([d135, d45, d90, d0]);
            switch ind_min
                case 1
                    x(n,m)     = x(n-1, m-1) + (2*dmin)/5; %Interpolation suivant la "ligne" 135°
%                    x(n+1,m+1) = x(n+2, m+2) - dmin/3;
%                     x(n+1, m)  = (x(n,m)+x(n+1,m-1)+x(n,m-1))/3;
%                     x(n, m+1)  = (x(n,m)+x(n-1,m)+x(n-1,m+1))/3;
                    min_135 = min_135+1;
                    correct = correct+1;
                case 2
                     x(n, m)    = x(n+1, m-1) + (2*dmin)/5;
%                     x(n+1, m+1) = (x(n,m)+x(n+1,m)+x(n,m+1))/3;
                    min_45 = min_45+1;
                    correct = correct+1;
                case 3
                    x(n,m)   = x(n-1,m) + (2*dmin)/5;
%                    x(n+1,m) = x(n+2,m) - dmin/3;
%                     x(n,m+1) = (x(n,m)+x(n-1,m)+x(n-1,m+1))/3;
%                     x(n+1,m+1) = (x(n+1,m)+x(n,m)+x(n,m+1))/3;
                    min_90 = min_90+1;
                    correct = correct+1;
                case 4
                    x(n,m)     = x(n, m-1) + (2*dmin)/5;
%                    x(n,m+1)   = x(n, m+2) - dmin/3;
%                     x(n+1,m)   = (x(n+1,m-1)+x(n,m-1)+x(n,m))/3;
%                     x(n+1,m+1) = (x(n+1,m)+x(n,m)+x(n,m+1))/3;
                    min_0 = min_0+1;
                    correct = correct+1;
            end
        end
    end
end

Où cr/cb_thresh sont les composantes ayant 0 là où la ligne a été détectée, et 1 là où il n'y a rien à faire.

J'estime un gradient suivant les angles, mais au lieu de le faire avec les points connexes au point considéré, je vais plus loin, car la ligne a très généralement une hauteur de 2 pixels.
Je ne sais pas si je peux le faire comme ça, afin d'avoir une idée de la direction du contour, et je ne sais pas si l'interpolation réalisée est assez bonne.

D'après les résultats obtenus (cf. pièce jointe), c'est pas mal, mais pas encore "super" .
Sans le traitement, on a l'image nommée "nickel", et avec, "reconstructed"

[ToTo13]

Bonjour,

pour ce qui est des contours, il est souvent bien de les approcher avec des morceaux d'ellipses ou des chainettes.